feat: Git extension stage 2 — GIT_BRANCH_NAME override, --force for existing dirs, auto-install tests (#1940) (#2117)

* feat: Git extension stage 2 — GIT_BRANCH_NAME override, --force for existing dirs, auto-install tests (#1940)

- Add GIT_BRANCH_NAME env var override to create-new-feature.sh/.ps1
  for exact branch naming (bypasses all prefix/suffix generation)
- Fix --force flag for 'specify init <dir>' into existing directories
- Add TestGitExtensionAutoInstall tests (auto-install, --no-git skip,
  commands registered)
- Add TestFeatureDirectoryResolution tests (env var, feature.json,
  priority, branch fallback)
- Document GIT_BRANCH_NAME in speckit.git.feature.md and specify.md

* fix: remove unused Tuple import (ruff F401)

* fix: address Copilot review feedback (#2117)

- Fix timestamp regex ordering: check YYYYMMDD-HHMMSS before generic
  numeric prefix in both bash and PowerShell
- Set BRANCH_SUFFIX in GIT_BRANCH_NAME override path so 244-byte
  truncation logic works correctly
- Add 244-byte length check for GIT_BRANCH_NAME in PowerShell
- Use existing_items for non-empty dir warning with --force
- Skip git extension install if already installed (idempotent --force)
- Wrap PowerShell feature.json parsing in try/catch for malformed JSON
- Fix PS comment: 'prefix lookup' -> 'exact mapping via Get-FeatureDir'
- Remove non-functional SPECIFY_SPEC_DIRECTORY from specify.md template

* fix: address second round of Copilot review feedback (#2117)

- Guard shutil.rmtree on init failure: skip cleanup when --force merged
  into a pre-existing directory (prevents data loss)
- Bash: error on GIT_BRANCH_NAME >244 bytes instead of broken truncation
- Fix malformed numbered list in specify.md (restore missing step 1)
- Add claude_skills.exists() assert before iterdir() in test

* fix: use UTF-8 byte count for 244-byte branch name limit (#2117)

- Bash: use LC_ALL=C wc -c for byte length instead of ${#VAR}
- PowerShell: use [System.Text.Encoding]::UTF8.GetByteCount() instead
  of .Length (UTF-16 code units)

* fix: address third round of review feedback (#2117)

- Update --dry-run help text in bash and PowerShell (branch name only)
- Fix specify.md JSON example: use concrete path, not literal variable
- Add TestForceExistingDirectory tests (merge + error without --force)
- Add PowerShell Get-FeaturePathsEnv tests (env var + feature.json)

* fix: normalize relative paths and fix Test-HasGit compat (#2117)

- Bash common.sh: normalize SPECIFY_FEATURE_DIRECTORY and feature.json
  relative paths to absolute under repo root
- PowerShell common.ps1: same normalization using IsPathRooted + Join-Path
- PowerShell create-new-feature.ps1: call Test-HasGit without -RepoRoot
  for compatibility with core common.ps1 (no param) and git-common.ps1
  (optional param with default)

* test: add GIT_BRANCH_NAME automated tests for bash and PowerShell (#2117)

- TestGitBranchNameOverrideBash: 5 tests (exact name, sequential prefix,
  timestamp prefix, overlong rejection, dry-run)
- TestGitBranchNameOverridePowerShell: 4 tests (exact name, sequential
  prefix, timestamp prefix, overlong rejection)
- Tests use extension scripts (not core) via new ext_git_repo and
  ext_ps_git_repo fixtures

* fix: restore git init during specify init + review fixes (#2117)

- Restore is_git_repo() and init_git_repo() functions removed in stage 2
- specify init now runs git init AND installs git extension (not just
  extension install alone)
- Add is_dir() guard for non-here path to prevent uncontrolled error
  when target exists but is a file
- Add python3 JSON fallback in common.sh for multi-line feature.json
  (grep pipeline fails on pretty-printed JSON without jq)

* fix: use init_git_repo error_msg in failure output (#2117)

* fix: ensure_executable_scripts also covers .specify/extensions/ (#2117)

Extension .sh scripts (e.g. create-new-feature.sh, initialize-repo.sh)
may lack execute bits after install. Scan both .specify/scripts/ and
.specify/extensions/ for permission fixing.

* fix: move chmod after extension install + sanitize error_msg (#2117)

- ensure_executable_scripts() now runs after git extension install so
  extension .sh files get execute bits in the same init run
- Sanitize init_git_repo error_msg to single line (replace newlines,
  truncate to 120 chars) to prevent garbled StepTracker output

* fix: use tracker.error for git init/extension failures (#2117)

Git init failure and extension install failure were reported as
tracker.complete (showing green) even on error. Now track a
git_has_error flag and call tracker.error when any step fails,
so the UI correctly reflects the failure state.

* fix: sanitize ext_err in git step tracker for consistent rendering (#2117)

tests/integrations/test_cli.py

@@ -3,6 +3,8 @@
 import json
 import os
 
+import yaml
+
 
 class TestInitIntegrationFlag:
     def test_integration_and_ai_mutually_exclusive(self, tmp_path):
@@ -147,3 +149,142 @@ class TestInitIntegrationFlag:
         # Other shared files should still be installed
         assert (scripts_dir / "setup-plan.sh").exists()
         assert (templates_dir / "plan-template.md").exists()
+
+
+class TestForceExistingDirectory:
+    """Tests for --force merging into an existing named directory."""
+
+    def test_force_merges_into_existing_dir(self, tmp_path):
+        """specify init <dir> --force succeeds when the directory already exists."""
+        from typer.testing import CliRunner
+        from specify_cli import app
+
+        target = tmp_path / "existing-proj"
+        target.mkdir()
+        # Place a pre-existing file to verify it survives the merge
+        marker = target / "user-file.txt"
+        marker.write_text("keep me", encoding="utf-8")
+
+        runner = CliRunner()
+        result = runner.invoke(app, [
+            "init", str(target), "--integration", "copilot", "--force",
+            "--no-git", "--script", "sh",
+        ], catch_exceptions=False)
+
+        assert result.exit_code == 0, f"init --force failed: {result.output}"
+
+        # Pre-existing file should survive
+        assert marker.read_text(encoding="utf-8") == "keep me"
+
+        # Spec Kit files should be installed
+        assert (target / ".specify" / "init-options.json").exists()
+        assert (target / ".specify" / "templates" / "spec-template.md").exists()
+
+    def test_without_force_errors_on_existing_dir(self, tmp_path):
+        """specify init <dir> without --force errors when directory exists."""
+        from typer.testing import CliRunner
+        from specify_cli import app
+
+        target = tmp_path / "existing-proj"
+        target.mkdir()
+
+        runner = CliRunner()
+        result = runner.invoke(app, [
+            "init", str(target), "--integration", "copilot",
+            "--no-git", "--script", "sh",
+        ], catch_exceptions=False)
+
+        assert result.exit_code == 1
+        assert "already exists" in result.output
+
+
+class TestGitExtensionAutoInstall:
+    """Tests for auto-installation of the git extension during specify init."""
+
+    def test_git_extension_auto_installed(self, tmp_path):
+        """Without --no-git, the git extension is installed during init."""
+        from typer.testing import CliRunner
+        from specify_cli import app
+
+        project = tmp_path / "git-auto"
+        project.mkdir()
+        old_cwd = os.getcwd()
+        try:
+            os.chdir(project)
+            runner = CliRunner()
+            result = runner.invoke(app, [
+                "init", "--here", "--ai", "claude", "--script", "sh",
+                "--ignore-agent-tools",
+            ], catch_exceptions=False)
+        finally:
+            os.chdir(old_cwd)
+
+        assert result.exit_code == 0, f"init failed: {result.output}"
+
+        # Check that the tracker didn't report a git error
+        assert "install failed" not in result.output, f"git extension install failed: {result.output}"
+
+        # Git extension files should be installed
+        ext_dir = project / ".specify" / "extensions" / "git"
+        assert ext_dir.exists(), "git extension directory not installed"
+        assert (ext_dir / "extension.yml").exists()
+        assert (ext_dir / "scripts" / "bash" / "create-new-feature.sh").exists()
+        assert (ext_dir / "scripts" / "bash" / "initialize-repo.sh").exists()
+
+        # Hooks should be registered
+        extensions_yml = project / ".specify" / "extensions.yml"
+        assert extensions_yml.exists(), "extensions.yml not created"
+        hooks_data = yaml.safe_load(extensions_yml.read_text(encoding="utf-8"))
+        assert "hooks" in hooks_data
+        assert "before_specify" in hooks_data["hooks"]
+        assert "before_constitution" in hooks_data["hooks"]
+
+    def test_no_git_skips_extension(self, tmp_path):
+        """With --no-git, the git extension is NOT installed."""
+        from typer.testing import CliRunner
+        from specify_cli import app
+
+        project = tmp_path / "no-git"
+        project.mkdir()
+        old_cwd = os.getcwd()
+        try:
+            os.chdir(project)
+            runner = CliRunner()
+            result = runner.invoke(app, [
+                "init", "--here", "--ai", "claude", "--script", "sh",
+                "--no-git", "--ignore-agent-tools",
+            ], catch_exceptions=False)
+        finally:
+            os.chdir(old_cwd)
+
+        assert result.exit_code == 0, f"init failed: {result.output}"
+
+        # Git extension should NOT be installed
+        ext_dir = project / ".specify" / "extensions" / "git"
+        assert not ext_dir.exists(), "git extension should not be installed with --no-git"
+
+    def test_git_extension_commands_registered(self, tmp_path):
+        """Git extension commands are registered with the agent during init."""
+        from typer.testing import CliRunner
+        from specify_cli import app
+
+        project = tmp_path / "git-cmds"
+        project.mkdir()
+        old_cwd = os.getcwd()
+        try:
+            os.chdir(project)
+            runner = CliRunner()
+            result = runner.invoke(app, [
+                "init", "--here", "--ai", "claude", "--script", "sh",
+                "--ignore-agent-tools",
+            ], catch_exceptions=False)
+        finally:
+            os.chdir(old_cwd)
+
+        assert result.exit_code == 0, f"init failed: {result.output}"
+
+        # Git extension commands should be registered with the agent
+        claude_skills = project / ".claude" / "skills"
+        assert claude_skills.exists(), "Claude skills directory was not created"
+        git_skills = [f for f in claude_skills.iterdir() if f.name.startswith("speckit-git-")]
+        assert len(git_skills) > 0, "no git extension commands registered"