forgeoptimizer 0.1.0__py3-none-any.whl

forgecli/builder/formatter.py

@@ -0,0 +1,31 @@
+"""Source code formatting dispatcher."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from pathlib import Path
+
+from forgecli.core.service import Service
+
+
+class Formatter(Service):
+    """Dispatch code formatting to a language-specific backend.
+
+    The default implementation is a no-op placeholder; concrete
+    formatters (ruff, black, prettier, gofmt) will be plugged in here
+    without changing call sites.
+    """
+
+    name = "builder.formatter"
+
+    def __init__(self, *, backend: str = "auto") -> None:
+        super().__init__()
+        self._backend = backend
+
+    @property
+    def backend(self) -> str:
+        return self._backend
+
+    def format(self, paths: Iterable[Path]) -> list[Path]:
+        """Format ``paths``; placeholder returns the input untouched."""
+        return [Path(p) for p in paths]

forgecli/cli/__init__.py

@@ -0,0 +1,5 @@
+"""Command-line interface for ForgeCLI."""
+
+from forgecli.cli.main import app
+
+__all__ = ["app"]

forgecli/cli/bootstrap.py

@@ -0,0 +1,281 @@
+"""Build the :class:`AppContext` for a CLI invocation."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from forgecli.config.loader import ConfigLoader
+from forgecli.core.context import AppContext
+from forgecli.core.logging import configure_logging, get_logger
+from forgecli.providers.anthropic import AnthropicProvider
+from forgecli.providers.base import ProviderRegistry, default_registry
+from forgecli.providers.google import GeminiProvider
+from forgecli.providers.mock import MockProvider
+from forgecli.providers.openai import OpenAIProvider
+from forgecli.providers.router_state import load_state as load_router_state
+from forgecli.utils.paths import ProjectPaths
+
+if TYPE_CHECKING:  # pragma: no cover - typing only
+    from forgecli.core.container import Container
+    from forgecli.optimizer.summarizer import Summarizer
+
+log = get_logger(__name__)
+
+
+def bootstrap_context(
+    *,
+    config_path: Path | None = None,
+    cwd: Path | str | None = None,
+    extras: dict[str, Any] | None = None,
+) -> AppContext:
+    """Build an :class:`AppContext` with default services registered."""
+    if isinstance(cwd, str):
+        cwd = Path(cwd)
+    import click
+
+    try:
+        click_ctx = click.get_current_context(silent=True)
+    except Exception:
+        click_ctx = None
+
+    if (
+        click_ctx is not None
+        and click_ctx.obj is not None
+        and isinstance(click_ctx.obj, AppContext)
+    ):
+        return click_ctx.obj
+
+    paths = ProjectPaths.from_env(cwd=cwd).ensure()
+
+    verbose = (extras or {}).get("verbose", False)
+    level = "DEBUG" if verbose else "INFO"
+    configure_logging(level=level)
+
+    loader = ConfigLoader(config_path) if config_path else ConfigLoader()
+
+    from forgecli.providers.openai_compatible import (
+        CohereProvider,
+        FireworksProvider,
+        GroqProvider,
+        LMStudioProvider,
+        MiniMaxProvider,
+        MistralProvider,
+        NvidiaProvider,
+        OllamaProvider,
+        OpenRouterProvider,
+        TogetherProvider,
+        VllmProvider,
+        XaiProvider,
+    )
+
+    provider_registry: ProviderRegistry = default_registry
+    for name, cls in (
+        ("mock", MockProvider),
+        ("openai", OpenAIProvider),
+        ("anthropic", AnthropicProvider),
+        ("google", GeminiProvider),
+        ("openrouter", OpenRouterProvider),
+        ("groq", GroqProvider),
+        ("mistral", MistralProvider),
+        ("minimax", MiniMaxProvider),
+        ("xai", XaiProvider),
+        ("together", TogetherProvider),
+        ("fireworks", FireworksProvider),
+        ("cohere", CohereProvider),
+        ("nvidia", NvidiaProvider),
+        ("ollama", OllamaProvider),
+        ("lmstudio", LMStudioProvider),
+        ("vllm", VllmProvider),
+    ):
+        provider_registry.register(name, cls)
+
+    container = _build_container(provider_registry, paths)
+    context = AppContext(paths=paths, loader=loader, container=container)
+    merged = dict(extras or {})
+    merged.setdefault(
+        "optimizer.state",
+        _load_optimizer_state(paths),
+    )
+    merged.setdefault(
+        "router.state",
+        load_router_state(paths.data_dir / "router.json"),
+    )
+    context.extras.update(merged)
+    if click_ctx is not None:
+        click_ctx.obj = context
+    return context
+
+
+def _load_optimizer_state(paths: ProjectPaths):
+    """Read the persisted optimizer state from ``data_dir/optimizer.json``."""
+    from forgecli.optimizer.ponytail import Intensity
+    from forgecli.optimizer.ponytail.state import OptimizerState
+
+    state_path = paths.data_dir / "optimizer.json"
+    if not state_path.exists():
+        return OptimizerState()
+    try:
+        payload = json.loads(state_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return OptimizerState()
+
+    state = OptimizerState()
+    intensity = payload.get("intensity")
+    if isinstance(intensity, str):
+        try:
+            state.intensity = Intensity.parse(intensity)
+        except ValueError:
+            state.intensity = Intensity.LITE
+    backend = payload.get("backend")
+    if isinstance(backend, str):
+        state.backend = backend
+    binary = payload.get("binary")
+    if isinstance(binary, str):
+        state.binary = binary
+    return state
+
+
+def _build_container(
+    provider_registry: ProviderRegistry,
+    paths: ProjectPaths,
+):
+    """Register default services in the DI container."""
+    from forgecli.core.container import Container
+    from forgecli.graph.backend_graphify import GraphifyRepositoryGraph
+    from forgecli.graph.graph import CodeGraph
+    from forgecli.graph.indexer import Indexer
+    from forgecli.graph.repository import RepositoryGraph
+    from forgecli.memory.store import MemoryStore
+    from forgecli.optimizer.chunker import Chunker
+    from forgecli.optimizer.optimizer import ContextOptimizer
+    from forgecli.optimizer.ponytail import PromptOptimizer
+    from forgecli.optimizer.ponytail.factory import build_optimizer
+    from forgecli.optimizer.ranker import Ranker
+    from forgecli.optimizer.summarizer import Summarizer
+    from forgecli.prompts.loader import PromptLoader
+    from forgecli.prompts.registry import PromptRegistry
+    from forgecli.prompts.renderer import PromptRenderer
+    from forgecli.providers.router import ModelRouter
+    from forgecli.templates.engine import TemplateEngine
+    from forgecli.templates.registry import TemplateRegistry
+
+    container = Container()
+
+    container.register_instance(ProviderRegistry, provider_registry)
+    container.register_instance(ProjectPaths, paths)
+    container.register_instance(CodeGraph, CodeGraph())
+
+    container.register(MemoryStore, lambda c: MemoryStore(paths.data_dir / "history.db"))
+    container.register(Summarizer, lambda c: _build_default_summarizer(c))
+    container.register(
+        ContextOptimizer,
+        lambda c: ContextOptimizer(
+            chunker=Chunker(),
+            ranker=Ranker(),
+            summarizer=c.resolve(Summarizer) if c.has(Summarizer) else None,
+        ),
+    )
+    container.register(
+        Indexer,
+        lambda c: Indexer(
+            graph=c.resolve(CodeGraph),
+            root=paths.cwd,
+        ),
+    )
+    container.register(
+        RepositoryGraph,  # type: ignore[type-abstract]
+        lambda _c: GraphifyRepositoryGraph(root=paths.cwd),
+    )
+    container.register(
+        PromptOptimizer,  # type: ignore[type-abstract]
+        lambda _c: build_optimizer(_load_optimizer_state(paths), ConfigLoader().load()),
+    )
+    container.register(
+        ModelRouter,
+        lambda c: ModelRouter(registry=c.resolve(ProviderRegistry)),
+    )
+    container.register(PromptRenderer, lambda _c: PromptRenderer())
+    container.register(PromptLoader, lambda _c: PromptLoader(paths.prompts_dir))
+    container.register(PromptRegistry, lambda _c: PromptRegistry())
+    container.register(TemplateEngine, lambda c: TemplateEngine(renderer=c.resolve(PromptRenderer)))
+    container.register(TemplateRegistry, lambda _c: TemplateRegistry())
+
+    return container
+
+
+def _build_default_summarizer(container: Container) -> Summarizer:
+    """Wire the default summarizer against the mock provider.
+
+    Real provider wiring will live in a separate composition function and
+    will be selected via configuration.
+    """
+    from forgecli.optimizer.summarizer import Summarizer
+    from forgecli.providers.mock import MockProvider, MockProviderConfig
+
+    provider = MockProvider(MockProviderConfig())
+    return Summarizer(provider=provider)
+
+
+def resolve_provider_and_decision(
+    *,
+    live: bool,
+    cwd: Path | str,
+) -> tuple[Any, Any]:
+    """Unified provider and route decision resolver for all AI commands.
+
+    If live is True and no provider has credentials (which resolves to mock),
+    it displays the error requesting configuration and exits with code 1.
+    """
+    import typer
+
+    from forgecli.providers.base import ProviderRegistry
+    from forgecli.providers.mock import MockProvider, MockProviderConfig
+    from forgecli.providers.router import (
+        ModelRouter,
+        RouteDecision,
+        SelectionMode,
+        _provider_has_credentials,
+    )
+    from forgecli.providers.router_state import load_state as load_router_state
+
+    if isinstance(cwd, str):
+        cwd = Path(cwd)
+
+    app_context = bootstrap_context(cwd=cwd)
+    state = load_router_state(app_context.paths.data_dir / "router.json")
+    router = app_context.container.resolve(ModelRouter)
+    decision = router.select(state.choice)
+
+    if not live:
+        provider: Any = MockProvider(MockProviderConfig())
+        decision = RouteDecision(
+            provider_name="mock",
+            model=decision.model,
+            mode=SelectionMode.FALLBACK,
+        )
+        return provider, decision
+
+    if decision.provider_name == "mock" or not _provider_has_credentials(decision.provider_name):
+        from forgecli.cli.ui import error
+
+        error(
+            "No AI provider configured.\n\n"
+            "Run:\n"
+            "  forge provider use <provider>\n"
+            "  forge model use <model>\n\n"
+            "Then retry."
+        )
+        raise typer.Exit(code=1)
+
+    registry = app_context.container.resolve(ProviderRegistry)
+    if not registry.has(decision.provider_name):
+        from forgecli.cli.ui import error
+
+        error(f"Unknown provider '{decision.provider_name}'.")
+        raise typer.Exit(code=1)
+
+    provider_cls = registry.get(decision.provider_name)
+    provider = provider_cls()  # type: ignore[call-arg]
+    return provider, decision

forgecli/cli/commands_graph.py

@@ -0,0 +1,149 @@
+"""``forge graph`` subcommand group: build.
+
+These commands integrate the external Graphify CLI behind the
+:mod:`forgecli.graph.repository` abstraction. When Graphify is not
+installed the commands print an installation hint instead of failing.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import typer
+
+from forgecli.cli.ui import (
+    error,
+    get_console,
+    info,
+    success,
+)
+from forgecli.graph.backend_graphify import GraphifyRepositoryGraph
+from forgecli.utils.fs import has_supported_source_files
+from forgecli.utils.paths import to_privacy_path
+
+app = typer.Typer(
+    help="Build the codebase graph.",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+)
+
+
+def _build_backend(path: Path) -> GraphifyRepositoryGraph:
+    return GraphifyRepositoryGraph(root=path)
+
+
+async def _require_graphify(backend: GraphifyRepositoryGraph) -> None:
+    if not await backend.is_available():
+        raise typer.Exit(code=1) from None
+
+
+def setup_graphify_credentials(path: Path) -> str | None:
+    """Read the active provider, load its API key, set env vars, and return provider name if configured."""
+    from forgecli.cli.bootstrap import bootstrap_context
+    from forgecli.core.credentials import get_api_key
+    from forgecli.providers.router import _PROVIDER_ENV_VARS, ModelRouter
+    from forgecli.providers.router_state import load_state as load_router_state
+
+    app_context = bootstrap_context(cwd=path)
+    state = load_router_state(app_context.paths.data_dir / "router.json")
+    router = app_context.container.resolve(ModelRouter)
+    decision = router.select(state.choice)
+
+    provider_name = decision.provider_name
+    if provider_name == "mock":
+        return None
+
+    # Try env vars first
+    env_vars = _PROVIDER_ENV_VARS.get(provider_name, ())
+    for ev in env_vars:
+        if os.environ.get(ev):
+            return provider_name
+
+    # Try keychain/credential manager
+    api_key = get_api_key(provider_name)
+    if api_key:
+        for ev in env_vars:
+            os.environ[ev] = api_key
+        return provider_name
+
+    return None
+
+
+@app.command("build")
+def build_cmd(
+    path: str = typer.Option(".", "--path", "-p", help="Project root to index."),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        help="Overwrite graph.json even if the rebuild has fewer nodes.",
+    ),
+    no_cluster: bool = typer.Option(False, "--no-cluster", help="Skip Leiden clustering."),
+) -> None:
+    """Build (or rebuild) the codebase graph for ``path``."""
+    import asyncio
+
+    path_obj = Path(path).resolve()
+
+    # 1. Exit cleanly if no supported source files found
+    if not has_supported_source_files(path_obj):
+        get_console().print("No supported source files found. Nothing to build.")
+        raise typer.Exit(code=0)
+
+    # 2. Check credentials first. Never continue without a valid provider configuration.
+    active_provider = setup_graphify_credentials(path_obj)
+    if not active_provider:
+        get_console().print(
+            "❌ API key required.\n\n"
+            "Forge Graph requires an AI provider API key before a knowledge graph can be built."
+        )
+        raise typer.Exit(code=1)
+
+    backend = _build_backend(path_obj)
+
+    async def _run() -> None:
+        if not await backend.is_available():
+            get_console().print(await backend.install_hint())
+            raise typer.Exit(code=1)
+
+        info(f"Building graph for [accent]{to_privacy_path(backend.root)}[/accent] ...")
+
+        try:
+            import json
+            import time
+
+            start_time = time.perf_counter()
+            result = await backend.build(force=force, no_cluster=no_cluster)
+            build_duration = time.perf_counter() - start_time
+
+            try:
+                build_time_file = backend.root / "graphify-out" / "build_time.json"
+                build_time_file.parent.mkdir(parents=True, exist_ok=True)
+                with open(build_time_file, "w", encoding="utf-8") as f:
+                    json.dump({"build_time": build_duration}, f)
+            except Exception:
+                pass
+
+            snapshot = result.snapshot
+            get_console().print(
+                f"  nodes:      [bold]{len(snapshot.nodes)}[/bold]\n"
+                f"  edges:      [bold]{len(snapshot.edges)}[/bold]\n"
+                f"  communities:[bold]{len(snapshot.communities)}[/bold]"
+            )
+            for label, value in result.artifacts.items():
+                get_console().print(f"  [muted]{label}:[/muted] {to_privacy_path(value)}")
+            success("Graph built.")
+        except Exception as exc:
+            error(f"Graph build failed: {exc}")
+            raise typer.Exit(code=1) from exc
+
+    try:
+        asyncio.run(_run())
+    except typer.Exit:
+        raise
+    except Exception as exc:
+        error(f"Graph build failed: {exc}")
+        raise typer.Exit(code=1) from exc
+
+
+__all__ = ["app"]

forgecli/cli/commands_wrappers.py

@@ -0,0 +1,80 @@
+"""Wrapper commands: forge claude | codex | cursor | opencode | commandcode."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from forgecli.runtime.wrappers import launch_wrapper
+
+_WRAPPER_SETTINGS = {
+    "allow_extra_args": True,
+    "allow_interspersed_args": True,
+    "ignore_unknown_options": True,
+}
+
+
+def claude_cmd(
+    ctx: typer.Context,
+    path: str = typer.Option(".", "--path", "-p", help="Project root."),
+    refresh: bool = typer.Option(False, "--refresh", help="Bypass cached Forge context."),
+) -> None:
+    """Launch Claude Code with Forge prompt + token optimization."""
+    launch_wrapper("claude", list(ctx.args), path=Path(path), force_prepare=refresh)
+
+
+def codex_cmd(
+    ctx: typer.Context,
+    path: str = typer.Option(".", "--path", "-p", help="Project root."),
+    refresh: bool = typer.Option(False, "--refresh", help="Bypass cached Forge context."),
+) -> None:
+    """Launch Codex CLI with Forge prompt + token optimization."""
+    launch_wrapper("codex", list(ctx.args), path=Path(path), force_prepare=refresh)
+
+
+def cursor_cmd(
+    ctx: typer.Context,
+    path: str = typer.Option(".", "--path", "-p", help="Project root."),
+    refresh: bool = typer.Option(False, "--refresh", help="Bypass cached Forge context."),
+) -> None:
+    """Launch Cursor CLI with Forge prompt + token optimization."""
+    launch_wrapper("cursor", list(ctx.args), path=Path(path), force_prepare=refresh)
+
+
+def opencode_cmd(
+    ctx: typer.Context,
+    path: str = typer.Option(".", "--path", "-p", help="Project root."),
+    refresh: bool = typer.Option(False, "--refresh", help="Bypass cached Forge context."),
+) -> None:
+    """Launch OpenCode CLI with Forge prompt + token optimization."""
+    launch_wrapper("opencode", list(ctx.args), path=Path(path), force_prepare=refresh)
+
+
+def commandcode_cmd(
+    ctx: typer.Context,
+    path: str = typer.Option(".", "--path", "-p", help="Project root."),
+    refresh: bool = typer.Option(False, "--refresh", help="Bypass cached Forge context."),
+) -> None:
+    """Launch CommandCode CLI with Forge prompt + token optimization."""
+    launch_wrapper("commandcode", list(ctx.args), path=Path(path), force_prepare=refresh)
+
+
+def antigravity_cmd(
+    ctx: typer.Context,
+    path: str = typer.Option(".", "--path", "-p", help="Project root."),
+    refresh: bool = typer.Option(False, "--refresh", help="Bypass cached Forge context."),
+) -> None:
+    """Launch Antigravity CLI with Forge prompt + token optimization."""
+    launch_wrapper("antigravity", list(ctx.args), path=Path(path), force_prepare=refresh)
+
+
+__all__ = [
+    "_WRAPPER_SETTINGS",
+    "antigravity_cmd",
+    "claude_cmd",
+    "codex_cmd",
+    "commandcode_cmd",
+    "cursor_cmd",
+    "opencode_cmd",
+]