symphony-code 0.0.1__py3-none-any.whl

coding_agent/config/config.py

@@ -0,0 +1,376 @@
+"""Product configuration loaded from a spawn-time settings file."""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any, Final, Literal, Union
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+from core_harness.config import HarnessConfig
+from coding_agent.addons.plugins.models import PluginConfig
+from coding_agent.config.prompts import SUBAGENT_SYSTEM_PROMPT
+
+SPAWN_SETTINGS_NAME = "config.json"
+SettingsSource = Union["CodingAgentConfig", str, Path]
+
+
+class ApprovalConfig(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    mode: Literal["ask", "always_allow"] = "ask"
+    allow_answers: set[str] = Field(
+        default_factory=lambda: {"y", "yes", "allow", "allow once", "a"}
+    )
+    broad_patch_chars: int = Field(default=400, ge=1)
+    require_for_bash: bool = True
+    require_for_overwrite: bool = True
+    require_for_broad_patch: bool = True
+    require_for_web_search: bool = True
+    # fnmatch patterns on the bash command, on the path for write_file /
+    # patch / generate_image, or on ``web_search:<query>`` for a web search.
+    # deny wins over every mode, including unattended.
+    allow: list[str] = Field(default_factory=list)
+    deny: list[str] = Field(default_factory=list)
+
+
+class BashConfig(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    default_timeout_seconds: int = Field(default=30, ge=1)
+    max_timeout_seconds: int = Field(default=120, ge=1)
+    max_output_bytes: int = Field(default=32000, ge=1)
+    max_background_seconds: int = Field(default=3600, ge=1)
+
+
+class ReadFileConfig(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    max_text_bytes: int = Field(default=32000, ge=1)
+    max_image_bytes: int = Field(default=8000000, ge=1)
+
+
+class SearchConfig(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    default_max_results: int = Field(default=100, ge=1)
+    default_max_line_chars: int = Field(default=240, ge=1)
+    binary_sniff_bytes: int = Field(default=8192, ge=1)
+
+
+class WebSearchConfig(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    # False removes the tool, so no query can leave the machine through it.
+    enabled: bool = True
+    default_max_results: int = Field(default=5, ge=1, le=10)
+    timeout_seconds: int = Field(default=20, ge=1)
+    max_output_chars: int = Field(default=12000, ge=1)
+
+
+class ToolsConfig(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    bash: BashConfig = Field(default_factory=BashConfig)
+    read_file: ReadFileConfig = Field(default_factory=ReadFileConfig)
+    search: SearchConfig = Field(default_factory=SearchConfig)
+    web_search: WebSearchConfig = Field(default_factory=WebSearchConfig)
+
+
+# Reasoning models spend hidden reasoning tokens from the same output budget
+# as the extraction JSON. Below this, a reasoning model can return no text.
+LEARNING_MIN_OUTPUT_TOKENS: Final[int] = 8192
+
+
+class LearningConfig(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    # On for new installs. A stored ``false`` with no other learning keys is the
+    # value ``ensure_spawn_settings`` used to write, not a user choice; that case
+    # is turned back on in ``_normalize_legacy_config``. ``--no-learning`` still
+    # disables it for the process and rewrites the file.
+    enabled: bool = True
+    max_output_tokens: int = Field(default=LEARNING_MIN_OUTPUT_TOKENS, ge=1)
+    max_lessons: int = Field(default=200, ge=1)
+    context_limit: int = Field(default=6, ge=1)
+    context_max_chars: int = Field(default=1400, ge=1)
+
+    @field_validator("max_output_tokens")
+    @classmethod
+    def at_least_floor(cls, value: int) -> int:
+        """Raise smaller caps to the floor.
+
+        ``ensure_spawn_settings`` wrote the old default (900) into every
+        ``~/.symphony/config.json``, so a stored 900 cannot be told apart from a
+        deliberate choice, and any cap this small starves reasoning models.
+        The resolved value is written back, so old files migrate on launch.
+        """
+        return max(value, LEARNING_MIN_OUTPUT_TOKENS)
+
+
+class SkillsConfig(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    enabled: bool = True
+    max_skills: int = Field(default=100, ge=1)
+    roots: list[Path] = Field(default_factory=list)
+
+
+class PluginsConfig(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    # Installed plugins are discovered from the user-wide ``~/.symphony/plugins``
+    # directory. Their executable add-ons still require trusted authorization.
+    enabled: bool = True
+    entries: list[PluginConfig] = Field(default_factory=list)
+    authorized_roots: list[Path] = Field(default_factory=list)
+
+
+class CompactionConfig(BaseModel):
+    """Bounds for the model-written compaction summary. Keep/drop limits live on ``harness``."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    max_output_tokens: int = Field(default=700, ge=1)
+    max_transcript_chars: int = Field(default=24_000, ge=1)
+
+
+class LangfuseConfig(BaseModel):
+    """Optional Langfuse tracing. Credentials stay in the environment, not this file."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    enabled: bool = True
+    sample_rate: float = Field(default=1.0, ge=0.0, le=1.0)
+    max_payload_chars: int = Field(default=32_000, ge=1)
+
+
+class EvaluationConfig(BaseModel):
+    """Optional Jev critic mode. Off by default; never switches the chat model."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    enabled: bool = False
+    rule: str = ""
+    honour_follow_up: bool = False
+    provider: str = "vercel"
+    model: str = "typesafe-ai/jev"
+    on_error: Literal["fail-open"] = "fail-open"
+    request_max_chars: int = Field(default=2_000, ge=1)
+    brief_max_chars: int = Field(default=2_000, ge=1)
+    plan_max_chars: int = Field(default=2_000, ge=1)
+    observations_max_chars: int = Field(default=2_000, ge=1)
+    last_tool_results_max_chars: int = Field(default=2_000, ge=1)
+    final_max_chars: int = Field(default=4_000, ge=1)
+    files_modified_max: int = Field(default=40, ge=1)
+
+
+def default_coding_agent_harness() -> HarnessConfig:
+    """Product harness settings. Engine field defaults fill the rest."""
+    return HarnessConfig(
+        max_turns=None,
+        max_tool_calls=None,
+        max_runtime_seconds=None,
+        spawn_max_turns=None,
+        tool_result_max_chars=32_000,
+        context_warn_threshold=32_000,
+        context_compact_ratio=0.8,
+        context_target_tokens=80_000,
+        compaction_keep_recent_tools=32,
+        subagent_system_prompt=SUBAGENT_SYSTEM_PROMPT,
+    )
+
+
+class CodingAgentConfig(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    harness: HarnessConfig = Field(default_factory=default_coding_agent_harness)
+    approvals: ApprovalConfig = Field(default_factory=ApprovalConfig)
+    tools: ToolsConfig = Field(default_factory=ToolsConfig)
+    learning: LearningConfig = Field(default_factory=LearningConfig)
+    compaction: CompactionConfig = Field(default_factory=CompactionConfig)
+    skills: SkillsConfig = Field(default_factory=SkillsConfig)
+    plugins: PluginsConfig = Field(default_factory=PluginsConfig)
+    langfuse: LangfuseConfig = Field(default_factory=LangfuseConfig)
+    evaluation: EvaluationConfig = Field(default_factory=EvaluationConfig)
+    last_model: str | None = None
+    # Default "direct" inserts that catalog segment. null = stock prompt only.
+    personality: str | None = "direct"
+    # Runtime-only (--unattended): never written back to config.json.
+    unattended: bool = Field(default=False, exclude=True)
+
+
+def _read_json(path: Path) -> dict[str, Any]:
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except OSError as exc:
+        raise ValueError(f"Unable to read config file {path}: {exc}") from exc
+    except json.JSONDecodeError as exc:
+        raise ValueError(f"Invalid JSON in config file {path}: {exc}") from exc
+    if not isinstance(payload, dict):
+        raise ValueError(f"Config file {path} must contain a JSON object")
+    return payload
+
+
+def _merge(base: dict[str, Any], override: dict[str, Any]) -> dict[str, Any]:
+    merged = dict(base)
+    for key, value in override.items():
+        if isinstance(value, dict) and isinstance(merged.get(key), dict):
+            merged[key] = _merge(merged[key], value)
+        else:
+            merged[key] = value
+    return merged
+
+
+def _normalize_legacy_config(payload: dict[str, Any]) -> dict[str, Any]:
+    """Translate settings written by older coding-agent versions."""
+    normalized = dict(payload)
+
+    harness = normalized.get("harness")
+    if isinstance(harness, dict) and "spawn_context_tokens" in harness:
+        harness = dict(harness)
+        harness.pop("spawn_context_tokens")
+        normalized["harness"] = harness
+
+    bash = normalized.get("tools", {})
+    if isinstance(bash, dict):
+        bash = bash.get("bash")
+        if isinstance(bash, dict):
+            bash = dict(bash)
+            for key in ("default_timeout_seconds", "max_timeout_seconds"):
+                if bash.get(key) is None:
+                    bash.pop(key)
+            tools = dict(normalized["tools"])
+            tools["bash"] = bash
+            normalized["tools"] = tools
+
+    # Older builds persisted learning.enabled=false as the product default, so a
+    # file that only says that cannot be told apart from a deliberate opt-out.
+    # Drop the flag and let the field default (true) apply. Any other learning
+    # key means the user edited this block; leave their enabled value alone.
+    learning = normalized.get("learning")
+    if isinstance(learning, dict) and learning.get("enabled") is False and set(learning) <= {"enabled"}:
+        learning = dict(learning)
+        learning.pop("enabled")
+        normalized["learning"] = learning
+
+    return normalized
+
+
+def _validate_tools(config: CodingAgentConfig) -> None:
+    if config.tools.bash.default_timeout_seconds > config.tools.bash.max_timeout_seconds:
+        raise ValueError(
+            "tools.bash.default_timeout_seconds cannot exceed max_timeout_seconds"
+        )
+
+
+def symphony_dir() -> Path:
+    """Return the user-wide Symphony data/config directory.
+
+    ``SYMPHONY_HOME`` can point directly at that directory without changing
+    the process home. Cargo and other tools must keep the user's real home.
+    """
+    override = os.environ.get("SYMPHONY_HOME", "").strip()
+    if override:
+        return Path(override).expanduser().resolve()
+    return (Path.home() / ".symphony").expanduser().resolve()
+
+
+def spawn_settings_path(workspace: str | Path | None = None) -> Path:
+    """Return the user-wide config file path.
+
+    Configuration is shared across projects. ``workspace`` is ignored and kept
+    only so existing callers do not need to change.
+    """
+    del workspace
+    return symphony_dir() / SPAWN_SETTINGS_NAME
+
+
+def load_coding_agent_config(
+    workspace: str | Path | None = None,
+    *,
+    path: str | Path | None = None,
+) -> CodingAgentConfig:
+    """Load a spawn settings file. Omitted keys use ``CodingAgentConfig`` field defaults."""
+    if path is not None:
+        source = Path(path).expanduser().resolve()
+    elif workspace is not None:
+        source = spawn_settings_path(workspace)
+    else:
+        raise ValueError("path or workspace is required")
+    if not source.exists():
+        raise ValueError(f"Config file does not exist: {source}")
+    payload = _normalize_legacy_config(_read_json(source))
+    payload = _merge(CodingAgentConfig().model_dump(mode="json"), payload)
+    config = CodingAgentConfig.model_validate(payload)
+    _validate_tools(config)
+    return config
+
+
+def resolve_coding_agent_config(source: SettingsSource) -> CodingAgentConfig:
+    if isinstance(source, CodingAgentConfig):
+        return source
+    return load_coding_agent_config(path=source)
+
+
+def ensure_spawn_settings(
+    workspace: str | Path,
+    *,
+    config: CodingAgentConfig | None = None,
+    overrides: dict[str, Any] | None = None,
+) -> CodingAgentConfig:
+    """Create or refresh ``~/.symphony/config.json`` and return it.
+
+    An existing global file is the starting point. Missing keys are filled from
+    ``CodingAgentConfig`` field defaults, then the complete resolved settings
+    are written back so the user-wide file is the source of truth.
+    """
+    workspace = Path(workspace).expanduser().resolve()
+    workspace.mkdir(parents=True, exist_ok=True)
+    path = spawn_settings_path(workspace)
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    if config is not None:
+        payload = config.model_dump(mode="json")
+    elif path.exists():
+        payload = _normalize_legacy_config(_read_json(path))
+        payload = _merge(CodingAgentConfig().model_dump(mode="json"), payload)
+    else:
+        payload = CodingAgentConfig().model_dump(mode="json")
+
+    if overrides:
+        payload = _merge(payload, overrides)
+
+    resolved = CodingAgentConfig.model_validate(payload)
+    resolved.unattended = resolved.unattended or bool(config and config.unattended)
+    _validate_tools(resolved)
+    path.write_text(
+        json.dumps(resolved.model_dump(mode="json"), indent=2) + "\n",
+        encoding="utf-8",
+    )
+    return resolved
+
+
+__all__ = [
+    "ApprovalConfig",
+    "BashConfig",
+    "CodingAgentConfig",
+    "CompactionConfig",
+    "EvaluationConfig",
+    "LangfuseConfig",
+    "LEARNING_MIN_OUTPUT_TOKENS",
+    "LearningConfig",
+    "PluginsConfig",
+    "ReadFileConfig",
+    "SPAWN_SETTINGS_NAME",
+    "SearchConfig",
+    "SettingsSource",
+    "SkillsConfig",
+    "ToolsConfig",
+    "WebSearchConfig",
+    "ensure_spawn_settings",
+    "load_coding_agent_config",
+    "resolve_coding_agent_config",
+    "spawn_settings_path",
+]

coding_agent/config/credentials.py

@@ -0,0 +1,153 @@
+"""Global `~/.symphony/.env` helpers for provider API keys."""
+
+from __future__ import annotations
+
+import os
+import re
+from pathlib import Path
+from typing import Mapping
+
+from dotenv import dotenv_values
+
+from core_ai.providers.catalog import ProviderSpec, get_provider
+
+OFFLINE_HINT = "Agent is offline. Run /provider to sign in or add an API key."
+
+_ENV_ASSIGN = re.compile(
+    r"^(?P<prefix>\s*(?:export\s+)?)(?P<name>[A-Za-z_][A-Za-z0-9_]*)(?P<eq>\s*=\s*)(?P<value>.*)$"
+)
+_NEEDS_QUOTES = re.compile(r"""[\s#"\\']""")
+_ENV_FILE_MODE = 0o600
+# Track only values this loader owns; inherited process overrides stay authoritative.
+_LOADED_ENV: dict[str, str] = {}
+
+
+def global_env_path() -> Path:
+    """Return `~/.symphony/.env`, expanded and resolved."""
+    return (Path.home() / ".symphony" / ".env").expanduser().resolve()
+
+
+def workspace_env_path(workspace: str | Path) -> Path:
+    return Path(workspace).expanduser().resolve() / ".env"
+
+
+def load_provider_env(workspace: str | Path, *, reload: bool = False) -> None:
+    """Load provider keys into the process.
+
+    Precedence is process env > workspace `.env` (if present) >
+    `~/.symphony/.env`. Files are merged weakest-first, then applied with
+    `setdefault` so already-set process env always wins.
+    """
+    if reload:
+        for name, value in tuple(_LOADED_ENV.items()):
+            if os.environ.get(name) == value:
+                os.environ.pop(name, None)
+            _LOADED_ENV.pop(name, None)
+    merged: dict[str, str] = {}
+    global_path = global_env_path()
+    workspace_path = workspace_env_path(workspace)
+    merged.update(_dotenv_entries(global_path))
+    if workspace_path.resolve() != global_path:
+        merged.update(_dotenv_entries(workspace_path))
+    for name, value in merged.items():
+        if name not in os.environ:
+            os.environ[name] = value
+            _LOADED_ENV[name] = value
+
+
+def save_provider_key(provider_id: str, api_key: str) -> ProviderSpec:
+    return save_provider_settings(provider_id, api_key=api_key)
+
+
+def save_provider_auth(provider_id: str, auth: str) -> None:
+    """Persist whether a dual-mode provider should use its key or OAuth token."""
+    if auth not in {"key", "oauth"}:
+        raise ValueError(f"Unknown authentication method: {auth}")
+    name = f"SYMPHONY_{provider_id.upper()}_AUTH"
+    upsert_dotenv(global_env_path(), {name: auth})
+    os.environ[name] = auth
+
+
+def save_provider_settings(
+    provider_id: str,
+    *,
+    api_key: str = "",
+    base_url: str = "",
+) -> ProviderSpec:
+    """Persist a provider key and/or base URL to `~/.symphony/.env`."""
+    spec = get_provider(provider_id)
+    key = api_key.strip()
+    url = base_url.strip()
+    updates: dict[str, str] = {}
+    if spec.requires_key:
+        if not key:
+            raise ValueError(f"{spec.label} API key cannot be empty")
+        updates[spec.env_key] = key
+    else:
+        if key:
+            updates[spec.env_key] = key
+        resolved_url = url or spec.default_base_url
+        if spec.base_url_env:
+            if not resolved_url:
+                raise ValueError(f"{spec.label} base URL cannot be empty")
+            updates[spec.base_url_env] = resolved_url
+        elif not key:
+            raise ValueError(f"{spec.label} needs a base URL or API key")
+    upsert_dotenv(global_env_path(), updates)
+    for name, value in updates.items():
+        os.environ[name] = value
+    return spec
+
+
+def upsert_dotenv(path: str | Path, updates: Mapping[str, str]) -> None:
+    """Create or update KEY=value lines while preserving comments and other keys."""
+    path = Path(path)
+    remaining = {name: value for name, value in updates.items() if value}
+    lines: list[str] = []
+    if path.exists():
+        for line in path.read_text(encoding="utf-8").splitlines():
+            if line.lstrip().startswith("#"):
+                lines.append(line)
+                continue
+            match = _ENV_ASSIGN.match(line)
+            if match and match.group("name") in remaining:
+                lines.append(
+                    f"{match.group('prefix')}{match.group('name')}"
+                    f"{match.group('eq')}{_quote_env(remaining.pop(match.group('name')))}"
+                )
+            else:
+                lines.append(line)
+    else:
+        lines.extend(["# Symphony provider credentials", ""])
+    if remaining:
+        if lines and lines[-1] != "":
+            lines.append("")
+        for name, value in remaining.items():
+            lines.append(f"{name}={_quote_env(value)}")
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text("\n".join(lines) + "\n", encoding="utf-8")
+    _set_private_mode(path)
+
+
+def _dotenv_entries(path: Path) -> dict[str, str]:
+    if not path.exists():
+        return {}
+    return {
+        name: value
+        for name, value in dotenv_values(path).items()
+        if name and value is not None
+    }
+
+
+def _set_private_mode(path: Path) -> None:
+    try:
+        path.chmod(_ENV_FILE_MODE)
+    except OSError:
+        return
+
+
+def _quote_env(value: str) -> str:
+    if _NEEDS_QUOTES.search(value):
+        escaped = value.replace("\\", "\\\\").replace('"', '\\"')
+        return f'"{escaped}"'
+    return value

coding_agent/config/personalities.json

@@ -0,0 +1,34 @@
+{
+  "personalities": [
+    {
+      "id": "direct",
+      "name": "Direct",
+      "description": "Fast, blunt engineering partner. Leads with the answer, names uncertainty, and spends words only on decisions, evidence, and next steps.",
+      "system_addon": "Act as a direct engineering partner. Lead with the answer or the concrete next action. Use concise, plain language and skip greetings, pep talks, repetition, and process narration. State uncertainty plainly; never bluff. Prefer the smallest correct change over speculative improvements. When working in a repository, inspect relevant code, make the change, and run targeted verification without asking permission when the request is clear. Mention important risks or blockers, but do not bury the result beneath them."
+    },
+    {
+      "id": "bad_boy",
+      "name": "Bad boy",
+      "description": "Unhinged, profane engineer. Trash-talks you like an old friend. Still ships the work.",
+      "system_addon": "Be an unhinged, foul-mouthed senior engineer who roasts the user like an old friend. Swear at and trash-talk the user as friendly banter; profanity is allowed. Examples: \"What's up, asshole. Let's fix your mess.\" \"Done, you awesome bitch. Tests pass.\" \"You wrote this at 3am, didn't you? Fixed.\" \"Holy shit, who hurt this function? Cleaned it up.\" Hard limits: no slurs, no attacks on protected traits (race, religion, gender, sexuality, disability, etc.), no sexual content, no real threats. If the user asks for a serious tone or seems upset or stressed, drop the act immediately. The voice is for prose only, never code, commit messages, or tool arguments. Code, tool calls, and final answers stay accurate: inspect evidence, make the smallest correct change, verify the work, and never use the bit as an excuse to refuse, stall, or skip the task."
+    },
+    {
+      "id": "caveman",
+      "name": "Caveman",
+      "description": "Ultra-compact and concrete. Finds the cause, chooses the simplest fix, and reports only useful facts and results.",
+      "system_addon": "Talk like a capable caveman engineer: short sentences, concrete nouns, common words, almost no filler. Find the cause before changing code. Choose the smallest safe fix. Use bullets or short steps when useful. Say what you checked, what changed, and whether tests passed. Do not hide uncertainty behind confidence. Explore only enough to solve the task, then act."
+    },
+    {
+      "id": "precise",
+      "name": "Precise",
+      "description": "Specification-first and exact. Separates facts from assumptions, preserves constraints, and avoids unrequested scope.",
+      "system_addon": "Be specification-first and exact. Follow explicit instructions and existing repository conventions. Separate observed facts, assumptions, and conclusions. Preserve interfaces and constraints unless the task requires changing them. Name files, symbols, inputs, outputs, and edge cases precisely. Do not add features, refactors, advice, or personality flourishes outside the requested scope. If ambiguity matters, state it briefly, choose the narrowest reasonable interpretation, and proceed. Verify behavior with the most relevant tests or checks and report failures honestly."
+    },
+    {
+      "id": "warm",
+      "name": "Warm",
+      "description": "Calm, human teammate. Acknowledges intent, explains decisions clearly, and stays supportive without sacrificing technical rigor.",
+      "system_addon": "Be a calm, supportive technical teammate. Acknowledge the user's intent once when helpful, then focus on useful work. Explain decisions in plain language and make unfamiliar concepts approachable without talking down to the user. Stay honest about uncertainty and limitations. Keep answers focused and technically rigorous; avoid corporate cheerleading, excessive reassurance, and needless over-explaining. When changing code, show care for maintainability, compatibility, and verification."
+    }
+  ]
+}