forgeoptimizer 0.1.0__py3-none-any.whl

forgecli/runtime/mcp_config.py

@@ -0,0 +1,118 @@
+"""Automated configuration and detection of Forge MCP server for AI CLIs."""
+
+from __future__ import annotations
+
+import contextlib
+import json
+from pathlib import Path
+
+from forgecli.cli.ui import info, success
+
+
+def configure_mcp_for_all(repo_root: Path) -> None:
+    """Detect and automatically configure Forge MCP server for Claude, Cursor, and local project."""
+    configure_claude_mcp()
+    configure_cursor_mcp(repo_root)
+    configure_project_local_mcp(repo_root)
+
+
+def configure_claude_mcp() -> None:
+    """Ensure ~/.claude.json is configured with the forge MCP server."""
+    claude_config_path = Path.home() / ".claude.json"
+    forge_mcp_entry = {"command": "forge", "args": ["mcp"]}
+
+    try:
+        data: dict = {}
+        if claude_config_path.exists():
+            content = claude_config_path.read_text(encoding="utf-8").strip()
+            if content:
+                try:
+                    data = json.loads(content)
+                except json.JSONDecodeError:
+                    info("Could not parse ~/.claude.json as valid JSON. Skipping auto-config.")
+                    return
+
+        if "mcpServers" not in data or not isinstance(data["mcpServers"], dict):
+            data["mcpServers"] = {}
+
+        if "forge" not in data["mcpServers"]:
+            data["mcpServers"]["forge"] = forge_mcp_entry
+            claude_config_path.write_text(json.dumps(data, indent=2), encoding="utf-8")
+            success("✨ Configured Forge MCP server in ~/.claude.json for Claude Code.")
+    except Exception as e:
+        info(f"Note: Could not auto-configure Claude Code MCP: {e}")
+        info("You can manually configure Claude Code using: claude mcp add forge -- forge mcp")
+
+
+def configure_cursor_mcp(repo_root: Path) -> None:
+    """Ensure Cursor is configured with the forge MCP server globally and project-locally."""
+    # 1. Global ~/.cursor/mcp.json
+    cursor_global_path = Path.home() / ".cursor" / "mcp.json"
+    forge_mcp_entry = {"command": "forge", "args": ["mcp"]}
+
+    try:
+        cursor_global_path.parent.mkdir(parents=True, exist_ok=True)
+        data: dict = {}
+        if cursor_global_path.exists():
+            content = cursor_global_path.read_text(encoding="utf-8").strip()
+            if content:
+                with contextlib.suppress(json.JSONDecodeError):
+                    data = json.loads(content)
+
+        if "mcpServers" not in data or not isinstance(data["mcpServers"], dict):
+            data["mcpServers"] = {}
+
+        if "forge" not in data["mcpServers"]:
+            data["mcpServers"]["forge"] = forge_mcp_entry
+            cursor_global_path.write_text(json.dumps(data, indent=2), encoding="utf-8")
+            success("✨ Configured Forge MCP server in ~/.cursor/mcp.json for Cursor.")
+    except Exception as e:
+        info(f"Note: Could not auto-configure Cursor global MCP: {e}")
+
+    # 2. Project-local .cursor/mcp.json
+    cursor_local_dir = repo_root / ".cursor"
+    cursor_local_path = cursor_local_dir / "mcp.json"
+    try:
+        cursor_local_dir.mkdir(parents=True, exist_ok=True)
+        data = {}
+        if cursor_local_path.exists():
+            content = cursor_local_path.read_text(encoding="utf-8").strip()
+            if content:
+                with contextlib.suppress(json.JSONDecodeError):
+                    data = json.loads(content)
+
+        if "mcpServers" not in data or not isinstance(data["mcpServers"], dict):
+            data["mcpServers"] = {}
+
+        if "forge" not in data["mcpServers"]:
+            data["mcpServers"]["forge"] = forge_mcp_entry
+            cursor_local_path.write_text(json.dumps(data, indent=2), encoding="utf-8")
+            success(
+                f"✨ Configured Forge MCP server in {repo_root.name}/.cursor/mcp.json for Cursor."
+            )
+    except Exception as e:
+        info(f"Note: Could not auto-configure Cursor local MCP: {e}")
+
+
+def configure_project_local_mcp(repo_root: Path) -> None:
+    """Create a project-local .mcp.json file for tools that support auto-discovery."""
+    mcp_local_path = repo_root / ".mcp.json"
+    forge_mcp_entry = {"command": "forge", "args": ["mcp"]}
+
+    try:
+        data: dict = {}
+        if mcp_local_path.exists():
+            content = mcp_local_path.read_text(encoding="utf-8").strip()
+            if content:
+                with contextlib.suppress(json.JSONDecodeError):
+                    data = json.loads(content)
+
+        if "mcpServers" not in data or not isinstance(data["mcpServers"], dict):
+            data["mcpServers"] = {}
+
+        if "forge" not in data["mcpServers"]:
+            data["mcpServers"]["forge"] = forge_mcp_entry
+            mcp_local_path.write_text(json.dumps(data, indent=2), encoding="utf-8")
+            success("✨ Created project-local .mcp.json for auto-discovery of Forge MCP server.")
+    except Exception as e:
+        info(f"Note: Could not write project-local .mcp.json: {e}")

forgecli/runtime/prepare.py

@@ -0,0 +1,203 @@
+"""Fast repository context for AI wrapper commands — no full codebase indexing."""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from forgecli.optimizer.optimizer import ContextOptimizer
+from forgecli.optimizer.ponytail import Intensity, PonytailRulesetOptimizer
+from forgecli.providers.base import ChatMessage, ChatRequest, Role
+from forgecli.runtime.cache_store import (
+    CachedRuntime,
+    load_runtime_cache,
+    repo_fingerprint,
+    save_runtime_cache,
+)
+from forgecli.utils.paths import ProjectPaths
+
+_SKIP_DIRS = {
+    ".git",
+    ".venv",
+    "__pycache__",
+    "node_modules",
+    "dist",
+    "build",
+    ".forge",
+    "graphify-out",
+    ".mypy_cache",
+    ".pytest_cache",
+    ".ruff_cache",
+}
+
+
+@dataclass(frozen=True)
+class PreparedRuntime:
+    """Optimized repository context ready for a wrapper CLI."""
+
+    root: Path
+    context_summary: str
+    context_file: Path
+    from_cache: bool
+
+    @classmethod
+    def from_cached(cls, root: Path, cached: CachedRuntime) -> PreparedRuntime:
+        return cls(
+            root=root,
+            context_summary=cached.context_summary,
+            context_file=Path(cached.context_file),
+            from_cache=True,
+        )
+
+
+def resolve_repo_root(start: Path) -> Path:
+    """Return the nearest git repository root, or ``start`` when not in a repo."""
+    start = start.resolve()
+    for candidate in (start, *start.parents):
+        if (candidate / ".git").exists():
+            return candidate
+    return start
+
+
+def _git_line(root: Path) -> str | None:
+    from forgecli.platform.shell import run
+
+    branch = run(["git", "rev-parse", "--abbrev-ref", "HEAD"], cwd=root)
+    if branch.ok and branch.stdout.strip():
+        return f"Branch: {branch.stdout.strip()}"
+    return None
+
+
+def _scan_repo_light(root: Path) -> str:
+    """Build a small repo snapshot without indexing the full codebase."""
+    lines = [
+        f"Repository: {root.name}",
+        f"Root: {root}",
+    ]
+    git_info = _git_line(root)
+    if git_info:
+        lines.append(git_info)
+
+    layout: list[str] = []
+    try:
+        for entry in sorted(root.iterdir(), key=lambda p: p.name.lower())[:36]:
+            if entry.name in _SKIP_DIRS or entry.name.startswith("."):
+                continue
+            if entry.is_dir():
+                layout.append(f"{entry.name}/")
+                try:
+                    for child in sorted(entry.iterdir(), key=lambda p: p.name.lower())[:6]:
+                        if child.name in _SKIP_DIRS or child.name.startswith("."):
+                            continue
+                        suffix = "/" if child.is_dir() else ""
+                        layout.append(f"  {child.name}{suffix}")
+                except OSError:
+                    pass
+            else:
+                layout.append(entry.name)
+    except OSError:
+        pass
+
+    if layout:
+        lines.extend(["", "Project layout (shallow scan):", *layout[:72]])
+
+    graph_marker = root / "graphify-out" / "graph.json"
+    if graph_marker.is_file():
+        lines.append("")
+        lines.append(
+            "Knowledge graph already on disk at graphify-out/. "
+            "Run `forge graph build` separately when you want a full refresh."
+        )
+
+    return "\n".join(lines)
+
+
+def _optimize_prompt(context: str) -> str:
+    import asyncio
+
+    optimizer = PonytailRulesetOptimizer(intensity=Intensity.LITE)
+    request = ChatRequest(
+        model="runtime",
+        messages=[
+            ChatMessage(
+                role=Role.SYSTEM,
+                content="Prepare concise repository context for an AI coding assistant.",
+            ),
+            ChatMessage(
+                role=Role.USER,
+                content=(
+                    "Optimize this repo snapshot for the next coding task. "
+                    "Prefer reuse, minimal diffs, and existing patterns.\n\n"
+                    f"{context}"
+                ),
+            ),
+        ],
+    )
+    optimized = asyncio.run(optimizer.optimize_chat(request))
+    user = next(
+        (message.content for message in optimized.request.messages if message.role is Role.USER),
+        context,
+    )
+    return user.strip() or context
+
+
+def _optimize_tokens(text: str) -> str:
+    optimizer = ContextOptimizer(max_context_tokens=8_000)
+    result = optimizer.optimize(text)
+    if not result.chunks:
+        return text[:12_000]
+    merged = "\n".join(chunk.text for chunk in result.chunks[:24])
+    return merged[:12_000]
+
+
+def prepare_runtime_sync(
+    start: Path,
+    *,
+    force: bool = False,
+    quiet: bool = False,
+) -> PreparedRuntime:
+    """Prepare lightweight optimized context — no full graph build."""
+    root = resolve_repo_root(start)
+    fingerprint = repo_fingerprint(root)
+
+    if not force:
+        cached = load_runtime_cache(fingerprint)
+        if cached is not None:
+            return PreparedRuntime.from_cached(root, cached)
+
+    raw_context = _scan_repo_light(root)
+    prompt_optimized = _optimize_prompt(raw_context)
+    token_optimized = _optimize_tokens(prompt_optimized)
+
+    # Optimization pipeline check: never allow optimized context to be larger than raw context
+    if len(token_optimized) > len(raw_context):
+        token_optimized = raw_context
+
+    cache_dir = ProjectPaths.from_env().cache_dir / "runtime" / "context"
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    context_file = cache_dir / f"{fingerprint}.md"
+    context_file.write_text(token_optimized, encoding="utf-8")
+
+    save_runtime_cache(
+        fingerprint,
+        CachedRuntime(
+            context_summary=token_optimized,
+            context_file=str(context_file),
+            node_count=0,
+            edge_count=0,
+            created_at=time.time(),
+        ),
+    )
+
+    if not quiet:
+        from forgecli.cli.ui import info
+
+        info(f"Optimized context for [accent]{root.name}[/accent] (cached for reuse)")
+
+    return PreparedRuntime(
+        root=root,
+        context_summary=token_optimized,
+        context_file=context_file,
+        from_cache=False,
+    )

forgecli/runtime/wrappers.py

@@ -0,0 +1,150 @@
+"""Launch Claude Code, Codex, Cursor, OpenCode, and CommandCode CLI with Forge-optimized context."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+import typer
+
+from forgecli.cli.ui import error, get_console, info
+from forgecli.platform.shell import which
+from forgecli.runtime.prepare import prepare_runtime_sync, resolve_repo_root
+
+
+@dataclass(frozen=True)
+class WrapperSpec:
+    name: str
+    binary: str
+    install_hint: str
+
+
+WRAPPERS: dict[str, WrapperSpec] = {
+    "claude": WrapperSpec(
+        name="Claude Code",
+        binary="claude",
+        install_hint="Install Claude Code: https://docs.anthropic.com/en/docs/claude-code",
+    ),
+    "codex": WrapperSpec(
+        name="Codex CLI",
+        binary="codex",
+        install_hint="Install OpenAI Codex CLI: https://developers.openai.com/codex/cli/",
+    ),
+    "cursor": WrapperSpec(
+        name="Cursor CLI",
+        binary="cursor",
+        install_hint="Install Cursor CLI: https://cursor.com/docs/cli/overview",
+    ),
+    "opencode": WrapperSpec(
+        name="OpenCode CLI",
+        binary="opencode",
+        install_hint="Install OpenCode CLI: https://opencode.ai/",
+    ),
+    "commandcode": WrapperSpec(
+        name="CommandCode CLI",
+        binary="commandcode",
+        install_hint="Install CommandCode CLI: https://commandcode.ai/",
+    ),
+    "antigravity": WrapperSpec(
+        name="Antigravity CLI",
+        binary="antigravity",
+        install_hint="Install Antigravity CLI",
+    ),
+}
+
+
+def launch_wrapper(
+    wrapper_id: str,
+    extra_args: list[str] | None = None,
+    *,
+    path: Path | None = None,
+    force_prepare: bool = False,
+) -> None:
+    """Prepare lightweight context and launch the selected AI CLI."""
+    spec = WRAPPERS.get(wrapper_id)
+    if spec is None:
+        error(f"Unknown wrapper: {wrapper_id}")
+        raise typer.Exit(code=1)
+
+    if extra_args:
+        error(
+            "Passing prompts or extra arguments to wrapper commands is not supported. Please run the command without arguments to launch the interactive CLI."
+        )
+        raise typer.Exit(code=1)
+
+    binary_path = which(spec.binary)
+    if binary_path is None and wrapper_id == "commandcode":
+        # Check alternative binary names for commandcode
+        binary_path = which("command-code")
+
+    if binary_path is None:
+        console = get_console()
+        console.print(f"[red]✗[/red] {spec.name} is not installed.")
+        console.print(spec.install_hint)
+        raise typer.Exit(code=1)
+
+    # 1. Detect current repository
+    cwd = (path or Path.cwd()).resolve()
+    repo_root = resolve_repo_root(cwd)
+
+    # 2. Ensure the daemon is running
+    import time
+
+    import httpx
+
+    from forgecli.cli.daemon import is_daemon_running, start_daemon_background
+
+    if not is_daemon_running():
+        info("Forge Runtime daemon is not running. Starting it in the background...")
+        start_daemon_background()
+        # Wait a moment for it to spin up
+        for _ in range(20):
+            if is_daemon_running():
+                break
+            time.sleep(0.2)
+
+    # 3. Optimize context, prompts, and tokens (aggressively reusing cache)
+    import time
+
+    from forgecli.utils.stats import record_wrapper_stats
+
+    start_time = time.perf_counter()
+    prepared = prepare_runtime_sync(repo_root, force=force_prepare, quiet=False)
+    prep_time = time.perf_counter() - start_time
+
+    record_wrapper_stats(wrapper_id, repo_root, prepared, prep_time)
+
+    if prepared.from_cache:
+        info("Reusing cached Forge context.")
+
+    # 4. Notify daemon to refresh/ensure context is registered
+    try:
+        with httpx.Client(timeout=2.0) as client:
+            client.get(f"http://127.0.0.1:16868/context?path={repo_root}")
+    except Exception:
+        pass
+
+    # 5. Automatically configure MCP server for launched CLIs
+    try:
+        from forgecli.runtime.mcp_config import configure_mcp_for_all
+
+        configure_mcp_for_all(repo_root)
+    except Exception:
+        pass
+
+    env = os.environ.copy()
+    env["FORGE_CONTEXT"] = prepared.context_summary
+    env["FORGE_CONTEXT_FILE"] = str(prepared.context_file)
+    env["FORGE_REPO_ROOT"] = str(prepared.root)
+
+    argv = [binary_path, *(extra_args or [])]
+    info(f"Launching [accent]{spec.name}[/accent] ...")
+
+    completed = subprocess.run(
+        argv,
+        cwd=str(prepared.root),
+        env=env,
+    )
+    raise typer.Exit(code=completed.returncode)

forgecli/sdk/__init__.py

@@ -0,0 +1,132 @@
+"""The ForgeCLI Plugin SDK.
+
+The SDK is the *contract* third-party developers use to extend
+ForgeCLI. It provides:
+
+* :mod:`forgecli.sdk.manifest`  — typed plugin metadata (TOML).
+* :mod:`forgecli.sdk.version`    — semver parsing + dep resolution.
+* :mod:`forgecli.sdk.loader`     — discovery (filesystem + entry-point).
+* :mod:`forgecli.sdk.events`     — pub/sub bus + hook manager.
+* :mod:`forgecli.sdk.sandbox`    — restricted-exec for plugin callbacks.
+* :mod:`forgecli.sdk.interfaces` — the 10 canonical plugin types.
+* :mod:`forgecli.sdk.manager`    — the :class:`PluginManager` façade
+  (install / enable / disable / uninstall / update / configure).
+
+See :file:`PLUGINS.md` for the end-to-end developer guide.
+"""
+
+from forgecli.sdk.events import (
+    HookManager,
+    PluginEvent,
+    PluginEventBus,
+    PluginEventKind,
+    PluginHook,
+)
+from forgecli.sdk.interfaces import (
+    AIProviderPlugin,
+    CodeGeneratorPlugin,
+    ContextOptimizerPlugin,
+    DeploymentProviderPlugin,
+    DocumentationGeneratorPlugin,
+    GitProviderPlugin,
+    HealthIssue,
+    HealthReport,
+    NotificationProviderPlugin,
+    ObservabilityProviderPlugin,
+    PluginConfigurable,
+    PluginHealthCheck,
+    RepositoryAnalyzerPlugin,
+    TestRunnerPlugin,
+)
+from forgecli.sdk.loader import (
+    LoadedPlugin,
+    default_plugins_dir,
+    discover_entry_points,
+    discover_filesystem,
+    load_filesystem,
+)
+from forgecli.sdk.loader import (
+    PluginManifestNotFoundError as PluginManifestNotFound,
+)
+from forgecli.sdk.manager import (
+    PluginAlreadyInstalledError,
+    PluginCompatibilityError,
+    PluginError,
+    PluginManager,
+    PluginNotFoundError,
+    PluginRegistryState,
+    PluginState,
+)
+from forgecli.sdk.manifest import (
+    Compatibility,
+    EntryPoint,
+    EntryPointKind,
+    Permission,
+    PluginManifest,
+    is_valid_plugin_name,
+)
+from forgecli.sdk.sandbox import Sandbox, ScopedBuiltins, run_sandboxed, sandbox
+from forgecli.sdk.version import (
+    DependencyCycleError,
+    Op,
+    Requirement,
+    Spec,
+    UnsatisfiableRequirementError,
+    Version,
+    VersionParseError,
+    resolve,
+)
+
+__all__ = [
+    "AIProviderPlugin",
+    "CodeGeneratorPlugin",
+    "Compatibility",
+    "ContextOptimizerPlugin",
+    "DependencyCycleError",
+    "DeploymentProviderPlugin",
+    "DocumentationGeneratorPlugin",
+    "EntryPoint",
+    "EntryPointKind",
+    "GitProviderPlugin",
+    "HealthIssue",
+    "HealthReport",
+    "HookManager",
+    "LoadedPlugin",
+    "NotificationProviderPlugin",
+    "ObservabilityProviderPlugin",
+    "Op",
+    "Permission",
+    "PluginAlreadyInstalledError",
+    "PluginCompatibilityError",
+    "PluginConfigurable",
+    "PluginError",
+    "PluginEvent",
+    "PluginEventBus",
+    "PluginEventKind",
+    "PluginHealthCheck",
+    "PluginHook",
+    "PluginManager",
+    "PluginManifest",
+    "PluginManifestNotFound",
+    "PluginManifestNotFoundError",
+    "PluginNotFoundError",
+    "PluginRegistryState",
+    "PluginState",
+    "RepositoryAnalyzerPlugin",
+    "Requirement",
+    "Sandbox",
+    "ScopedBuiltins",
+    "Spec",
+    "TestRunnerPlugin",
+    "UnsatisfiableRequirementError",
+    "Version",
+    "VersionParseError",
+    "default_plugins_dir",
+    "discover_entry_points",
+    "discover_filesystem",
+    "is_valid_plugin_name",
+    "load_filesystem",
+    "resolve",
+    "run_sandboxed",
+    "sandbox",
+]