forgeoptimizer 1.0.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 auth login\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,137 @@
+"""``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:
+        error(
+            "No API key configured. Run 'forge auth login' or export "
+            "OPENAI_API_KEY / ANTHROPIC_API_KEY / GEMINI_API_KEY before running 'forge graph build'."
+        )
+        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:
+            result = await backend.build(force=force, no_cluster=no_cluster)
+            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,63 @@
+"""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)
+
+
+__all__ = ["_WRAPPER_SETTINGS", "claude_cmd", "codex_cmd", "commandcode_cmd", "cursor_cmd", "opencode_cmd"]

forgecli/cli/main.py

@@ -0,0 +1,122 @@
+"""Top-level Typer application for Forge."""
+
+from __future__ import annotations
+
+import contextlib
+import signal
+import warnings
+from pathlib import Path
+
+import typer
+
+from forgecli import __app_name__, __version__
+from forgecli.cli import commands_graph, commands_wrappers
+from forgecli.cli.bootstrap import bootstrap_context
+from forgecli.cli.ui import error, get_console
+from forgecli.core.errors import ForgeCLIError
+
+warnings.filterwarnings("ignore")
+
+with contextlib.suppress(AttributeError):
+    signal.signal(signal.SIGPIPE, signal.SIG_DFL)
+
+app = typer.Typer(
+    name="forge",
+    help="Forge — AI optimization runtime for Claude Code, Codex, Cursor, OpenCode, and CommandCode CLI.",
+    no_args_is_help=False,
+    add_completion=False,
+    rich_markup_mode="rich",
+)
+
+app.add_typer(commands_graph.app, name="graph")
+app.command(
+    "claude",
+    help="Launch Claude Code with Forge prompt + token optimization.",
+    context_settings=commands_wrappers._WRAPPER_SETTINGS,
+)(commands_wrappers.claude_cmd)
+app.command(
+    "codex",
+    help="Launch Codex CLI with Forge prompt + token optimization.",
+    context_settings=commands_wrappers._WRAPPER_SETTINGS,
+)(commands_wrappers.codex_cmd)
+app.command(
+    "cursor",
+    help="Launch Cursor CLI with Forge prompt + token optimization.",
+    context_settings=commands_wrappers._WRAPPER_SETTINGS,
+)(commands_wrappers.cursor_cmd)
+app.command(
+    "opencode",
+    help="Launch OpenCode CLI with Forge prompt + token optimization.",
+    context_settings=commands_wrappers._WRAPPER_SETTINGS,
+)(commands_wrappers.opencode_cmd)
+app.command(
+    "commandcode",
+    help="Launch CommandCode CLI with Forge prompt + token optimization.",
+    context_settings=commands_wrappers._WRAPPER_SETTINGS,
+)(commands_wrappers.commandcode_cmd)
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        get_console().print(f"{__app_name__} [muted]v{__version__}[/muted]")
+        raise typer.Exit()
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    config: Path | None = typer.Option(
+        None,
+        "--config",
+        "-c",
+        help="Path to a forgecli.toml file.",
+    ),
+    verbose: bool = typer.Option(False, "--verbose", help="Enable debug logging."),
+    version: bool = typer.Option(
+        False,
+        "--version",
+        callback=_version_callback,
+        is_eager=True,
+        help="Show the version and exit.",
+    ),
+) -> None:
+    """Forge global entry point."""
+    bootstrap_context(config_path=config, extras={"verbose": verbose})
+    if ctx.invoked_subcommand is not None:
+        return
+
+    console = get_console()
+    console.print()
+    console.print(
+        f"  [bold cyan]Forge[/bold cyan] [dim]v{__version__}[/dim] • "
+        "[bold white]AI Optimization Runtime[/bold white]"
+    )
+    console.print(
+        "  [dim]Prompt + token optimization for AI coding CLIs.[/dim]\n"
+    )
+    console.print(
+        "  [bold]Commands[/bold]\n"
+        "    [cyan]forge claude[/cyan]       Launch Claude Code with optimized context\n"
+        "    [cyan]forge codex[/cyan]        Launch Codex CLI with optimized context\n"
+        "    [cyan]forge cursor[/cyan]       Launch Cursor CLI with optimized context\n"
+        "    [cyan]forge opencode[/cyan]     Launch OpenCode CLI with optimized context\n"
+        "    [cyan]forge commandcode[/cyan]  Launch CommandCode CLI with optimized context\n"
+        "    [cyan]forge graph build[/cyan]  Build a full knowledge graph (optional)\n"
+        "    [cyan]forge --help[/cyan]       Show all options\n"
+    )
+
+
+def _run() -> None:
+    """Run the Typer app and translate ForgeCLIError to clean exit codes."""
+    try:
+        app()
+    except ForgeCLIError as exc:
+        error(str(exc))
+        raise SystemExit(2) from exc
+
+
+if __name__ == "__main__":
+    _run()
+
+
+__all__ = ["app", "main"]

forgecli/cli/ui.py

@@ -0,0 +1,56 @@
+"""Rich-based terminal UI helpers."""
+
+from __future__ import annotations
+
+from rich.console import Console
+from rich.table import Table
+from rich.theme import Theme
+
+_THEME = Theme(
+    {
+        "info": "cyan",
+        "warn": "yellow",
+        "error": "bold red",
+        "success": "bold green",
+        "muted": "dim",
+        "accent": "magenta",
+        "accent.bold": "bold magenta",
+    }
+)
+
+
+def get_console() -> Console:
+    """Return a shared Rich :class:`Console` with the ForgeCLI theme."""
+    return Console(theme=_THEME, soft_wrap=False)
+
+
+def info(message: str) -> None:
+    get_console().print(f"[info]ℹ[/info] {message}")
+
+
+def warn(message: str) -> None:
+    get_console().print(f"[warn]![/warn] {message}")
+
+
+def error(message: str) -> None:
+    get_console().print(f"[error]✗[/error] {message}")
+
+
+def success(message: str) -> None:
+    get_console().print(f"[success]✓[/success] {message}")
+
+
+def warn_deprecated(command: str) -> None:
+    get_console().print(
+        f"[yellow]Deprecated[/yellow] — [bold]{command}[/bold] may be removed in a future release."
+    )
+
+
+def table(headers: list[str], rows: list[list[str]], *, title: str | None = None) -> None:
+    """Print a small :class:`rich.table.Table` to the shared console."""
+    tbl = Table(title=title, header_style="accent.bold")
+    for header in headers:
+        tbl.add_column(header)
+    for row in rows:
+        tbl.add_row(*row)
+    get_console().print(tbl)