cortexcode 0.8.1__py3-none-any.whl → 0.9.1__py3-none-any.whl

cortexcode/ai_docs/doc_generator.py

@@ -60,7 +60,7 @@ class AIDocGenerator:
             messages = prompts.generate_project_overview_prompt(index_data)
             output.overview = self._generate(messages, "overview")
             if output.overview:
-                (output_dir / "AI_OVERVIEW.md").write_text(output.overview)
+                (output_dir / "AI_OVERVIEW.md").write_text(output.overview, encoding="utf-8")
                 print("  -> AI_OVERVIEW.md")
         
         if "api" in docs:
@@ -68,7 +68,7 @@ class AIDocGenerator:
             messages = prompts.generate_api_docs_prompt(index_data)
             output.api_docs = self._generate(messages, "api")
             if output.api_docs:
-                (output_dir / "AI_API.md").write_text(output.api_docs)
+                (output_dir / "AI_API.md").write_text(output.api_docs, encoding="utf-8")
                 print("  -> AI_API.md")
         
         if "architecture" in docs:
@@ -76,7 +76,7 @@ class AIDocGenerator:
             messages = prompts.generate_architecture_prompt(index_data)
             output.architecture = self._generate(messages, "architecture")
             if output.architecture:
-                (output_dir / "AI_ARCHITECTURE.md").write_text(output.architecture)
+                (output_dir / "AI_ARCHITECTURE.md").write_text(output.architecture, encoding="utf-8")
                 print("  -> AI_ARCHITECTURE.md")
         
         if "flows" in docs:
@@ -84,7 +84,7 @@ class AIDocGenerator:
             messages = prompts.generate_flow_docs_prompt(index_data)
             output.flows = self._generate(messages, "flows")
             if output.flows:
-                (output_dir / "AI_FLOWS.md").write_text(output.flows)
+                (output_dir / "AI_FLOWS.md").write_text(output.flows, encoding="utf-8")
                 print("  -> AI_FLOWS.md")
         
         return output
@@ -107,7 +107,7 @@ class AIDocGenerator:
         result = self._generate(messages, f"module_{module_name}")
         
         if output_path and result:
-            Path(output_path).write_text(result)
+            Path(output_path).write_text(result, encoding="utf-8")
         
         return result
 

cortexcode/cli/cli_index.py

@@ -1,6 +1,9 @@
+import json
 import time
+import sys
 from pathlib import Path
 
+import click
 from rich import box
 from rich.console import Console
 from rich.panel import Panel
@@ -8,6 +11,497 @@ from rich.progress import BarColumn, Progress, SpinnerColumn, TaskProgressColumn
 from rich.table import Table
 
 
+def _load_questionary():
+    try:
+        import questionary
+    except ImportError:
+        return None
+    return questionary
+
+
+def _load_user_config() -> dict:
+    config_path = Path.home() / ".cortexcode" / "config.json"
+    if not config_path.exists():
+        return {}
+    try:
+        return json.loads(config_path.read_text(encoding="utf-8"))
+    except Exception:
+        return {}
+
+
+def _save_user_config(config: dict) -> None:
+    config_path = Path.home() / ".cortexcode" / "config.json"
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    config_path.write_text(json.dumps(config, indent=2), encoding="utf-8")
+
+
+def _load_post_index_preferences() -> dict:
+    config = _load_user_config()
+    prefs = config.get("post_index_wizard", {})
+    if isinstance(prefs, dict):
+        return prefs
+    return {}
+
+
+def _save_post_index_preferences(preferences: dict) -> None:
+    config = _load_user_config()
+    config["post_index_wizard"] = preferences
+    _save_user_config(config)
+
+
+def _should_show_post_index_wizard(watch: bool, disabled: bool, force: bool) -> bool:
+    if force:
+        return True
+    preferences = _load_post_index_preferences()
+    return not disabled and preferences.get("enabled", True) and not watch and sys.stdin.isatty() and sys.stdout.isatty()
+
+
+def _prompt_generate_now() -> bool:
+    questionary = _load_questionary()
+    if questionary:
+        answer = questionary.confirm("Generate docs, diagrams, reports, or setup now?", default=False).ask()
+        return bool(answer)
+    return click.confirm("Generate docs, diagrams, reports, or setup now?", default=False)
+
+
+def _get_recommended_targets(index_data: dict, preferences: dict) -> list[str]:
+    saved_targets = preferences.get("targets")
+    if isinstance(saved_targets, list) and saved_targets:
+        return saved_targets
+
+    recommended = ["docs", "diagrams", "report"]
+    profile = index_data.get("project_profile", {}) if isinstance(index_data, dict) else {}
+    route_count = profile.get("route_count", 0)
+    entity_count = profile.get("entity_count", 0)
+    files = index_data.get("files", {}) if isinstance(index_data, dict) else {}
+    symbol_count = sum(
+        len(file_data.get("symbols", [])) if isinstance(file_data, dict) else len(file_data)
+        for file_data in files.values()
+    )
+
+    if route_count or entity_count:
+        recommended.append("dashboard")
+    if 0 < symbol_count <= 500:
+        recommended.append("viz")
+
+    seen = []
+    for item in recommended:
+        if item not in seen:
+            seen.append(item)
+    return seen
+
+
+def _prompt_generation_targets(console: Console, defaults: list[str] | None = None, recommended: list[str] | None = None) -> list[str]:
+    core_options = [
+        ("docs", "Project docs"),
+        ("diagrams", "Mermaid diagrams"),
+        ("report", "Interactive terminal report"),
+        ("viz", "Interactive graph visualization"),
+        ("dashboard", "Live dashboard"),
+    ]
+    ai_options = [
+        ("ai_docs", "AI docs"),
+        ("wiki", "CodeWiki"),
+    ]
+    setup_options = [
+        ("mcp_setup", "Configure MCP for your editor"),
+    ]
+    options = core_options + ai_options + setup_options
+    defaults = defaults or []
+    recommended = recommended or []
+    questionary = _load_questionary()
+    if questionary:
+        choices = [questionary.Separator("══ Core outputs ══")]
+        choices.extend(
+            questionary.Choice(
+                title=f"{label}{' [recommended]' if value in recommended else ''}",
+                value=value,
+                checked=value in defaults,
+            )
+            for value, label in core_options
+        )
+        choices.append(questionary.Separator("══ AI-powered ══"))
+        choices.extend(
+            questionary.Choice(
+                title=f"{label}{' [recommended]' if value in recommended else ''}",
+                value=value,
+                checked=value in defaults,
+            )
+            for value, label in ai_options
+        )
+        choices.append(questionary.Separator("══ Setup ══"))
+        choices.extend(
+            questionary.Choice(
+                title=f"{label}{' [recommended]' if value in recommended else ''}",
+                value=value,
+                checked=value in defaults,
+            )
+            for value, label in setup_options
+        )
+        selections = questionary.checkbox(
+            "Select what to generate",
+            choices=choices,
+            validate=lambda items: True if items else "Select at least one option.",
+        ).ask()
+        return selections or []
+
+    console.print("\n[bold]Select what to generate:[/bold]")
+    for idx, (_, label) in enumerate(options, 1):
+        suffix = " [recommended]" if options[idx - 1][0] in recommended else ""
+        console.print(f"  {idx}. {label}{suffix}")
+    default_indexes = [str(idx) for idx, (value, _) in enumerate(options, 1) if value in defaults]
+    raw_value = click.prompt(
+        "Enter choices as comma-separated numbers",
+        default=",".join(default_indexes) if default_indexes else "1,2",
+        show_default=True,
+    )
+    selected = []
+    for part in raw_value.split(","):
+        part = part.strip()
+        if not part.isdigit():
+            continue
+        index = int(part) - 1
+        if 0 <= index < len(options):
+            selected.append(options[index][0])
+    seen = []
+    for item in selected:
+        if item not in seen:
+            seen.append(item)
+    return seen
+
+
+def _prompt_provider(default: str | None = None) -> str:
+    from cortexcode.ai_docs.config import get_config
+
+    provider = default or get_config().provider or "google"
+    choices = ["google", "openai", "anthropic", "ollama"]
+    questionary = _load_questionary()
+    if questionary:
+        answer = questionary.select("Choose provider", choices=choices, default=provider).ask()
+        return answer or provider
+    return click.prompt("Choose provider", type=click.Choice(choices), default=provider, show_choices=True)
+
+
+def _ensure_provider_access(console: Console, provider: str) -> bool:
+    from cortexcode.ai_docs.config import AIConfig, get_api_key, get_config, set_api_key, set_config
+
+    config = get_config()
+    set_config(AIConfig(provider=provider, model=config.model, temperature=config.temperature, max_tokens=config.max_tokens))
+
+    if provider == "ollama":
+        return True
+
+    if get_api_key(provider):
+        return True
+
+    provider_labels = {
+        "google": ("Gemini", "https://aistudio.google.com/apikey"),
+        "openai": ("OpenAI", "https://platform.openai.com/api-keys"),
+        "anthropic": ("Anthropic", "https://console.anthropic.com/settings/keys"),
+    }
+    label, url = provider_labels.get(provider, (provider, ""))
+    console.print(
+        f"\n[yellow]No API key found for {label}.[/yellow]\n"
+        f"[dim]Get your key at:[/dim] [cyan]{url}[/cyan]\n"
+    )
+
+    questionary = _load_questionary()
+    if questionary:
+        api_key = questionary.password(f"Enter your {label} API key (leave blank to skip)").ask() or ""
+    else:
+        api_key = click.prompt(
+            f"Enter your {label} API key (leave blank to skip)",
+            default="",
+            show_default=False,
+            hide_input=True,
+        ).strip()
+
+    if not api_key:
+        console.print(f"[dim]Skipped. You can set it later with:[/dim] [cyan]cortexcode config set {provider}_api_key YOUR_KEY[/cyan]\n")
+        return False
+
+    set_api_key(provider, api_key)
+    console.print(f"[green]✓[/green] API key saved for {label}.\n")
+    return True
+
+
+def _prompt_report_type(available_reports: list[str], default: str | None = None) -> str:
+    questionary = _load_questionary()
+    selected_default = default if default in available_reports else (available_reports[0] if available_reports else "overview")
+    if questionary:
+        answer = questionary.select("Choose report type", choices=available_reports, default=selected_default).ask()
+        return answer or selected_default
+    return click.prompt(
+        "Choose report type",
+        type=click.Choice(available_reports),
+        default=selected_default,
+        show_choices=True,
+    )
+
+
+def _prompt_dashboard_port(default: int) -> int:
+    questionary = _load_questionary()
+    if questionary:
+        answer = questionary.text("Dashboard port", default=str(default), validate=lambda value: value.isdigit() or "Enter a valid port").ask()
+        return int(answer or default)
+    return int(click.prompt("Dashboard port", default=default, type=int, show_default=True))
+
+
+def _prompt_diagram_types(defaults: list[str]) -> list[str]:
+    diagram_types = ["call_graph", "class", "sequence", "architecture", "imports", "dependencies", "entities", "file_tree"]
+    questionary = _load_questionary()
+    if questionary:
+        selections = questionary.checkbox(
+            "Choose diagram types",
+            choices=[questionary.Choice(title=item, value=item, checked=item in defaults) for item in diagram_types],
+            validate=lambda items: True if items else "Select at least one diagram type.",
+        ).ask()
+        return selections or defaults
+
+    raw_value = click.prompt(
+        "Choose diagram types (comma-separated)",
+        default=",".join(defaults),
+        show_default=True,
+    )
+    values = [item.strip() for item in raw_value.split(",") if item.strip() in diagram_types]
+    return values or defaults
+
+
+def _prompt_ai_doc_types(defaults: list[str]) -> list[str]:
+    doc_types = ["overview", "api", "architecture", "flows"]
+    questionary = _load_questionary()
+    if questionary:
+        selections = questionary.checkbox(
+            "Choose AI doc types",
+            choices=[questionary.Choice(title=item, value=item, checked=item in defaults) for item in doc_types],
+            validate=lambda items: True if items else "Select at least one AI doc type.",
+        ).ask()
+        return selections or defaults
+
+    raw_value = click.prompt(
+        "Choose AI doc types (comma-separated)",
+        default=",".join(defaults),
+        show_default=True,
+    )
+    values = [item.strip() for item in raw_value.split(",") if item.strip() in doc_types]
+    return values or defaults
+
+
+def _prompt_confirm(message: str, default: bool) -> bool:
+    questionary = _load_questionary()
+    if questionary:
+        answer = questionary.confirm(message, default=default).ask()
+        return bool(answer)
+    return click.confirm(message, default=default)
+
+
+def _prompt_max_modules(default: int) -> int:
+    questionary = _load_questionary()
+    if questionary:
+        answer = questionary.text("Max module pages", default=str(default), validate=lambda value: value.isdigit() or "Enter a valid number").ask()
+        return int(answer or default)
+    return int(click.prompt("Max module pages", default=default, type=int, show_default=True))
+
+
+def _prompt_save_preferences() -> bool:
+    questionary = _load_questionary()
+    if questionary:
+        answer = questionary.confirm("Save these choices as defaults for future index runs?", default=True).ask()
+        return bool(answer)
+    return click.confirm("Save these choices as defaults for future index runs?", default=True)
+
+
+def _prompt_show_wizard_next_time(default: bool) -> bool:
+    questionary = _load_questionary()
+    if questionary:
+        answer = questionary.confirm("Show this wizard automatically after future index runs?", default=default).ask()
+        return bool(answer)
+    return click.confirm("Show this wizard automatically after future index runs?", default=default)
+
+
+def _run_post_index_wizard(console: Console, path: Path, index_data: dict) -> None:
+    import webbrowser
+
+    from cortexcode import indexer
+    from cortexcode.cli import handle_ai_docs_command, handle_dashboard_command, handle_diagrams_command, handle_docs_command, handle_wiki_command
+    from cortexcode.cli.cli_servers import handle_mcp_setup
+    from cortexcode.cli.cli_support import require_ai_doc_generator, require_index_path
+    from cortexcode.docs import generate_all_docs
+    from cortexcode.docs.diagrams import save_diagrams
+    from cortexcode.dashboard import DashboardServer
+    from cortexcode.reports.site.viz import generate_viz_html
+    from cortexcode.terminal.completion import print_ai_docs_complete, print_diagrams_complete, print_docs_complete
+    from cortexcode.terminal.headers import print_ai_docs_header, print_diagrams_header, print_docs_header
+    from cortexcode.terminal.reports import get_available_reports, print_terminal_report
+
+    preferences = _load_post_index_preferences()
+    if not _prompt_generate_now():
+        return
+
+    recommended_targets = _get_recommended_targets(index_data, preferences)
+    default_targets = preferences.get("targets") or recommended_targets
+    targets = _prompt_generation_targets(console, default_targets, recommended_targets)
+    if not targets:
+        return
+
+    provider = preferences.get("provider")
+    if any(target in {"ai_docs", "wiki"} for target in targets):
+        provider = _prompt_provider(provider)
+        if not _ensure_provider_access(console, provider):
+            targets = [target for target in targets if target not in {"ai_docs", "wiki"}]
+            if not targets:
+                return
+
+    report_type = preferences.get("report_type")
+    if "report" in targets:
+        available_reports = get_available_reports(index_data, ["overview", "tech", "hotspots", "routes", "entities", "frontend", "cli"])
+        report_type = _prompt_report_type(available_reports, report_type)
+
+    dashboard_port = int(preferences.get("dashboard_port", 8787))
+    if "dashboard" in targets:
+        dashboard_port = _prompt_dashboard_port(dashboard_port)
+
+    docs_open_browser = bool(preferences.get("open_docs_browser", False))
+    if "docs" in targets:
+        docs_open_browser = _prompt_confirm("Open generated docs in browser?", docs_open_browser)
+
+    recommended_diagrams = index_data.get("project_profile", {}).get("recommendations", {}).get("diagrams", [])
+    diagram_defaults = preferences.get("diagram_types") or [item for item in recommended_diagrams if item in ["call_graph", "class", "sequence", "architecture", "imports", "dependencies", "entities", "file_tree"]] or ["architecture", "call_graph"]
+    selected_diagram_types = diagram_defaults
+    if "diagrams" in targets:
+        selected_diagram_types = _prompt_diagram_types(diagram_defaults)
+
+    ai_doc_defaults = preferences.get("ai_doc_types") or ["overview", "api", "architecture", "flows"]
+    selected_ai_doc_types = ai_doc_defaults
+    if "ai_docs" in targets:
+        selected_ai_doc_types = _prompt_ai_doc_types(ai_doc_defaults)
+
+    wiki_open_browser = bool(preferences.get("open_wiki_browser", False))
+    wiki_include_modules = bool(preferences.get("wiki_include_modules", True))
+    wiki_max_modules = int(preferences.get("wiki_max_modules", 15))
+    if "wiki" in targets:
+        wiki_open_browser = _prompt_confirm("Open generated CodeWiki in browser?", wiki_open_browser)
+        wiki_include_modules = _prompt_confirm("Include per-module wiki pages?", wiki_include_modules)
+        if wiki_include_modules:
+            wiki_max_modules = _prompt_max_modules(wiki_max_modules)
+
+    viz_open_browser = bool(preferences.get("open_viz_browser", True))
+    if "viz" in targets:
+        viz_open_browser = _prompt_confirm("Open graph visualization in browser?", viz_open_browser)
+
+    wizard_enabled = _prompt_show_wizard_next_time(bool(preferences.get("enabled", True)))
+
+    if _prompt_save_preferences():
+        _save_post_index_preferences(
+            {
+                "targets": targets,
+                "provider": provider,
+                "report_type": report_type,
+                "dashboard_port": dashboard_port,
+                "diagram_types": selected_diagram_types,
+                "ai_doc_types": selected_ai_doc_types,
+                "open_docs_browser": docs_open_browser,
+                "open_wiki_browser": wiki_open_browser,
+                "wiki_include_modules": wiki_include_modules,
+                "wiki_max_modules": wiki_max_modules,
+                "open_viz_browser": viz_open_browser,
+                "enabled": wizard_enabled,
+            }
+        )
+
+    if "docs" in targets:
+        handle_docs_command(
+            console,
+            path,
+            path / ".cortexcode" / "docs",
+            docs_open_browser,
+            require_index_path,
+            print_docs_header,
+            generate_all_docs,
+            print_docs_complete,
+        )
+
+    if "diagrams" in targets:
+        output_dir = path / ".cortexcode" / "diagrams"
+        diagram_types = ["call_graph", "class", "sequence", "architecture", "imports", "dependencies", "entities", "file_tree"]
+        if len(selected_diagram_types) == 1:
+            handle_diagrams_command(
+                console,
+                path,
+                output_dir,
+                selected_diagram_types[0],
+                require_index_path,
+                print_diagrams_header,
+                save_diagrams,
+                diagram_types,
+                print_diagrams_complete,
+            )
+        elif len(selected_diagram_types) == len(diagram_types):
+            handle_diagrams_command(
+                console,
+                path,
+                output_dir,
+                None,
+                require_index_path,
+                print_diagrams_header,
+                save_diagrams,
+                diagram_types,
+                print_diagrams_complete,
+            )
+        else:
+            _, index_path = require_index_path(console, path)
+            print_diagrams_header(console, path)
+            for diagram_type in selected_diagram_types:
+                save_diagrams(index_path, output_dir, diagram_type=diagram_type)
+            generated_files = ["DIAGRAMS.md", *[f"{item}.mmd" for item in selected_diagram_types]]
+            print_diagrams_complete(console, output_dir, generated_files)
+
+    if "ai_docs" in targets:
+        handle_ai_docs_command(
+            console,
+            path,
+            path / ".cortexcode" / "ai-docs",
+            provider,
+            None,
+            tuple(selected_ai_doc_types),
+            require_ai_doc_generator,
+            require_index_path,
+            print_ai_docs_header,
+            print_ai_docs_complete,
+        )
+
+    if "wiki" in targets:
+        handle_wiki_command(
+            console,
+            path,
+            path / ".cortexcode" / "wiki",
+            provider,
+            None,
+            None,
+            not wiki_include_modules,
+            wiki_max_modules,
+            wiki_open_browser,
+        )
+
+    if "report" in targets:
+        print_terminal_report(console, report_type or "overview", index_data, path)
+
+    if "viz" in targets:
+        viz_path = path / ".cortexcode" / "graph.html"
+        generate_viz_html(index_data, viz_path)
+        if viz_open_browser:
+            console.print(f"[cyan]Opening visualization:[/cyan] {viz_path}")
+            webbrowser.open(viz_path.as_uri())
+        else:
+            console.print(f"[green]✓[/green] Visualization generated: {viz_path}")
+
+    if "mcp_setup" in targets:
+        handle_mcp_setup(console)
+
+    if "dashboard" in targets:
+        handle_dashboard_command(console, path, dashboard_port, indexer, DashboardServer)
+
+
 def handle_index_command(
     console: Console,
     path: str | Path,
@@ -20,6 +514,8 @@ def handle_index_command(
     include,
     root,
     dry_run: bool,
+    no_post_index_wizard: bool,
+    force_wizard: bool,
     indexer_module,
     print_index_header,
     print_project_profile_summary,
@@ -104,6 +600,9 @@ def handle_index_command(
     if verbose:
         show_index_summary(console, index_data)
 
+    if _should_show_post_index_wizard(watch, no_post_index_wizard, force_wizard):
+        _run_post_index_wizard(console, path, index_data)
+
     if watch:
         console.print("\n[yellow]Starting watcher...[/yellow]")
         console.print("[dim]Press Ctrl+C to stop[/dim]")

cortexcode/cli/cli_servers.py

@@ -1,6 +1,7 @@
 import json
 import os
 import shutil
+import platform
 from pathlib import Path
 
 from rich.console import Console
@@ -10,68 +11,103 @@ from rich.prompt import Prompt
 IDE_CONFIGS = {
     "vscode": {
         "name": "VS Code",
-        "file": ".vscode/settings.json",
-        "config": {"mcpServers": {"cortexcode": {"command": "cortexcode", "args": ["mcp"], "disabled": False}}},
+        "file": ".vscode/mcp.json",
+        "global_file": "~/.vscode/mcp.json",
+        "config": {"servers": {"cortexcode": {"command": "cortexcode", "args": ["mcp", "start"]}}},
     },
     "cursor": {
         "name": "Cursor",
-        "file": ".cursor/settings.json",
-        "config": {"mcpServers": {"cortexcode": {"command": "cortexcode", "args": ["mcp"], "disabled": False}}},
+        "file": ".cursor/mcp.json",
+        "global_file": "~/.cursor/mcp.json",
+        "config": {"servers": {"cortexcode": {"command": "cortexcode", "args": ["mcp", "start"]}}},
     },
     "windsurf": {
         "name": "Windsurf",
-        "file": ".windsurf/config.json",
-        "config": {"mcpServers": {"cortexcode": {"command": "cortexcode", "args": ["mcp"], "disabled": False}}},
+        "file": ".codeium/windsurf/mcp_config.json",
+        "global_file": "~/.codeium/windsurf/mcp_config.json",
+        "config": {"mcpServers": {"cortexcode": {"command": "cortexcode", "args": ["mcp", "start"]}}},
     },
     "claude": {
-        "name": "Claude Desktop",
-        "file": "claude_desktop_config.json",
-        "config": {"mcpServers": {"cortexcode": {"command": "cortexcode", "args": ["mcp"], "disabled": False}}},
+        "name": "Claude Code",
+        "file": None,
+        "global_file": None,
+        "config": None,
+        "cli_command": "claude mcp add cortexcode stdio -- cortexcode mcp start",
     },
     "cline": {
         "name": "Cline",
-        "file": ".cline/settings.json",
-        "config": {"mcpServers": {"cortexcode": {"command": "cortexcode", "args": ["mcp"], "disabled": False}}},
+        "file": ".cline/mcp.json",
+        "global_file": "~/.cline/mcp.json",
+        "config": {"mcpServers": {"cortexcode": {"command": "cortexcode", "args": ["mcp", "start"]}}},
     },
     "roocode": {
         "name": "RooCode",
-        "file": ".roocode/settings.json",
-        "config": {"mcpServers": {"cortexcode": {"command": "cortexcode", "args": ["mcp"], "disabled": False}}},
+        "file": ".roocode/mcp.json",
+        "global_file": "~/.roocode/mcp.json",
+        "config": {"mcpServers": {"cortexcode": {"command": "cortexcode", "args": ["mcp", "start"]}}},
     },
-    "gemini": {
-        "name": "Gemini CLI",
-        "file": ".gemini/settings.json",
-        "config": {"mcpServers": {"cortexcode": {"command": "cortexcode", "args": ["mcp"], "disabled": False}}},
+    "opencode": {
+        "name": "OpenCode",
+        "file": "opencode.json",
+        "global_file": "~/.opencode/opencode.json",
+        "config": {"mcp": {"cortexcode": {"type": "local", "command": ["cortexcode", "mcp", "start"], "enabled": True}}},
     },
-    "amazonq": {
-        "name": "Amazon Q Developer",
-        "file": ".aws/amazonq/settings.json",
-        "config": {"mcpServers": {"cortexcode": {"command": "cortexcode", "args": ["mcp"], "disabled": False}}},
+    "antigravity": {
+        "name": "Antigravity",
+        "file": ".antigravity/mcp.json",
+        "global_file": "~/.antigravity/mcp.json",
+        "config": {"mcpServers": {"cortexcode": {"command": "cortexcode", "args": ["mcp", "start"]}}},
     },
 }
 
 
+def get_claude_config_path() -> Path:
+    """Get Claude Desktop config path based on OS."""
+    home = Path.home()
+    system = platform.system()
+    
+    if system == "Windows":
+        return home / "AppData" / "Roaming" / "Claude" / "claude_desktop_config.json"
+    elif system == "Darwin":  # macOS
+        return home / "Library" / "Application Support" / "Claude" / "claude_desktop_config.json"
+    else:  # Linux
+        return home / ".config" / "Claude" / "claude_desktop_config.json"
+
+
 def detect_ide() -> list[str]:
     """Detect which IDEs are available in the current environment."""
     detected = []
     home = Path.home()
     
-    if (home / ".vscode/settings.json").exists():
+    # VS Code / Cursor mcp.json
+    if (home / ".vscode/mcp.json").exists() or (Path.cwd() / ".vscode/mcp.json").exists():
         detected.append("vscode")
-    if (home / ".cursor/settings.json").exists():
+    if (home / ".cursor/mcp.json").exists():
         detected.append("cursor")
-    if (home / ".windsurf/config.json").exists():
+    
+    # Windsurf
+    if (home / ".codeium/windsurf/mcp_config.json").exists():
         detected.append("windsurf")
-    if (home / "AppData/Roaming/Claude/settings.json").exists() or (home / ".claude/settings.json").exists():
+    
+    # Claude Desktop
+    if get_claude_config_path().exists():
         detected.append("claude")
-    if (home / ".cline/settings.json").exists():
+    
+    # Cline
+    if (home / ".cline/mcp.json").exists():
         detected.append("cline")
-    if (home / ".roocode/settings.json").exists():
+    
+    # RooCode
+    if (home / ".roocode/mcp.json").exists():
         detected.append("roocode")
-    if (home / ".gemini/settings.json").exists():
-        detected.append("gemini")
-    if (home / ".aws/amazonq/settings.json").exists():
-        detected.append("amazonq")
+    
+    # OpenCode
+    if (Path.cwd() / "opencode.json").exists() or (home / ".opencode/opencode.json").exists():
+        detected.append("opencode")
+    
+    # Antigravity
+    if (home / ".antigravity/mcp.json").exists():
+        detected.append("antigravity")
     
     return detected
 
@@ -112,12 +148,36 @@ def handle_mcp_setup(console: Console) -> None:
         return
     
     for target in targets:
+        ide = IDE_CONFIGS.get(target)
+        
+        if target == "claude":
+            console.print(f"\n[yellow]Claude Code:[/yellow] Run this command manually:")
+            console.print(f"  [cyan]{ide.get('cli_command')}[/cyan]")
+            console.print("[dim]Then restart Claude Code[/dim]")
+            continue
+        
+        if target == "opencode":
+            config_path = Path.cwd() / ide["file"]
+            config_path.parent.mkdir(parents=True, exist_ok=True)
+            
+            existing = {}
+            if config_path.exists():
+                try:
+                    existing = json.loads(config_path.read_text())
+                except:
+                    pass
+            
+            if "mcp" not in existing:
+                existing["mcp"] = {}
+            existing["mcp"]["cortexcode"] = ide["config"]["mcp"]["cortexcode"]
+            
+            config_path.write_text(json.dumps(existing, indent=2))
+            console.print(f"[green]✓[/green] Updated {config_path}")
+            continue
+        
         if target.startswith("custom:"):
             config_path = Path(target.split(":", 1)[1])
         else:
-            ide = IDE_CONFIGS.get(target)
-            if not ide:
-                continue
             config_path = Path.cwd() / ide["file"]
         
         config_path.parent.mkdir(parents=True, exist_ok=True)
@@ -129,15 +189,18 @@ def handle_mcp_setup(console: Console) -> None:
             except:
                 pass
         
-        mcp_key = "mcpServers"
+        # VS Code/Cursor use "servers", others use "mcpServers"
+        if target in ("vscode", "cursor"):
+            mcp_key = "servers"
+        else:
+            mcp_key = "mcpServers"
+        
         if mcp_key not in existing:
             existing[mcp_key] = {}
         
         existing[mcp_key]["cortexcode"] = {
             "command": "cortexcode",
             "args": ["mcp"],
-            "disabled": False,
-            "alwaysAllow": [],
         }
         
         config_path.write_text(json.dumps(existing, indent=2))

cortexcode/context/context_query.py

@@ -15,16 +15,17 @@ def get_context(index_path: Path, query: str | None = None, num_results: int = 5
         num_results: Number of results to return
 
     Returns:
-        Dictionary with relevant symbols and their relationships
+        Dictionary with relevant symbols and their code snippets
     """
     index = json.loads(index_path.read_text(encoding="utf-8"))
 
     files = index.get("files", {})
     call_graph = index.get("call_graph", {})
     file_deps = index.get("file_dependencies", {})
+    source_code = index.get("source_code", {})
 
     if not query:
-        return _get_all_symbols(files, call_graph, num_results)
+        return _get_all_symbols(files, call_graph, source_code, num_results)
 
     file_filter = None
     query_lower = query.lower()
@@ -44,11 +45,11 @@ def get_context(index_path: Path, query: str | None = None, num_results: int = 5
 
         for sym in symbols:
             if file_filter and not query_lower:
-                results.append(_build_symbol_result(sym, rel_path, call_graph))
+                results.append(_build_symbol_result(sym, rel_path, call_graph, source_code))
                 continue
 
             if _matches_query(sym, query_lower):
-                results.append(_build_symbol_result(sym, rel_path, call_graph))
+                results.append(_build_symbol_result(sym, rel_path, call_graph, source_code))
 
         if query_lower:
             for imp in imports:
@@ -79,8 +80,8 @@ def get_context(index_path: Path, query: str | None = None, num_results: int = 5
     return response
 
 
-def _build_symbol_result(sym: dict, rel_path: str, call_graph: dict) -> dict:
-    """Build a context result dict for a symbol."""
+def _build_symbol_result(sym: dict, rel_path: str, call_graph: dict, source_code: dict) -> dict:
+    """Build a context result dict for a symbol with actual code."""
     result = {
         "name": sym.get("name"),
         "type": sym.get("type"),
@@ -92,6 +93,11 @@ def _build_symbol_result(sym: dict, rel_path: str, call_graph: dict) -> dict:
         "framework": sym.get("framework"),
     }
 
+    # Add actual code snippet from source_code - look up by symbol name + type
+    code = _get_symbol_code(sym.get("name"), sym.get("type"), rel_path, source_code)
+    if code:
+        result["code"] = code
+
     if sym.get("return_type"):
         result["return_type"] = sym["return_type"]
 
@@ -105,7 +111,29 @@ def _build_symbol_result(sym: dict, rel_path: str, call_graph: dict) -> dict:
     return result
 
 
-def _get_all_symbols(files: dict, call_graph: dict, limit: int) -> dict[str, Any]:
+def _get_symbol_code(sym_name: str, sym_type: str, rel_path: str, source_code: dict) -> str | None:
+    """Get the actual code snippet for a symbol from source_code storage."""
+    if not source_code or not sym_name:
+        return None
+
+    # Try to find by symbol name + type key first
+    key = f"{sym_name}:{sym_type}"
+    if key in source_code:
+        file_data = source_code[key].get(rel_path)
+        if file_data:
+            return file_data.get("body")
+    
+    # Fallback: search through all keys for this symbol name
+    for code_key, files in source_code.items():
+        if code_key.startswith(f"{sym_name}:"):
+            file_data = files.get(rel_path)
+            if file_data:
+                return file_data.get("body")
+    
+    return None
+
+
+def _get_all_symbols(files: dict, call_graph: dict, source_code: dict, limit: int) -> dict[str, Any]:
     """Get all symbols, limited."""
     all_symbols = []
 

cortexcode/indexer.py

@@ -45,6 +45,7 @@ class CodeIndexer(IndexerExtractorMixin):
         self.symbols: list[dict[str, Any]] = []
         self.call_graph: dict[str, list[str]] = {}
         self.file_symbols: dict[str, list[dict[str, Any]]] = {}
+        self.source_code: dict[str, dict] = {}  # Store source code lines for context
         self.gitignore_patterns: list[tuple[str, bool]] = []
         
         # Filter options
@@ -85,6 +86,7 @@ class CodeIndexer(IndexerExtractorMixin):
         self.symbols = session["symbols"]
         self.call_graph = session["call_graph"]
         self.file_symbols = session["file_symbols"]
+        self.source_code = session.get("source_code", {})
         self.parsers = session["parsers"]
         
         self._load_gitignore(root_path)
@@ -153,6 +155,10 @@ class CodeIndexer(IndexerExtractorMixin):
     
     def _index_file(self, file_path: Path, root: Path) -> None:
         """Index a single file."""
+        rel_path = file_path.relative_to(root)
+        rel_str = str(rel_path)
+        
+        # First, run the actual indexing to get symbol positions
         result = index_file(
             file_path,
             root,
@@ -171,6 +177,41 @@ class CodeIndexer(IndexerExtractorMixin):
             return
 
         rel_path, file_data, symbols = result
+        
+        # Load full file content to extract complete function bodies
+        try:
+            content = file_path.read_text(encoding="utf-8", errors="ignore")
+            lines = content.split("\n")
+            
+            # Store full function bodies for each symbol
+            for sym in symbols:
+                sym_line = sym.get("line", 1)
+                sym_name = sym.get("name", "")
+                sym_type = sym.get("type", "")
+                
+                # Find the end of this symbol (next symbol or end of file)
+                end_line = len(lines)
+                for other_sym in symbols:
+                    other_line = other_sym.get("line", 1)
+                    if other_line > sym_line and (end_line == len(lines) or other_line < end_line):
+                        end_line = other_line - 1
+                
+                # Extract full body (with some context before)
+                start_line = max(1, sym_line - 2)
+                body_lines = lines[start_line-1:end_line]
+                body = "\n".join(body_lines)
+                
+                # Store with key: "symbol_name:type" for quick lookup
+                key = f"{sym_name}:{sym_type}"
+                if key not in self.source_code:
+                    self.source_code[key] = {}
+                self.source_code[key][rel_str] = {
+                    "line": sym_line,
+                    "body": body
+                }
+        except Exception:
+            pass
+        
         merge_indexed_file(
             rel_path,
             file_data,
@@ -182,7 +223,7 @@ class CodeIndexer(IndexerExtractorMixin):
     
     def _build_index(self, root: Path) -> dict[str, Any]:
         """Build the final index structure."""
-        return build_index_result(
+        result = build_index_result(
             root=root,
             file_symbols=self.file_symbols,
             call_graph=self.call_graph,
@@ -195,6 +236,9 @@ class CodeIndexer(IndexerExtractorMixin):
             regex_languages=REGEX_LANGUAGES,
             plugin_registry=plugin_registry,
         )
+        # Add source code for context retrieval
+        result["source_code"] = self.source_code
+        return result
 
 
 def index_directory(path: str | Path, incremental: bool = False, filter_opts: dict[str, Any] | None = None) -> dict[str, Any]:

cortexcode/main.py

@@ -494,7 +494,9 @@ def serve_lsp():
 @click.option("-I", "--include", multiple=True, help="Patterns to include, e.g., 'apps/*', 'packages/*'")
 @click.option("-r", "--root", default=None, help="Monorepo root (for nx-style projects)")
 @click.option("-n", "--dry-run", is_flag=True, help="Preview what would be indexed without indexing")
-def index(path, output, verbose, watch, incremental, include_tests, exclude, include, root, dry_run):
+@click.option("--no-post-index-wizard", is_flag=True, help="Skip the interactive post-index generation wizard")
+@click.option("--force-wizard", is_flag=True, help="Force showing the post-index wizard even in non-TTY mode")
+def index(path, output, verbose, watch, incremental, include_tests, exclude, include, root, dry_run, no_post_index_wizard, force_wizard):
     """Index a directory and save the code graph."""
     handle_index_command(
         console,
@@ -508,6 +510,8 @@ def index(path, output, verbose, watch, incremental, include_tests, exclude, inc
         include,
         root,
         dry_run,
+        no_post_index_wizard,
+        force_wizard,
         indexer,
         print_index_header_renderer,
         print_project_profile_summary_renderer,

cortexcode/mcp/mcp_registry.py

@@ -17,7 +17,7 @@ TOOL_DEFINITIONS = [
     },
     {
         "name": "cortexcode_context",
-        "description": "USE THIS when you need to understand how a function/class works, see its implementation, or see what it calls/who calls it. Also use when user asks 'how does X work' or 'show me the code for X'.",
+        "description": "USE THIS when you need to understand how a function/class works, see its implementation, or see what it calls/who calls it. Also use when user asks 'how does X work' or 'show me the code for X'. Returns ACTUAL CODE SNIPPETS from the index - no need to read files separately. This saves tokens and time.",
         "inputSchema": {
             "type": "object",
             "properties": {

{cortexcode-0.8.1.dist-info → cortexcode-0.9.1.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: cortexcode
-Version: 0.8.1
-Summary: Lightweight code indexing for AI assistants — save 90%+ tokens with structured context
+Version: 0.9.1
+Summary: Lightweight code indexing for AI assistants — build a searchable codegraph and grounded context
 Author-email: Naveen <naveen_joshi07@outlook.com>
 License: MIT
 Project-URL: Homepage, https://github.com/naveen-joshi/cortexcode
@@ -32,6 +32,7 @@ Requires-Dist: tree-sitter-rust>=0.23.0
 Requires-Dist: tree-sitter-java>=0.23.0
 Requires-Dist: tree-sitter-c-sharp>=0.23.0
 Requires-Dist: click>=8.1.0
+Requires-Dist: questionary>=2.0.1
 Requires-Dist: watchdog>=4.0.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: pyyaml>=6.0.0
@@ -54,44 +55,36 @@ Dynamic: license-file
   <h1 align="center">CortexCode</h1>
   <p align="center">
     <strong>Lightweight code indexing for AI assistants</strong><br>
-    Save 90%+ tokens by giving AI agents structured context instead of raw source files.
+    Build a searchable codegraph, generate documentation, and give AI assistants grounded context.
   </p>
 </p>
 
-<p align="center">
-  <a href="https://pypi.org/project/cortexcode/"><img src="https://img.shields.io/pypi/v/cortexcode?style=flat-square&color=blue" alt="PyPI"></a>
-  <a href="https://pypi.org/project/cortexcode/"><img src="https://img.shields.io/pypi/pyversions/cortexcode?style=flat-square" alt="Python"></a>
-  <a href="https://github.com/naveen-joshi/cortexcode/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT-green?style=flat-square" alt="License"></a>
-  <a href="https://github.com/naveen-joshi/cortexcode"><img src="https://img.shields.io/github/stars/naveen-joshi/cortexcode?style=flat-square" alt="Stars"></a>
-  <a href="https://marketplace.visualstudio.com/items?itemName=cortexcode.cortexcode-vscode"><img src="https://img.shields.io/visual-studio-marketplace/v/cortexcode.cortexcode-vscode?style=flat-square" alt="VS Code"></a>
-</p>
-
 ---
 
 ## The Problem
 
 AI coding assistants (Copilot, Cursor, Windsurf, etc.) need to understand your codebase. The current approach: **dump entire source files into the context window**. This is:
 
-- **Expensive** — A 150-file project can cost 200K+ tokens per query
-- **Slow** — More tokens = slower responses
-- **Wasteful** — Most of those tokens are irrelevant to the question
+- **Noisy** — Important signals are buried inside large files
+- **Fragile** — Assistants miss architecture, relationships, and runtime surface area
+- **Hard to reuse** — Raw file dumps do not become a durable project map
 
 ## The Solution
 
-CortexCode indexes your codebase using **AST parsing** (tree-sitter) and provides a structured, searchable index. Instead of feeding 200K tokens of raw code, you feed **~500 tokens of relevant context**.
+CortexCode indexes your codebase using **AST parsing** (tree-sitter) and builds a structured, searchable codegraph. You can explore symbols, trace flows, generate docs and diagrams, produce CodeWiki pages, and connect AI tools through MCP.
 
 ```
 ┌─────────────────────────────────────────────────┐
 │  Without CortexCode          With CortexCode    │
 │                                                  │
-│  200,000 tokens    →         500 tokens          │
-│  $0.006/query      →         $0.00002/query      │
-│  All files dumped  →         Only relevant syms  │
-│  No structure      →         Call graph + types   │
+│  Raw files only    →         Searchable codegraph │
+│  Manual digging    →         Linked symbols       │
+│  Ad-hoc prompts    →         Reusable context     │
+│  No project map    →         Docs + diagrams      │
 └─────────────────────────────────────────────────┘
 ```
 
-Run `cortexcode stats` on your project to see your actual savings.
+Run `cortexcode index` on your project to generate the codegraph and start exploring.
 
 ## Quick Start
 
@@ -107,9 +100,6 @@ cd cortexcode && pip install -e .
 cd your-project
 cortexcode index
 
-# See token savings
-cortexcode stats
-
 # Get context for AI
 cortexcode context "handleAuth"
 
@@ -117,6 +107,22 @@ cortexcode context "handleAuth"
 cortexcode docs --open
 ```
 
+### Post-Index Wizard
+
+After running `cortexcode index`, an interactive wizard can guide you through generating outputs:
+
+```bash
+cortexcode index              # Run index, then wizard prompts
+cortexcode index --force-wizard   # Force wizard in non-TTY mode
+cortexcode index --no-post-index-wizard  # Skip wizard
+```
+
+**Wizard features:**
+- Multi-select checkbox for docs, diagrams, AI docs, CodeWiki, reports, visualization, dashboard, MCP setup
+- Smart recommendations based on detected project shape
+- Follow-up prompts for diagram types, AI doc types, wiki options
+- Preference persistence — saves your choices for future runs
+
 ## Features
 
 ### Multi-Language AST Indexing
@@ -142,24 +148,14 @@ Parses source code into structured symbols using tree-sitter grammars.
 - **Entities** — Database models and ORM definitions
 - **Framework Detection** — React components, Angular services, etc.
 
-### Token Savings
+### Project Exploration & Context
 
-CortexCode dramatically reduces the tokens needed to give AI assistants useful context:
+Use CortexCode to inspect structure and answer practical questions about a codebase:
 
-```bash
-$ cortexcode stats
-
-╭──────── Token Savings Analysis ────────╮
-│ Source files         154 files          │
-│ Raw project tokens   203,847            │
-│ Full index tokens    45,291             │
-│ Context query tokens 487                │
-│                                         │
-│ Tokens saved         203,360            │
-│ Savings              99.8%              │
-│ Compression ratio    418.6x             │
-╰─────────────────────────────────────────╯
-```
+- **Context lookup** — Pull relevant symbols and files for a query
+- **Call graph tracing** — Follow how behavior moves across modules
+- **Architecture visibility** — Inspect routes, entities, dependencies, and layers
+- **Reusable index** — Keep a structured project map that tools can build on
 
 ### Interactive HTML Documentation
 
@@ -194,7 +190,6 @@ cortexcode wiki --no-modules       # Skip per-module pages (faster)
 - **Mermaid diagrams** — Auto-generated flow diagrams
 - **Concept mapping** — Maps technical concepts to symbols and files
 - **Concept search** — Ask "how does authentication work?" and get grounded answers
-- **Token tracking** — See exactly how many tokens each page used
 
 **Output:** `.cortexcode/wiki/index.html` — Open directly or serve locally.
 
@@ -245,12 +240,12 @@ CortexCode supports both a short form (`cc`) and full form (`cortexcode`). Comma
 | Command | Description |
 |---------|-------------|
 | `cc analyze context [query]` | Get relevant context for AI |
-| `cc analyze context [query] --tokens` | Show token savings for query |
+| `cc analyze context [query] --tokens` | Show context size estimates for a query |
 | `cc analyze search [query]` | Grep-like symbol search with type/file filters |
 | `cc analyze find [query]` | Semantic search by meaning ("auth handler") |
 | `cc analyze diff` | Show changed symbols since last commit |
 | `cc analyze diff --ref HEAD~3` | Compare against any git ref |
-| `cc analyze stats` | Show project stats and token savings |
+| `cc analyze stats` | Show project index and analysis stats |
 | `cc analyze scan` | Scan dependencies for security warnings |
 | `cc analyze trace <symbol>` | Trace code flow through call graph |
 | `cc analyze flow <concept>` | Analyze code flow grouped by file |
@@ -355,7 +350,7 @@ Add to `~/.windsurf/config.json`:
 
 ```bash
 # Paste this output into your AI chat
-cortexcode context "useAuth" --tokens
+cortexcode context "useAuth"
 ```
 
 ### 2. JSON Index (programmatic)
@@ -552,7 +547,6 @@ CortexCode respects `.gitignore` files (including nested ones) and has built-in
 ## Roadmap
 
 - [x] MCP server for direct AI agent integration
-- [x] Tiktoken-based accurate token counting
 - [x] Semantic search over symbols (TF-IDF + synonym expansion)
 - [x] Cross-file type inference
 - [x] Git diff-aware context (show only changed symbols)

{cortexcode-0.8.1.dist-info → cortexcode-0.9.1.dist-info}/RECORD

@@ -6,9 +6,9 @@ cortexcode/context.py,sha256=CEX__dc21fdSLNg-Ec48ROTBILzEDufKPKANah_0HKk,342
 cortexcode/dashboard.py,sha256=NNK4EhgBo3gBuwwntT5wIi7ZlX1ThHVlbxn6q0c-HdE,5361
 cortexcode/docs.py,sha256=GT6GxWK7r-Zq-9VqxaLFAo9Yzh11kgwUgdaz46H4NmI,912
 cortexcode/git_diff.py,sha256=YEEZM2yKYztE-T7rI5iBf2NluY4G1WIjlp-DprZ-6Rs,5742
-cortexcode/indexer.py,sha256=uDSpGXOX-3q3dBgX3uUTakGKPsknfhmgod-kXCXOivo,8575
+cortexcode/indexer.py,sha256=lcw6iGF1rPpBpvyX9XnAKBnjl6Yatv9RpB78VceQFyo,10477
 cortexcode/lsp_server.py,sha256=mAPk78OVWQodBjBI3WhqEjrwjXrb0MF630IYDZ8_MLM,11102
-cortexcode/main.py,sha256=tDd0mPBhBp5x1eWsdcouzREPJUZ2npphfpJ7UA5Z884,43069
+cortexcode/main.py,sha256=G7iiyXkE9c5Oe6cI4HnH6g4yXOCRih2O_Hihx9an82M,43380
 cortexcode/performance.py,sha256=tkr7RMjIuutQqcNO8wgLBNzNMFXti7y9CkiSetPam_A,706
 cortexcode/plugins.py,sha256=6WsmnvRT7D_coxD6YgwB-Dpu_iKOS89FNnT-gkgK4-8,6298
 cortexcode/semantic_search.py,sha256=PO1FjbQhKf6EGfwtwHcdqVXL5W_xMr4e7GxuctdrFzM,8745
@@ -26,7 +26,7 @@ cortexcode/advanced_analysis/advanced_analysis_security.py,sha256=ZkXbzZHim7KnHs
 cortexcode/ai_docs/__init__.py,sha256=W68LGb82g2wVOsvm3DfMd9esntVfgZH4cwDzcAxRpGg,472
 cortexcode/ai_docs/config.py,sha256=7qwDS2t7q6t-eQepBi51PsV9uTggrtzsD_JI7jH8_6k,3388
 cortexcode/ai_docs/doc_cache.py,sha256=Im4nhro2sT0uytq0rajRntd3v6KUCmspS4VDmQWeHl8,1220
-cortexcode/ai_docs/doc_generator.py,sha256=O8Yy_okZf5Kcc2sLK6LN87JyWAZCS83H-l0dwdMbu1o,7018
+cortexcode/ai_docs/doc_generator.py,sha256=8zelx0xH6tCrEeAPyYuzWb5a7rejPT5AjfmPu2znZ64,7108
 cortexcode/ai_docs/doc_lookup.py,sha256=L_q4o_tYb_UK3l7CT-ZQBdKZPzCL7oH30LkaCxYoVdI,1067
 cortexcode/ai_docs/doc_models.py,sha256=jNGOposSsYrcrzC7UJ_81PP2yP9lzZtJ3dsxfbV7cio,339
 cortexcode/ai_docs/explainer.py,sha256=rMPab2N9UkfeY6NrmiaM2OZNElRUKqv7ZXVuzUnq6bo,9557
@@ -53,13 +53,13 @@ cortexcode/cli/cli_explain.py,sha256=q_Gh1m3XXzcJXa9px1OOMPlLx3-CqJ0x_VK3TgciltE
 cortexcode/cli/cli_find.py,sha256=EueM1_fYWgDIRD5mUJ798lN5QW3UOyz7gW0jeEMytlM,1314
 cortexcode/cli/cli_githook.py,sha256=TJoVrTlRDSeL9SzQQzKDWy8lVAR8utHxldUlawCVE-o,3315
 cortexcode/cli/cli_impact.py,sha256=KXAt8asPE9HoQmixGaBGPX7iRBGVjN7jalFnM8DDNXY,2080
-cortexcode/cli/cli_index.py,sha256=52xDZiIQsS3Zk2QKZ0TRkNverJfGbAQ4TR3pQyTsvuw,3925
+cortexcode/cli/cli_index.py,sha256=LR79rBBPQpjt1c70eTyjVUKX3EIs-SYo3vk0rRE4Pj0,23524
 cortexcode/cli/cli_jobs.py,sha256=Zy_p2xS5KNWSlZ0dEgYbJbUNMV4CMuN22s_PwHUYptc,4820
 cortexcode/cli/cli_package.py,sha256=YQ3BI2-BUTvy7zaLHulFRxpFQzwt5pBwPi55XFs83CI,7688
 cortexcode/cli/cli_report.py,sha256=4scGu4Tv_mq7jRMu1KJ8YxBWrdMovOJmfZEfwu5olnU,562
 cortexcode/cli/cli_scan.py,sha256=Br3-8DLnnOspnLCHFi5Jg8_XBViRaQjHiBcazkQGadA,1224
 cortexcode/cli/cli_search.py,sha256=FKBjdXAgj3wu4DM_n175HMTPHjTIuZDcEQ5nYnEjOz8,1925
-cortexcode/cli/cli_servers.py,sha256=wkfjVn0kc9-8PwFYrMhCLxPUp9p9vUXZfb4gwrAr3A8,5718
+cortexcode/cli/cli_servers.py,sha256=xnK4xL5qrr2FS-dw0z1EEOgMKMR7LSRmxPew91Wc51g,7717
 cortexcode/cli/cli_shell.py,sha256=J6ji1zhM4g-JqbUrzD43lWqsqvSkAGYvTiiyWg9OZso,5173
 cortexcode/cli/cli_stats.py,sha256=P7RrX4CcqslGWQ1ZDUjOfPojDZ6hYVXwhRUbNvL3Iq4,601
 cortexcode/cli/cli_support.py,sha256=Y05HqRtMeNsGPJruJZj8g0PLflEHRNByoFBWyf_1po4,954
@@ -69,7 +69,7 @@ cortexcode/cli/cli_wiki.py,sha256=VLKxFkqWsWa9Dp4b4k5aV8B8d607pDcnwElqTXHIf2c,58
 cortexcode/cli/cli_workspace.py,sha256=_l3aGwHfPvI-UfriM8FfztAwINN5dnlV2UFQ5AtWjiQ,3805
 cortexcode/context/__init__.py,sha256=vHyIXWJ7LRvtgh1PVywTUZ3JkFLRgJT8OD_xj9WW2YU,430
 cortexcode/context/context_format.py,sha256=4cH-MEDZbdDTYunUxDqgB0Wvm7CP9b_lVkyVkkC9FxM,623
-cortexcode/context/context_query.py,sha256=JDWG9-LTxGTrmnKfAetb0mR-CqBBJKtx5phAs-ECimE,5934
+cortexcode/context/context_query.py,sha256=iu4nUdRS5-gQ2CKJBB5EcjeNsSsAZTDhpAD3DGfIogA,7047
 cortexcode/context/context_tokens.py,sha256=xN69ADHUn7rUlKmDJN6q7HY_I4fX9QzJyoz0Hkv6WEw,2217
 cortexcode/diagrams/__init__.py,sha256=xKmWh67Kt8ngSnNuOQ1ff2uwzZJ9boxepQsPNu6vm7I,1143
 cortexcode/diagrams/architecture.py,sha256=xx5yekiAF-VF0LxC9dbXsKjKskOlXQRuS6jlefoRPY8,2482
@@ -135,7 +135,7 @@ cortexcode/knowledge/snippets.py,sha256=8cpetnmY-KdFj4aWSt55mmO6JJ502CU6r01Jpjpx
 cortexcode/knowledge/usage.py,sha256=U6_wuXMqsNBSyZtOeerWtexoAu6ma1Eb8yds7HpTgCs,3549
 cortexcode/mcp/__init__.py,sha256=ibMesuUdMZtpjx294SNPZi5oNitZmj3DJYCOntw9Aw4,699
 cortexcode/mcp/mcp_protocol.py,sha256=grKhPjzbYSi7GI93WifnZ4NHYW8K-NdYeGUZtqrN4Zc,379
-cortexcode/mcp/mcp_registry.py,sha256=nE9_6AscXnblfDGtGS1uXGx85spw1bjqN1Db5Uu-5Yk,9438
+cortexcode/mcp/mcp_registry.py,sha256=9pRGfkHxnQB1pT6MBto9RwOo9AdEXoop8cX_-qnkjDw,9546
 cortexcode/mcp/mcp_server.py,sha256=RM7PGxRqpijgxc_GS3r-8ax42myEl-uDnKiXgRkpPx4,2835
 cortexcode/mcp/mcp_tool_handlers.py,sha256=QOA1-dWMl_iE65y1y7Gq79fICbSq4H1n0v5HqLsbdWw,9304
 cortexcode/mcp/mcp_transport.py,sha256=-ep5iL4z6lP0gahFq_3fb_fruh8kNrQMEBpK1HoPCpo,1864
@@ -165,9 +165,9 @@ cortexcode/terminal/headers.py,sha256=Yk9IGniMCiZD45V_yc1mjM3WjHimxoe9vL3CE5NAWv
 cortexcode/terminal/prompts.py,sha256=KRwjLipbO5Ihv3ycp1T2nGQtoGmKPP1ZNXb3BUz4oF4,359
 cortexcode/terminal/reports.py,sha256=4nLu0fBqDWKuQowX78VqX1nBaJl2zrTt9vEYCVP--O0,10135
 cortexcode/terminal/stats.py,sha256=PooaYP-OqaewhwypnUHESOrdwwICvggb3n2HdqEQxrc,1365
-cortexcode-0.8.1.dist-info/licenses/LICENSE,sha256=DWE8vkHgP2ChQTJHFWtrutLbuHQUBsU_InyfesP4neo,1067
-cortexcode-0.8.1.dist-info/METADATA,sha256=UsS0GRN1LsxE2UpgtZZwnMmf5lcLmr8r_SLDuMWsEGw,21188
-cortexcode-0.8.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-cortexcode-0.8.1.dist-info/entry_points.txt,sha256=3TfwRp96e7ICJDUoJpcAu3NXVGT6HcyvHVU3pQ_vftg,78
-cortexcode-0.8.1.dist-info/top_level.txt,sha256=r8FxzjLfKhRXXcORnECtGo7i2zKYXlV7v1XnIJ0SOc0,11
-cortexcode-0.8.1.dist-info/RECORD,,
+cortexcode-0.9.1.dist-info/licenses/LICENSE,sha256=DWE8vkHgP2ChQTJHFWtrutLbuHQUBsU_InyfesP4neo,1067
+cortexcode-0.9.1.dist-info/METADATA,sha256=D4Xoobbt4QrM5hxIQiU-ZTz8SRyE2gcGZ3Ud1uxsB5s,20648
+cortexcode-0.9.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+cortexcode-0.9.1.dist-info/entry_points.txt,sha256=3TfwRp96e7ICJDUoJpcAu3NXVGT6HcyvHVU3pQ_vftg,78
+cortexcode-0.9.1.dist-info/top_level.txt,sha256=r8FxzjLfKhRXXcORnECtGo7i2zKYXlV7v1XnIJ0SOc0,11
+cortexcode-0.9.1.dist-info/RECORD,,