forgeoptimizer 0.1.0__py3-none-any.whl

forgecli/cli/main.py

@@ -0,0 +1,234 @@
+"""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)
+app.command(
+    "antigravity",
+    help="Launch Antigravity CLI with Forge prompt + token optimization.",
+    context_settings=commands_wrappers._WRAPPER_SETTINGS,
+)(commands_wrappers.antigravity_cmd)
+
+
+@app.command("start", help="Start the long-running Forge Context Runtime daemon.")
+def start_cmd(
+    port: int = typer.Option(16868, "--port", "-p", help="Port to run the daemon HTTP server on."),
+) -> None:
+    """Start the long-running Forge Context Runtime daemon."""
+    import uvicorn
+
+    from forgecli.cli.daemon import get_watcher_for_path, is_daemon_running
+    from forgecli.cli.ui import info, success
+
+    if is_daemon_running():
+        info("Forge Runtime daemon is already running on http://127.0.0.1:16868")
+        raise typer.Exit(code=0)
+
+    success("Starting Forge Runtime daemon on http://127.0.0.1:16868...")
+    get_watcher_for_path(Path.cwd())
+
+    from forgecli.cli.daemon import app as daemon_app
+
+    uvicorn.run(daemon_app, host="127.0.0.1", port=port, log_level="warning")
+
+
+@app.command("mcp", help="Start the Forge MCP Server over stdio.")
+def mcp_cmd() -> None:
+    """Start the Forge MCP Server over stdio."""
+    from forgecli.cli.daemon import run_mcp_stdio
+
+    run_mcp_stdio()
+
+
+@app.command(
+    "stats",
+    help="Display the prompt and token optimization statistics from the latest wrapper runs.",
+)
+def stats_cmd() -> None:
+    """Display the prompt and token optimization statistics from the latest wrapper runs."""
+    from forgecli.cli.ui import get_console
+    from forgecli.utils.stats import get_stats_history
+
+    history = get_stats_history()
+    if not history:
+        get_console().print("No optimization statistics available yet.")
+        return
+
+    console = get_console()
+    console.print()
+
+    for idx, run in enumerate(history):
+        run_title = "[bold cyan]Forge Optimization Report"
+        if len(history) > 1:
+            run_title += f" (Run #{idx + 1}"
+            if idx == 0:
+                run_title += " - Latest"
+            run_title += ")"
+        run_title += "[/bold cyan]"
+
+        console.print(run_title)
+
+        # Capitalize the CLI used (e.g. claude -> Claude, antigravity -> Antigravity)
+        cli_raw = run.get("cli_used", "N/A")
+        cli_display = cli_raw.capitalize() if isinstance(cli_raw, str) else str(cli_raw)
+
+        console.print(f"Timestamp            : [muted]{run.get('timestamp', 'N/A')}[/muted]")
+        console.print(f"Repository           : [white]{run.get('repo_name', 'N/A')}[/white]")
+        console.print(f"AI CLI               : [white]{cli_display}[/white]")
+        console.print()
+
+        # Tokens section
+        console.print("[bold]Estimated Tokens[/bold]")
+        console.print("[dim]────────────────────────[/dim]")
+
+        red_abs = run.get("reduction_tokens", 0)
+        red_pct = run.get("reduction_pct", 0.0)
+
+        if red_abs <= 0:
+            console.print("[yellow]No meaningful token reduction for this repository.[/yellow]")
+        else:
+            console.print(
+                f"Original             : [white]{run.get('original_tokens', 0):,}[/white]"
+            )
+            console.print(
+                f"Optimized            : [white]{run.get('optimized_tokens', 0):,}[/white]"
+            )
+            console.print(f"Saved                : [green]{red_abs:,}[/green]")
+            console.print(f"Reduction            : [green]{red_pct:.1f}%[/green]")
+        console.print()
+
+        # Optimization section
+        console.print("[bold]Optimization[/bold]")
+        console.print("[dim]────────────────────────[/dim]")
+        console.print(f"Files Scanned        : [white]{run.get('files_scanned', 0)}[/white]")
+        console.print(f"Relevant Files       : [white]{run.get('files_count', 0)}[/white]")
+        console.print(f"Excluded Files       : [white]{run.get('excluded_files', 0)}[/white]")
+        console.print(f"Preparation Time     : [white]{run.get('prep_time', 0.0):.2f} s[/white]")
+        console.print(
+            f"Prompt Optimization  : [white]{run.get('prompt_opt_status', 'N/A')}[/white]"
+        )
+        console.print(f"Token Optimization   : [white]{run.get('token_opt_status', 'N/A')}[/white]")
+
+        if idx < len(history) - 1:
+            console.print()
+            console.print("[dim]==================================================[/dim]")
+            console.print()
+
+
+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 antigravity[/cyan]  Launch Antigravity CLI with optimized context\n"
+        "    [cyan]forge start[/cyan]        Start the background context optimization daemon\n"
+        "    [cyan]forge mcp[/cyan]          Start the stdio Model Context Protocol (MCP) server\n"
+        "    [cyan]forge stats[/cyan]        Display optimization statistics\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)

forgecli/config/__init__.py

@@ -0,0 +1,28 @@
+"""Configuration loading and validation.
+
+Public names are exposed lazily to avoid import cycles with
+:mod:`forgecli.core.context`.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+__all__ = ["ConfigLoader", "ForgeSettings"]
+
+
+if TYPE_CHECKING:  # pragma: no cover - typing only
+    from forgecli.config.loader import ConfigLoader
+    from forgecli.config.settings import ForgeSettings
+
+
+def __getattr__(name: str) -> Any:
+    if name == "ConfigLoader":
+        from forgecli.config.loader import ConfigLoader
+
+        return ConfigLoader
+    if name == "ForgeSettings":
+        from forgecli.config.settings import ForgeSettings
+
+        return ForgeSettings
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

forgecli/config/loader.py

@@ -0,0 +1,85 @@
+"""Load configuration from TOML files and merge with environment variables."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+try:
+    import tomllib  # py3.11+
+except ModuleNotFoundError:  # pragma: no cover - fallback for older runtimes
+    import tomli as tomllib  # type: ignore[no-redef,import-not-found]
+
+from forgecli.config.settings import ForgeSettings
+from forgecli.core.errors import ConfigError
+
+
+class ConfigLoader:
+    """Resolve and load configuration from disk and the environment."""
+
+    DEFAULT_CANDIDATES: tuple[Path, ...] = (
+        Path("./forgecli.toml"),
+        Path("./.forgecli.toml"),
+        Path("./pyproject.toml"),
+    )
+
+    def __init__(self, *user_paths: Path) -> None:
+        self._user_paths: tuple[Path, ...] = user_paths
+        self._cached: ForgeSettings | None = None
+
+    def load(self, *, force: bool = False) -> ForgeSettings:
+        """Load the configuration, caching the result for subsequent calls."""
+        if self._cached is not None and not force:
+            return self._cached
+
+        data: dict[str, Any] = {}
+        for path in self._candidate_paths():
+            if not path.exists():
+                continue
+            data = self._merge(data, self._read_toml(path))
+
+        try:
+            settings = ForgeSettings(**data)
+        except Exception as exc:  # pragma: no cover - delegated validation
+            raise ConfigError(f"Invalid configuration: {exc}") from exc
+
+        self._cached = settings
+        return settings
+
+    def invalidate(self) -> None:
+        """Clear the in-memory cache so the next ``load`` re-reads files."""
+        self._cached = None
+
+    def _candidate_paths(self) -> list[Path]:
+        if self._user_paths:
+            return list(self._user_paths)
+        return list(self.DEFAULT_CANDIDATES)
+
+    @staticmethod
+    def _read_toml(path: Path) -> dict[str, Any]:
+        if path.name == "pyproject.toml":
+            try:
+                payload = tomllib.loads(path.read_text(encoding="utf-8"))
+            except OSError as exc:
+                raise ConfigError(f"Unable to read {path}: {exc}") from exc
+            tool = payload.get("tool", {}).get("forgecli")
+            return dict(tool) if isinstance(tool, dict) else {}
+
+        try:
+            return tomllib.loads(path.read_text(encoding="utf-8"))
+        except OSError as exc:
+            raise ConfigError(f"Unable to read {path}: {exc}") from exc
+        except tomllib.TOMLDecodeError as exc:
+            raise ConfigError(f"Malformed TOML in {path}: {exc}") from exc
+
+    @staticmethod
+    def _merge(base: dict[str, Any], override: dict[str, Any]) -> dict[str, Any]:
+        """Recursively merge two dictionaries, ``override`` winning on conflict."""
+        result: dict[str, Any] = dict(base)
+        for key, value in override.items():
+            existing = result.get(key)
+            if isinstance(existing, dict) and isinstance(value, dict):
+                result[key] = ConfigLoader._merge(existing, value)
+            else:
+                result[key] = value
+        return result

forgecli/config/settings.py

@@ -0,0 +1,206 @@
+"""Pydantic models describing the typed ForgeCLI configuration."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class AppSection(BaseModel):
+    """Top-level application metadata."""
+
+    model_config = ConfigDict(extra="allow")
+
+    name: str = "forgecli"
+    version: str = "0.1.0"
+    log_level: str = "INFO"
+    data_dir: Path = Field(default_factory=lambda: Path("~/.local/share/forgecli"))
+    plugins_dir: Path = Field(default_factory=lambda: Path("~/.config/forgecli/plugins"))
+
+
+class ProviderSection(BaseModel):
+    """Configuration for a single AI provider."""
+
+    model_config = ConfigDict(extra="allow")
+
+    api_key_env: str | None = None
+    base_url: str | None = None
+    base_url_env: str | None = None
+    default_model: str | None = None
+    max_tokens: int = 8192
+    temperature: float = 0.2
+    enabled: bool = True
+
+
+class ProvidersConfig(BaseModel):
+    """Provider registry configuration."""
+
+    model_config = ConfigDict(extra="allow")
+
+    default: str | None = None
+    default_model: str | None = None
+    allowed: list[str] = Field(default_factory=list)
+    providers: dict[str, ProviderSection] = Field(default_factory=dict)
+
+
+class GitSection(BaseModel):
+    """Git automation settings."""
+
+    model_config = ConfigDict(extra="allow")
+
+    default_branch: str = "main"
+    user_name: str = ""
+    user_email: str = ""
+    auto_fetch: bool = True
+
+
+class OptimizerSection(BaseModel):
+    """Context optimizer settings."""
+
+    model_config = ConfigDict(extra="allow")
+
+    max_context_tokens: int = 200_000
+    chunk_size: int = 4000
+    chunk_overlap: int = 200
+    strategy: str = "auto"  # auto | sliding | map-reduce | graph
+
+
+class PromptOptimizerSection(BaseModel):
+    """Ponytail prompt-optimizer settings."""
+
+    model_config = ConfigDict(extra="allow")
+
+    enabled: bool = True
+    intensity: str = "lite"  # off | lite | full | ultra
+    backend: str = "ruleset"  # ruleset | cli | auto
+    binary: str = "ponytail"  # only used when backend = "cli"
+    timeout_seconds: float = 30.0
+
+
+class CavemanSection(BaseModel):
+    """Caveman token-optimizer settings."""
+
+    model_config = ConfigDict(extra="allow")
+
+    enabled: bool = False
+    intensity: str = "off"  # off | lite | full | ultra | wenyan
+    backend: str = "ruleset"  # ruleset | cli | auto
+    binary: str = "caveman"  # only used when backend = "cli"
+    timeout_seconds: float = 30.0
+
+
+class GraphSection(BaseModel):
+    """Repository graph settings."""
+
+    model_config = ConfigDict(extra="allow")
+
+    enabled: bool = True
+    languages: list[str] = Field(default_factory=lambda: ["python", "typescript"])
+    max_depth: int = 8
+    ignore_patterns: list[str] = Field(default_factory=list)
+
+
+class MemorySection(BaseModel):
+    """Local memory store settings."""
+
+    model_config = ConfigDict(extra="allow")
+
+    db_path: Path = Field(default_factory=lambda: Path("~/.local/share/forgecli/history.db"))
+    history_limit: int = 1000
+    embedding_provider: str = "mock"
+
+
+class ReviewSection(BaseModel):
+    """Code review settings."""
+
+    model_config = ConfigDict(extra="allow")
+
+    enabled: bool = True
+    auto_review: bool = False
+    max_diff_lines: int = 2000
+    lint_first: bool = True
+
+
+class BuilderSection(BaseModel):
+    """Builder/pipeline settings."""
+
+    model_config = ConfigDict(extra="allow")
+
+    auto_format: bool = True
+    formatter: str = "auto"
+    test_command: str = ""
+    max_iterations: int = 3
+
+
+class PlannerSection(BaseModel):
+    """Planner/agent settings."""
+
+    model_config = ConfigDict(extra="allow")
+
+    default_strategy: str = "react"
+    max_steps: int = 20
+    allow_shell: bool = False
+
+
+class PromptsSection(BaseModel):
+    """Prompt template settings."""
+
+    model_config = ConfigDict(extra="allow")
+
+    dir: Path = Field(default_factory=lambda: Path("~/.config/forgecli/prompts"))
+    render_backend: str = "jinja"
+
+
+class TelemetrySection(BaseModel):
+    """Telemetry and analytics settings."""
+
+    model_config = ConfigDict(extra="allow")
+
+    enabled: bool = False
+    endpoint: str = ""
+
+
+class ForgeSettings(BaseSettings):
+    """Root settings model combining file config and environment variables."""
+
+    model_config = SettingsConfigDict(
+        env_prefix="FORGECLI_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        env_nested_delimiter="__",
+        extra="ignore",
+        case_sensitive=False,
+    )
+
+    app: AppSection = Field(default_factory=AppSection)
+    providers: ProvidersConfig = Field(default_factory=ProvidersConfig)
+    git: GitSection = Field(default_factory=GitSection)
+    optimizer: OptimizerSection = Field(default_factory=OptimizerSection)
+    prompt_optimizer: PromptOptimizerSection = Field(default_factory=PromptOptimizerSection)
+    caveman: CavemanSection = Field(default_factory=CavemanSection)
+    graph: GraphSection = Field(default_factory=GraphSection)
+    memory: MemorySection = Field(default_factory=MemorySection)
+    review: ReviewSection = Field(default_factory=ReviewSection)
+    builder: BuilderSection = Field(default_factory=BuilderSection)
+    planner: PlannerSection = Field(default_factory=PlannerSection)
+    prompts: PromptsSection = Field(default_factory=PromptsSection)
+    telemetry: TelemetrySection = Field(default_factory=TelemetrySection)
+    extra: dict[str, Any] = Field(default_factory=dict)
+
+    @field_validator(
+        "app",
+        "providers",
+        "git",
+        "optimizer",
+        "prompt_optimizer",
+        "caveman",
+        "graph",
+        mode="before",
+    )
+    @classmethod
+    def _coerce_none(cls, value: Any) -> Any:
+        """Allow empty sections to be passed as ``None``."""
+        return value or {}