Remove --language option from rhiza init CLI command

Co-authored-by: tschm <2046079+tschm@users.noreply.github.com>

Author: Copilot

REPOSITORY_ANALYSIS.md

@@ -838,7 +838,7 @@ Branch `copilot/add-early-repository-validation` contains a single "Initial plan
 
 - **_sync_helpers.py at 958 LOC is the largest file and a potential maintenance bottleneck.** While the extraction (PR #319) improved test decoupling, the module is now 42% of the entire `src/rhiza/` codebase (2,259 total LOC). Consider further decomposition into `_diff.py`, `_merge.py`, `_lock_io.py`, and `_snapshot.py` if the file continues to grow.
 
-- **No smoke test for Go language mode.** `rhiza init --language go` is supported (documented in CLI help text), but `.github/workflows/rhiza_smoke.yml` only tests the default Python mode. Go template initialization could silently break without detection. Add a second job to the smoke test workflow for Go projects.
+- **No smoke test for Go template repository mode.** Using `template_repository="jebel-quant/rhiza-go"` is supported, but `.github/workflows/rhiza_smoke.yml` only tests the default Python mode. Go template initialization could silently break without detection. Add a second job to the smoke test workflow for Go projects.
 
 - **Pre-commit hook for custom rhiza checks uses external package.** `.pre-commit-config.yaml` references `rhiza-hooks>=0.3.0` (a separate PyPI package). If this package is unmaintained or has a breaking change, all pre-commit runs will fail. Consider vendoring critical hooks into `.rhiza/hooks/` or documenting the external dependency risk.
 
@@ -936,7 +936,7 @@ This is an **exemplary production-grade project** with excellent engineering dis
 
 - **_sync_helpers.py at 958 LOC is 42% of codebase and potential maintenance bottleneck.** While the extraction (PR #319) improved modularity, a single 958-line file concentrates critical logic. Consider further decomposition into focused modules: `_diff.py` (diff computation), `_merge.py` (3-way merge), `_lock_io.py` (lock file I/O with fcntl), `_snapshot.py` (template snapshot prep).
 
-- **No smoke test for Go language mode.** `rhiza init --language go` is supported (visible in CLI help text and `language_validators.py`), but `rhiza_smoke.yml` only tests Python projects. Go template initialization could silently regress. Add second job to smoke test workflow for Go projects.
+- **No smoke test for Go template repository mode.** Using `template_repository="jebel-quant/rhiza-go"` is supported (visible in `language_validators.py`), but `rhiza_smoke.yml` only tests Python projects. Go template initialization could silently regress. Add second job to smoke test workflow for Go projects.
 
 - **Pre-commit hooks depend on external rhiza-hooks package.** `.pre-commit-config.yaml` references `rhiza-hooks>=0.3.0` (separate PyPI package). If unmaintained or breaking, all pre-commit runs fail. Consider vendoring critical hooks into `.rhiza/hooks/` or documenting external dependency risk in CONTRIBUTING.md.
 

src/rhiza/cli.py

@@ -99,18 +99,10 @@ def init(
         help="Target Git hosting platform (github or gitlab). Determines which CI/CD files to include. "
         "If not provided, will prompt interactively.",
     ),
-    language: str = typer.Option(
-        "python",
-        "--language",
-        help="Programming language for the project (python, go, etc.). Defaults to 'python'.",
-    ),
     template_repository: str = typer.Option(
         None,
         "--template-repository",
-        help=(
-            "Custom template repository (format: owner/repo). "
-            "Defaults to 'jebel-quant/rhiza' for Python or 'jebel-quant/rhiza-go' for Go."
-        ),
+        help=("Custom template repository (format: owner/repo). Defaults to 'jebel-quant/rhiza'."),
     ),
     template_branch: str = typer.Option(
         None,
@@ -123,32 +115,25 @@ def init(
     Creates a default `.rhiza/template.yml` configuration file if one
     doesn't exist, or validates the existing configuration.
 
-    The default template includes common project files based on the language.
+    The default template includes common project files.
     The --git-host option determines which CI/CD configuration to include:
     - github: includes .github folder (GitHub Actions workflows)
     - gitlab: includes .gitlab-ci.yml (GitLab CI configuration)
 
-    The --language option determines the project type and files created:
-    - python: creates pyproject.toml, src/, and Python project structure
-    - go: creates minimal structure (you'll need to run 'go mod init')
-
     Examples:
       rhiza init
-      rhiza init --language go
-      rhiza init --language python --git-host github
       rhiza init --git-host gitlab
+      rhiza init --git-host github
       rhiza init --template-repository myorg/my-templates
       rhiza init --template-repository myorg/my-templates --template-branch develop
       rhiza init /path/to/project
-      rhiza init .. --language go
     """
     if not init_cmd(
         target,
         project_name=project_name,
         package_name=package_name,
         with_dev_dependencies=with_dev_dependencies,
         git_host=git_host,
-        language=language,
         template_repository=template_repository,
         template_branch=template_branch,
     ):

tests/test_commands/test_init_language.py

@@ -1,4 +1,4 @@
-"""Tests for language-specific init functionality."""
+"""Tests for template-repository-based init functionality."""
 
 from unittest.mock import patch
 
@@ -7,42 +7,38 @@
 from rhiza.commands.init import init
 
 
-class TestInitWithLanguage:
-    """Tests for init command with language parameter."""
+class TestInitWithTemplateRepository:
+    """Tests for init command with template repository selection."""
 
-    def test_init_with_go_language(self, tmp_path):
-        """Test that init with go language creates Go-specific structure."""
-        init(tmp_path, git_host="github", language="go")
+    @patch("rhiza.commands.init._check_template_repository_reachable", return_value=True)
+    def test_init_with_go_template_repository(self, mock_check, tmp_path):
+        """Test that init with go template repository creates correct config."""
+        init(tmp_path, git_host="github", template_repository="jebel-quant/rhiza-go")
 
-        # Verify template.yml was created with go language
+        # Verify template.yml was created with go repository
         template_file = tmp_path / ".rhiza" / "template.yml"
         assert template_file.exists()
 
         with open(template_file) as f:
             config = yaml.safe_load(f)
 
         assert config["repository"] == "jebel-quant/rhiza-go"
-        assert config["language"] == "go"
-
-        # Verify Go-specific structure was NOT created (user should run go mod init)
-        assert not (tmp_path / "go.mod").exists()
-        assert not (tmp_path / "src").exists()
-        assert not (tmp_path / "pyproject.toml").exists()
-
-        # Only README should be created
-        assert (tmp_path / "README.md").exists()
+        # The language parameter defaults to "python" internally; RhizaTemplate.to_yaml()
+        # omits the language field when it equals the default "python" value.
+        assert "language" not in config
 
-    def test_init_with_python_language_explicit(self, tmp_path):
-        """Test that init with explicit python language creates Python structure."""
-        init(tmp_path, git_host="github", language="python")
+    def test_init_with_python_template_repository(self, tmp_path):
+        """Test that init with default python template repository creates Python structure."""
+        init(tmp_path, git_host="github")
 
         # Verify template.yml was created WITHOUT language field (it's default)
         template_file = tmp_path / ".rhiza" / "template.yml"
         with open(template_file) as f:
             config = yaml.safe_load(f)
 
         assert config["repository"] == "jebel-quant/rhiza"
-        # Language field should not be in config (it's the default)
+        # RhizaTemplate.to_yaml() omits the language field when it equals the
+        # default "python" value, so no language key is written to the file.
         assert "language" not in config
 
         # Verify Python-specific structure
@@ -51,62 +47,39 @@ def test_init_with_python_language_explicit(self, tmp_path):
         assert (tmp_path / "README.md").exists()
 
     def test_init_defaults_to_python(self, tmp_path):
-        """Test that init defaults to python when no language specified."""
+        """Test that init defaults to python when no template repository specified."""
         init(tmp_path, git_host="github")
 
         # Verify Python structure was created
         assert (tmp_path / "pyproject.toml").exists()
         assert (tmp_path / "src").is_dir()
 
     @patch("rhiza.commands.init._check_template_repository_reachable", return_value=True)
-    def test_init_go_with_custom_template_repository(self, mock_check, tmp_path):
-        """Test that custom template repository works with Go language."""
+    def test_init_with_custom_template_repository(self, mock_check, tmp_path):
+        """Test that custom template repository is stored correctly."""
         init(
             tmp_path,
             git_host="github",
-            language="go",
             template_repository="custom/go-templates",
         )
 
         template_file = tmp_path / ".rhiza" / "template.yml"
         with open(template_file) as f:
             config = yaml.safe_load(f)
 
-        # Custom repository should override default
+        # Custom repository should be set
         assert config["repository"] == "custom/go-templates"
-        assert config["language"] == "go"
-
-    def test_init_unknown_language(self, tmp_path):
-        """Test that init handles unknown languages gracefully."""
-        init(tmp_path, git_host="github", language="rust")
-
-        # Should create minimal structure
-        assert (tmp_path / ".rhiza" / "template.yml").exists()
-        assert (tmp_path / "README.md").exists()
 
-        # Should not create language-specific files
-        assert not (tmp_path / "pyproject.toml").exists()
-        assert not (tmp_path / "go.mod").exists()
-
-        # Verify template.yml
-        template_file = tmp_path / ".rhiza" / "template.yml"
-        with open(template_file) as f:
-            config = yaml.safe_load(f)
-
-        assert config["language"] == "rust"
-        # Should use default Python repository since no mapping exists
-        assert config["repository"] == "jebel-quant/rhiza"
-
-    def test_init_go_language_with_gitlab(self, tmp_path):
-        """Test Go init with GitLab hosting."""
-        init(tmp_path, git_host="gitlab", language="go")
+    @patch("rhiza.commands.init._check_template_repository_reachable", return_value=True)
+    def test_init_go_template_repository_with_gitlab(self, mock_check, tmp_path):
+        """Test go template repository with GitLab hosting."""
+        init(tmp_path, git_host="gitlab", template_repository="jebel-quant/rhiza-go")
 
         template_file = tmp_path / ".rhiza" / "template.yml"
         with open(template_file) as f:
             config = yaml.safe_load(f)
 
         assert config["repository"] == "jebel-quant/rhiza-go"
-        assert config["language"] == "go"
         # Should include gitlab in templates
         assert "gitlab" in config["templates"]
         assert "github" not in config["templates"]