forgeoptimizer 1.0.0__py3-none-any.whl

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,204 @@
+"""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)
+    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",
+        "graph",
+        mode="before",
+    )
+    @classmethod
+    def _coerce_none(cls, value: Any) -> Any:
+        """Allow empty sections to be passed as ``None``."""
+        return value or {}

forgecli/config/writer.py

@@ -0,0 +1,90 @@
+"""TOML writer helper to update ForgeCLI config settings on the fly."""
+
+from __future__ import annotations
+
+import contextlib
+from pathlib import Path
+from typing import Any
+
+try:
+    import tomllib  # py3.11+
+except ModuleNotFoundError:  # pragma: no cover
+    import tomli as tomllib  # type: ignore[no-redef,import-not-found]
+
+
+def dump_toml(data: dict[str, Any]) -> str:
+    """Serialize a dictionary to a basic TOML string (handles flat tables and primitive values)."""
+    lines = []
+    # Write top-level key-values first
+    for k, v in sorted(data.items()):
+        if not isinstance(v, dict):
+            if isinstance(v, bool):
+                lines.append(f"{k} = {str(v).lower()}")
+            elif isinstance(v, (int, float)):
+                lines.append(f"{k} = {v}")
+            elif isinstance(v, str):
+                lines.append(f'{k} = "{v}"')
+            elif isinstance(v, list):
+                items = ", ".join(f'"{x}"' if isinstance(x, str) else str(x) for x in v)
+                lines.append(f"{k} = [{items}]")
+
+    # Write tables
+    for section_name, section_val in sorted(data.items()):
+        if isinstance(section_val, dict):
+            lines.append(f"\n[{section_name}]")
+            for k, v in sorted(section_val.items()):
+                if isinstance(v, bool):
+                    lines.append(f"{k} = {str(v).lower()}")
+                elif isinstance(v, (int, float)):
+                    lines.append(f"{k} = {v}")
+                elif isinstance(v, str):
+                    lines.append(f'{k} = "{v}"')
+                elif isinstance(v, list):
+                    items = ", ".join(f'"{x}"' if isinstance(x, str) else str(x) for x in v)
+                    lines.append(f"{k} = [{items}]")
+
+    return "\n".join(lines).strip() + "\n"
+
+
+def update_config(
+    default_provider: str | None = None,
+    default_model: str | None = None,
+    clear_provider: bool = False,
+    clear_model: bool = False,
+) -> Path:
+    """Update defaults in the active forgecli.toml configuration file."""
+    from forgecli.config.loader import ConfigLoader
+
+    loader = ConfigLoader()
+    # Find existing writeable candidate config file
+    candidates = loader._candidate_paths()
+    target_path = None
+    for p in candidates:
+        if p.exists() and p.name != "pyproject.toml":
+            target_path = p
+            break
+
+    if not target_path:
+        target_path = Path("./forgecli.toml")
+
+    data: dict[str, Any] = {}
+    if target_path.exists():
+        with contextlib.suppress(Exception):
+            data = tomllib.loads(target_path.read_text(encoding="utf-8"))
+
+    if "providers" not in data:
+        data["providers"] = {}
+
+    if clear_provider:
+        data["providers"].pop("default", None)
+    elif default_provider is not None:
+        data["providers"]["default"] = default_provider
+
+    if clear_model:
+        data["providers"].pop("default_model", None)
+    elif default_model is not None:
+        data["providers"]["default_model"] = default_model
+
+    content = dump_toml(data)
+    target_path.write_text(content, encoding="utf-8")
+    return target_path

forgecli/core/__init__.py

@@ -0,0 +1,35 @@
+"""Core orchestration primitives: app context, DI container, events."""
+
+from forgecli.core.container import Container
+from forgecli.core.context import AppContext
+from forgecli.core.errors import (
+    ConfigError,
+    ForgeCLIError,
+    GitError,
+    PipelineError,
+    PluginError,
+    ProviderError,
+)
+from forgecli.core.events import Event, EventBus
+from forgecli.core.logging import configure_logging, get_logger
+from forgecli.core.plugins import Plugin, discover_plugins, install_plugins
+from forgecli.core.service import Service
+
+__all__ = [
+    "AppContext",
+    "ConfigError",
+    "Container",
+    "Event",
+    "EventBus",
+    "ForgeCLIError",
+    "GitError",
+    "PipelineError",
+    "Plugin",
+    "PluginError",
+    "ProviderError",
+    "Service",
+    "configure_logging",
+    "discover_plugins",
+    "get_logger",
+    "install_plugins",
+]

forgecli/core/container.py

@@ -0,0 +1,68 @@
+"""Lightweight dependency-injection container."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any, TypeVar
+
+T = TypeVar("T")
+
+
+class Container:
+    """A minimal service container with factory and singleton registrations.
+
+    The container intentionally avoids any global state; an instance is
+    owned by :class:`forgecli.core.context.AppContext` and created per process.
+    """
+
+    def __init__(self) -> None:
+        self._factories: dict[type, Callable[[Container], Any]] = {}
+        self._singletons: dict[type, Any] = {}
+        self._singleton_flags: dict[type, bool] = {}
+
+    def register(
+        self,
+        interface: type[T],
+        factory: Callable[[Container], T],
+        *,
+        singleton: bool = True,
+    ) -> None:
+        """Register a factory for ``interface``.
+
+        When ``singleton`` is True, the first call to :meth:`resolve` will
+        cache the result and return it for all subsequent calls.
+        """
+        self._factories[interface] = factory
+        self._singleton_flags[interface] = singleton
+        if not singleton:
+            self._singletons.pop(interface, None)
+
+    def register_instance(self, interface: type[T], instance: T) -> None:
+        """Bind a pre-constructed instance to ``interface``."""
+        self._factories[interface] = lambda _c: instance
+        self._singletons[interface] = instance
+        self._singleton_flags[interface] = True
+
+    def resolve(self, interface: type[T]) -> T:
+        """Resolve an instance for ``interface``."""
+        if interface in self._singletons:
+            return self._singletons[interface]  # type: ignore[return-value]
+        if interface not in self._factories:
+            raise KeyError(f"No registration for {interface!r}")
+        instance = self._factories[interface](self)
+        if self._is_singleton(interface):
+            self._singletons[interface] = instance
+        return instance  # type: ignore[return-value]
+
+    def _is_singleton(self, interface: type) -> bool:
+        """Return True if ``interface`` was registered as a singleton."""
+        return self._singleton_flags.get(interface, True)
+
+    def has(self, interface: type) -> bool:
+        return interface in self._factories or interface in self._singletons
+
+    def clear(self) -> None:
+        """Drop all registrations and cached singletons."""
+        self._factories.clear()
+        self._singletons.clear()
+        self._singleton_flags.clear()

forgecli/core/context.py

@@ -0,0 +1,54 @@
+"""Application context: shared state object passed across the CLI."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from forgecli.core.container import Container
+from forgecli.core.events import EventBus
+from forgecli.utils.paths import ProjectPaths
+
+if TYPE_CHECKING:  # pragma: no cover - typing only
+    from forgecli.config.loader import ConfigLoader
+    from forgecli.config.settings import ForgeSettings
+
+
+@dataclass
+class AppContext:
+    """Shared, mutable context for one CLI invocation.
+
+    The context is created in :mod:`forgecli.cli.main` and explicitly
+    passed to services that need it. It owns the configuration loader,
+    the DI container, the event bus, and resolved filesystem paths.
+    """
+
+    paths: ProjectPaths
+    loader: ConfigLoader
+    settings: ForgeSettings | None = None
+    container: Container = field(default_factory=Container)
+    event_bus: EventBus = field(default_factory=EventBus)
+    extras: dict[str, Any] = field(default_factory=dict)
+
+    def resolve_settings(self, *, force: bool = False) -> ForgeSettings:
+        """Load (or return cached) settings."""
+        if self.settings is None or force:
+            self.settings = self.loader.load(force=force)
+        return self.settings
+
+    def with_overrides(self, **values: Any) -> AppContext:
+        """Return a shallow copy with extra values merged into ``extras``."""
+        new = AppContext(
+            paths=self.paths,
+            loader=self.loader,
+            settings=self.settings,
+            container=self.container,
+            event_bus=self.event_bus,
+            extras={**self.extras, **values},
+        )
+        return new
+
+    @property
+    def cwd(self) -> Path:
+        return self.paths.cwd

forgecli/core/credentials.py

@@ -0,0 +1,114 @@
+"""Secure storage for API keys with OS keychain (keyring) and encrypted fallback."""
+
+from __future__ import annotations
+
+import base64
+import contextlib
+import getpass
+import hashlib
+import json
+import sys
+import uuid
+from pathlib import Path
+
+import keyring
+from cryptography.fernet import Fernet
+
+from forgecli.utils.paths import ProjectPaths
+
+KEYRING_SERVICE = "forgectx"
+
+
+def _get_credentials_file() -> Path:
+    paths = ProjectPaths.from_env()
+    paths.config_dir.mkdir(parents=True, exist_ok=True)
+    return paths.config_dir / "credentials.json"
+
+
+def _get_encryption_key() -> bytes:
+    try:
+        host_info = f"{uuid.getnode()}:{getpass.getuser()}:{sys.platform}"
+    except Exception:
+        host_info = "fallback-forgectx-key-salt"
+    key_hash = hashlib.sha256(host_info.encode("utf-8")).digest()
+    return base64.urlsafe_b64encode(key_hash)
+
+
+def _read_encrypted_file() -> dict[str, str]:
+    path = _get_credentials_file()
+    if not path.exists():
+        return {}
+    try:
+        raw_data = path.read_bytes()
+        fernet = Fernet(_get_encryption_key())
+        decrypted = fernet.decrypt(raw_data)
+        return json.loads(decrypted.decode("utf-8"))
+    except Exception:
+        return {}
+
+
+def _write_encrypted_file(data: dict[str, str]) -> None:
+    path = _get_credentials_file()
+    fernet = Fernet(_get_encryption_key())
+    encrypted = fernet.encrypt(json.dumps(data).encode("utf-8"))
+    path.write_bytes(encrypted)
+    with contextlib.suppress(OSError):
+        path.chmod(0o600)
+
+
+def get_api_key(provider: str) -> str | None:
+    """Retrieve the API key for a provider."""
+    provider = provider.lower().strip()
+    try:
+        val = keyring.get_password(KEYRING_SERVICE, provider)
+        if val is not None:
+            return val
+    except Exception:
+        pass
+    data = _read_encrypted_file()
+    return data.get(provider)
+
+
+def set_api_key(provider: str, api_key: str) -> None:
+    """Store an API key in the OS keychain, falling back to encrypted disk storage."""
+    provider = provider.lower().strip()
+    api_key = api_key.strip()
+    if not provider or not api_key:
+        raise ValueError("provider and api_key are required")
+    try:
+        keyring.set_password(KEYRING_SERVICE, provider, api_key)
+        return
+    except Exception:
+        data = _read_encrypted_file()
+        data[provider] = api_key
+        _write_encrypted_file(data)
+
+
+def delete_api_key(provider: str) -> None:
+    """Remove a stored API key."""
+    provider = provider.lower().strip()
+    with contextlib.suppress(Exception):
+        keyring.delete_password(KEYRING_SERVICE, provider)
+    data = _read_encrypted_file()
+    if provider in data:
+        del data[provider]
+        _write_encrypted_file(data)
+
+
+def list_stored_providers() -> list[str]:
+    """Return provider names with stored credentials."""
+    providers = set(_read_encrypted_file())
+    for name in (
+        "openai",
+        "anthropic",
+        "google",
+        "openrouter",
+        "groq",
+        "together",
+    ):
+        try:
+            if keyring.get_password(KEYRING_SERVICE, name):
+                providers.add(name)
+        except Exception:
+            continue
+    return sorted(providers)