Merge pull request #10 from M9nx/copilot/allow-model-selection-option

Add embedding profile size aliases (small/base/large)

Author: M9nx

README.md

@@ -88,7 +88,7 @@ codexa init
 ```
 
 CodexA auto-detects your available RAM and picks the best embedding model.
-Or choose a model profile explicitly:
+Or choose a model profile explicitly (aliases: small → fast, base → balanced, large → precise):
 
 ```bash
 codexa init --profile fast       # mxbai-embed-xsmall — low RAM (<1 GB)

docs/guide/quickstart.md

@@ -26,6 +26,8 @@ codexa init --profile balanced   # Default, ~2 GB RAM
 codexa init --profile precise    # Best quality, ~4 GB RAM
 ```
 
+Aliases: `small` → `fast`, `base` → `balanced`, `large` → `precise`.
+
 Compare models on your codebase: `codexa models benchmark`
 :::
 

semantic_code_intelligence/cli/commands/init_cmd.py

@@ -13,6 +13,7 @@
     save_config,
 )
 from semantic_code_intelligence.embeddings.model_registry import (
+    CLI_PROFILE_CHOICES,
     recommend_profile_for_ram,
     resolve_profile,
 )
@@ -94,9 +95,12 @@ def _generate_vscode_mcp_config(root: Path) -> bool:
 @click.option(
     "--profile",
     "profile_name",
-    type=click.Choice(["fast", "balanced", "precise"], case_sensitive=False),
+    type=click.Choice(CLI_PROFILE_CHOICES, case_sensitive=False),
     default=None,
-    help="Embedding model profile: fast (tiny, low RAM), balanced (default), precise (code-optimised).",
+    help=(
+        "Embedding model profile: fast (low RAM), balanced (default), or precise (code-optimized). "
+        "Size aliases (small/base/large) and named aliases (default/quality/code) are supported."
+    ),
 )
 @click.pass_context
 def init_cmd(ctx: click.Context, path: str, auto_index: bool, setup_vscode: bool, profile_name: str | None) -> None:

semantic_code_intelligence/cli/commands/models_cmd.py

@@ -10,6 +10,7 @@
 from semantic_code_intelligence.config.settings import AppConfig, load_config, save_config
 from semantic_code_intelligence.embeddings.model_registry import (
     AVAILABLE_MODELS,
+    CLI_PROFILE_CHOICES,
     DEFAULT_MODEL,
     MODEL_ALIASES,
     MODEL_PROFILES,
@@ -216,7 +217,23 @@ def models_profiles(json_mode: bool) -> None:
     console.print(table)
     if available_gb:
         print_info(f"Detected RAM: {available_gb:.1f} GB — recommended profile marked with ⭐")
-    print_info("Use: codexa init --profile <fast|balanced|precise>")
+
+    canonical_names = sorted(MODEL_PROFILES.keys())
+    print_info(f"Use: codexa init --profile <{'|'.join(canonical_names)}>")
+
+    alias_map: dict[str, set[str]] = {}
+    for choice in CLI_PROFILE_CHOICES:
+        profile = resolve_profile(choice)
+        if profile is None or choice == profile.name:
+            continue
+        alias_map.setdefault(profile.name, set()).add(choice)
+
+    if alias_map:
+        alias_parts = []
+        for name in sorted(alias_map.keys()):
+            aliases = "/".join(sorted(alias_map[name]))
+            alias_parts.append(f"{name} ({aliases})")
+        print_info(f"Aliases also supported: {', '.join(alias_parts)}")
 
 
 @models_cmd.command("benchmark")

semantic_code_intelligence/embeddings/model_registry.py

@@ -134,11 +134,21 @@ class ModelProfile:
 
 PROFILE_ALIASES: dict[str, str] = {
     "small": "fast",
+    "base": "balanced",
     "default": "balanced",
     "quality": "precise",
     "code": "precise",
+    "large": "precise",
 }
 
+CORE_PROFILES: list[str] = ["fast", "balanced", "precise"]
+ALL_PROFILE_NAMES = set(PROFILE_ALIASES.keys()) | set(MODEL_PROFILES.keys())
+CLI_PROFILE_CHOICES: list[str] = [
+    *CORE_PROFILES,
+    # Aliases can overlap canonical names; set operations ensure each appears once in the final list
+    *sorted(set(ALL_PROFILE_NAMES) - set(CORE_PROFILES)),
+]
+
 
 def resolve_profile(name: str) -> ModelProfile | None:
     """Resolve a profile name or alias to a ModelProfile."""

semantic_code_intelligence/tests/test_cli.py

@@ -12,6 +12,7 @@
 
 from semantic_code_intelligence.cli.main import cli
 from semantic_code_intelligence.embeddings.generator import BYTES_PER_GB
+from semantic_code_intelligence.embeddings.model_registry import MODEL_PROFILES
 
 
 @pytest.fixture
@@ -72,6 +73,24 @@ def test_init_default_path(self, runner: CliRunner):
             assert result.exit_code == 0
             assert Path(td, ".codexa").is_dir()
 
+    def test_init_profile_aliases(self, runner: CliRunner, tmp_path: Path):
+        cases = [
+            ("small", "fast"),
+            ("base", "balanced"),
+            ("large", "precise"),
+        ]
+
+        for alias, expected_profile in cases:
+            proj = tmp_path / alias
+            proj.mkdir()
+            result = runner.invoke(cli, ["init", str(proj), "--profile", alias])
+            assert result.exit_code == 0
+            assert "Model profile" in result.output
+            assert MODEL_PROFILES[expected_profile].label in result.output
+
+            cfg = load_config(proj)
+            assert cfg.embedding.model_name == MODEL_PROFILES[expected_profile].model_name
+
     def test_init_saves_recommended_batch_size(self, runner: CliRunner, tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
         # Force deterministic resource detection so recommendations are stable in tests
         monkeypatch.setattr(