symphony-code 0.0.1__py3-none-any.whl

coding_agent/bench/cli.py

@@ -0,0 +1,200 @@
+"""Headless ``symphony bench``: run ``CodingAgent``, write patch + result.json."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import os
+import sys
+import tempfile
+import tomllib
+from pathlib import Path
+from typing import Any, Sequence
+
+from core_ai import has_configured_provider
+from core_ai.providers.catalog import MissingProviderCredentials
+from core_harness import EventSink, HarnessCancelled, HarnessLimitExceeded
+
+from coding_agent.agent import CodingAgent
+from coding_agent.bench.patch import git_head, write_workspace_patch
+from coding_agent.config import (
+    ApprovalConfig,
+    CodingAgentConfig,
+    EvaluationConfig,
+    LearningConfig,
+    PluginsConfig,
+    default_coding_agent_harness,
+)
+from coding_agent.config.credentials import load_provider_env
+
+PERSONALITIES = ("direct", "precise")
+
+
+def _config_paths() -> list[Path]:
+    paths: list[Path] = []
+    env = os.environ.get("SYMPHONY_BENCH_CONFIG", "").strip()
+    if env:
+        paths.append(Path(env))
+    paths.append(Path("/opt/symphony/bench/config.toml"))
+    here = Path(__file__).resolve()
+    if len(here.parents) >= 5:
+        paths.append(here.parents[4] / "bench" / "config.toml")
+    return paths
+
+
+def load_bench_config() -> dict[str, Any]:
+    for path in _config_paths():
+        if path.is_file():
+            payload = tomllib.loads(path.read_text(encoding="utf-8"))
+            if isinstance(payload, dict):
+                return payload
+    return {}
+
+
+def build_parser(defaults: dict[str, Any] | None = None) -> argparse.ArgumentParser:
+    defaults = defaults if defaults is not None else load_bench_config()
+    testbed = str(defaults.get("testbed") or "/testbed")
+    workspace = testbed if Path(testbed).is_dir() else "."
+    parser = argparse.ArgumentParser(
+        prog="symphony bench",
+        description="Headless Symphony bench run. Writes workspace.patch and result.json.",
+    )
+    parser.add_argument("--workspace", default=workspace, help="Working directory (default: /testbed if present, else .)")
+    parser.add_argument(
+        "--instruction",
+        default="-",
+        help="Instruction file, or - for stdin",
+    )
+    parser.add_argument("--model", default=defaults.get("model"), help="provider:model id")
+    parser.add_argument(
+        "--max-turns",
+        type=int,
+        default=int(defaults["max_turns"]) if defaults.get("max_turns") is not None else None,
+    )
+    parser.add_argument(
+        "--timeout",
+        type=float,
+        default=float(defaults["timeout_sec"]) if defaults.get("timeout_sec") is not None else None,
+        help="Run time cap in seconds (harness max_runtime_seconds)",
+    )
+    parser.add_argument(
+        "--personality",
+        choices=PERSONALITIES,
+        default=str(defaults.get("personality") or "direct"),
+        help="Fixed personality (no picker)",
+    )
+    parser.add_argument(
+        "--jev",
+        dest="enable_jev",
+        action="store_true",
+        default=False,
+        help="Enable Jev critic mode (off by default)",
+    )
+    return parser
+
+
+def read_instruction(value: str) -> str:
+    if value == "-":
+        if sys.stdin.isatty():
+            raise SystemExit("instruction required: pass --instruction FILE or pipe stdin")
+        return sys.stdin.read()
+    path = Path(value).expanduser()
+    if not path.is_file():
+        raise SystemExit(f"instruction file not found: {value}")
+    return path.read_text(encoding="utf-8")
+
+
+def _write_result(workspace: Path, payload: dict[str, Any]) -> None:
+    (workspace / "result.json").write_text(
+        json.dumps(payload, indent=2) + "\n",
+        encoding="utf-8",
+    )
+
+
+def _turns(sink: EventSink) -> int:
+    return sum(1 for event in sink.events if event.event_type == "turn_started")
+
+
+def _isolate_home() -> None:
+    os.environ["HOME"] = tempfile.mkdtemp(prefix="symphony-bench-home-")
+
+
+def _bench_config(
+    *,
+    personality: str,
+    enable_jev: bool,
+    max_turns: int | None,
+    timeout: float | None,
+) -> CodingAgentConfig:
+    harness = default_coding_agent_harness()
+    updates: dict[str, Any] = {}
+    if max_turns is not None:
+        updates["max_turns"] = max_turns
+    if timeout is not None:
+        updates["max_runtime_seconds"] = float(timeout)
+    if updates:
+        harness = harness.model_copy(update=updates)
+    return CodingAgentConfig(
+        harness=harness,
+        personality=personality,
+        learning=LearningConfig(enabled=False),
+        evaluation=EvaluationConfig(enabled=enable_jev),
+        plugins=PluginsConfig(enabled=False),
+        approvals=ApprovalConfig(mode="always_allow"),
+    )
+
+
+async def _run_agent(agent: CodingAgent, instruction: str) -> None:
+    await agent.run(instruction)
+
+
+def run_bench(args: argparse.Namespace) -> int:
+    workspace = Path(args.workspace).expanduser().resolve()
+    workspace.mkdir(parents=True, exist_ok=True)
+    instruction = read_instruction(args.instruction)
+    load_provider_env(workspace)
+    start_ref = git_head(workspace)
+    sink = EventSink()
+    ok = False
+    error: str | None = None
+    try:
+        if not has_configured_provider():
+            raise MissingProviderCredentials()
+        _isolate_home()
+        from core_ai import build_default_registry, default_model_id
+
+        registry = build_default_registry()
+        agent = CodingAgent(
+            registry=registry,
+            model_id=default_model_id(registry, args.model),
+            workspace=workspace,
+            config=_bench_config(
+                personality=args.personality,
+                enable_jev=bool(args.enable_jev),
+                max_turns=args.max_turns,
+                timeout=args.timeout,
+            ),
+            sink=sink,
+        )
+        asyncio.run(_run_agent(agent, instruction))
+        ok = True
+    except HarnessLimitExceeded:
+        ok = True
+    except HarnessCancelled as exc:
+        error = str(exc) or "cancelled"
+    except Exception as exc:
+        error = str(exc) or exc.__class__.__name__
+    turns = _turns(sink)
+    write_workspace_patch(workspace, start_ref=start_ref)
+    payload: dict[str, Any] = {"ok": ok, "turns": turns}
+    if error:
+        payload["error"] = error
+    _write_result(workspace, payload)
+    return 0 if ok else 1
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(list(argv) if argv is not None else None)
+    return run_bench(args)

coding_agent/bench/patch.py

@@ -0,0 +1,78 @@
+"""Git diff of the workspace from a recorded start ref."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import tempfile
+from pathlib import Path
+
+_EXCLUDE = ("workspace.patch", "result.json", "instruction.md", ".symphony")
+
+
+def git_head(workspace: Path) -> str | None:
+    result = subprocess.run(
+        ["git", "rev-parse", "HEAD"],
+        cwd=workspace,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if result.returncode != 0:
+        return None
+    ref = result.stdout.strip()
+    return ref or None
+
+
+def workspace_diff(workspace: Path, start_ref: str | None = None) -> str:
+    """Unified diff of tracked and untracked files versus ``start_ref`` (default HEAD)."""
+    workspace = workspace.resolve()
+    ref = start_ref or git_head(workspace)
+    if ref is None:
+        return ""
+    env = os.environ.copy()
+    with tempfile.TemporaryDirectory(prefix="symphony-bench-index-") as tmp:
+        env["GIT_INDEX_FILE"] = str(Path(tmp) / "index")
+        read = subprocess.run(
+            ["git", "read-tree", ref],
+            cwd=workspace,
+            env=env,
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if read.returncode != 0:
+            return ""
+        subprocess.run(
+            ["git", "add", "-A", "--", "."],
+            cwd=workspace,
+            env=env,
+            capture_output=True,
+            check=False,
+        )
+        subprocess.run(
+            ["git", "reset", "-q", "--", *_EXCLUDE],
+            cwd=workspace,
+            env=env,
+            capture_output=True,
+            check=False,
+        )
+        diff = subprocess.run(
+            ["git", "diff", "--cached", "--binary", "--no-color"],
+            cwd=workspace,
+            env=env,
+            capture_output=True,
+            check=False,
+        )
+        return diff.stdout.decode("utf-8", errors="replace")
+
+
+def write_workspace_patch(
+    workspace: Path,
+    dest: Path | None = None,
+    *,
+    start_ref: str | None = None,
+) -> Path:
+    dest = dest or workspace.resolve() / "workspace.patch"
+    dest.write_text(workspace_diff(workspace, start_ref), encoding="utf-8")
+    return dest

coding_agent/commands/__init__.py

@@ -0,0 +1,5 @@
+"""Slash-command catalog and decisions shared by the TUI and the stdio host.
+
+Pure data and matching. Nothing here imports Textual, so headless surfaces
+(``protocols/stdio``) can read the same catalog the TUI shows.
+"""

coding_agent/commands/catalog.py

@@ -0,0 +1,179 @@
+"""Slash-command catalogs and option matching."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Iterable, Optional
+
+from core_ai import list_models
+from coding_agent.config.personalities import load_personalities
+
+
+@dataclass(frozen=True)
+class SlashCommand:
+    name: str
+    description: str
+    argument: str = ""
+
+    @property
+    def usage(self) -> str:
+        return f"/{self.name}{f' {self.argument}' if self.argument else ''}"
+
+
+@dataclass(frozen=True)
+class ModelOption:
+    id: str
+    label: str
+    description: str
+
+
+@dataclass(frozen=True)
+class EffortOption:
+    id: str
+    label: str
+    description: str
+
+
+@dataclass(frozen=True)
+class PersonalityOption:
+    id: str
+    label: str
+    description: str
+
+
+def model_options(providers: Iterable[str] | None = None) -> tuple[ModelOption, ...]:
+    """Build TUI choices from the core_ai catalog, optionally by provider."""
+    source = list_models() if providers is None else tuple(
+        model for provider in providers for model in list_models(provider)
+    )
+    return tuple(
+        ModelOption(
+            id=model.full_id,
+            label=model.id,
+            description=f"{model.provider} · {model.api.replace('_', ' ')}",
+        )
+        for model in source
+    )
+
+
+def find_model(
+    value: str,
+    models: Iterable[ModelOption] | None = None,
+) -> Optional[ModelOption]:
+    models = model_options() if models is None else models
+    needle = value.strip().lower()
+    if not needle:
+        return None
+    matches = [
+        model for model in models
+        if needle in {model.id.lower(), model.id.split(":", 1)[-1].lower(), model.label.lower()}
+    ]
+    return matches[0] if len(matches) == 1 else None
+
+
+def model_matches(
+    value: str,
+    models: Iterable[ModelOption] | None = None,
+) -> tuple[ModelOption, ...]:
+    models = model_options() if models is None else models
+    needle = value.strip().lower()
+    return tuple(model for model in models if not needle or needle in model.id.lower() or needle in model.label.lower())
+
+
+EFFORT_CATALOG = (
+    EffortOption("default", "Default", "Use Symphony's balanced default"),
+    EffortOption("none", "None", "Fastest · no deliberate reasoning"),
+    EffortOption("low", "Low", "Fast · lightweight reasoning"),
+    EffortOption("medium", "Medium", "Balanced speed and depth"),
+    EffortOption("high", "High", "Deeper reasoning"),
+    EffortOption("xhigh", "Extra high", "Extended reasoning"),
+    EffortOption("max", "Maximum", "Deepest reasoning · GPT-5.6"),
+)
+EFFORTS = tuple(option.id for option in EFFORT_CATALOG)
+
+
+SLASH_COMMANDS = (
+    SlashCommand("model", "View or switch the active model", "[model]"),
+    SlashCommand("personality", "View or switch the agent personality", "[id]"),
+    SlashCommand("voice", "Talk until you say done or press Ctrl+A again", ""),
+    SlashCommand("effort", "Set model reasoning effort", "[level]"),
+    SlashCommand("provider", "Sign in or add a model provider", "[name]"),
+    SlashCommand("langfuse", "Configure Langfuse telemetry and install the SDK", ""),
+    SlashCommand("jev", "Set a Jev finish rule or toggle it", "[on|off|rule]"),
+    SlashCommand("new", "Start a fresh conversation"),
+    SlashCommand("addon", "Create or improve a Symphony user addon", "[idea]"),
+    SlashCommand("reload", "Reload configuration from .env and user addons"),
+    SlashCommand("addons", "List loaded and failed user addons"),
+    SlashCommand("compact", "Keep recent messages and compact saved context"),
+    SlashCommand("status", "Show session, model, and context details"),
+    SlashCommand("dashboard", "Show live agents and their CPU, memory, and disk"),
+    SlashCommand("context", "Inspect active model context"),
+    SlashCommand("session", "Inspect session images, compactions, memory, and recorded events"),
+    SlashCommand("learning", "Browse curated memory topics and pending captures"),
+    SlashCommand("installed", "View installed skills and plugins"),
+    SlashCommand("diff", "Open the current workspace diff in a modal"),
+    SlashCommand("clear", "Clear the visible transcript"),
+    SlashCommand("help", "Show available slash commands"),
+    SlashCommand("quit", "Exit Symphony"),
+)
+
+
+def command_matches(
+    value: str,
+    *,
+    include_effort: bool = True,
+    extra: Iterable[SlashCommand] = (),
+) -> tuple[SlashCommand, ...]:
+    """Match built-in commands, then ``extra`` (user-addon commands)."""
+    if not value.startswith("/") or " " in value:
+        return ()
+    prefix = value[1:].lower()
+    return tuple(
+        command
+        for command in (*SLASH_COMMANDS, *extra)
+        if command.name.startswith(prefix)
+        and (include_effort or command.name != "effort")
+    )
+
+
+def personality_options() -> tuple[PersonalityOption, ...]:
+    return tuple(
+        PersonalityOption(
+            item.id,
+            item.name,
+            item.description or item.system_addon.split(".", 1)[0],
+        )
+        for item in load_personalities()
+    )
+
+
+def find_personality(
+    value: str,
+    personalities: Iterable[PersonalityOption] | None = None,
+) -> Optional[PersonalityOption]:
+    options = personality_options() if personalities is None else personalities
+    needle = value.strip().lower()
+    if not needle:
+        return None
+    matches = [
+        item
+        for item in options
+        if needle in {item.id.lower(), item.label.lower(), item.id.replace("_", " ").lower()}
+    ]
+    return matches[0] if len(matches) == 1 else None
+
+
+def personality_matches(
+    value: str,
+    personalities: Iterable[PersonalityOption] | None = None,
+) -> tuple[PersonalityOption, ...]:
+    options = personality_options() if personalities is None else personalities
+    needle = value.strip().lower()
+    return tuple(
+        item
+        for item in options
+        if not needle
+        or needle in item.id.lower()
+        or needle in item.label.lower()
+        or needle in item.id.replace("_", " ").lower()
+    )

coding_agent/commands/jev_argument.py

@@ -0,0 +1,40 @@
+"""Read the ``/jev`` argument once for every surface.
+
+The TUI keeps a rule for the current session and the stdio protocol writes it
+to config. Where the rule is stored stays with each surface; this module only
+decides what the argument means.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+_TOGGLE = frozenset({"", "toggle"})
+_ON = frozenset({"on", "enable", "true", "1"})
+_OFF = frozenset({"off", "disable", "false", "0"})
+
+
+@dataclass(frozen=True)
+class JevChange:
+    """Result of ``/jev <argument>``. ``rule`` is None when the rule is unchanged."""
+
+    enabled: bool
+    rule: Optional[str] = None
+
+
+def parse_jev_argument(current: bool, argument: str) -> JevChange:
+    """Resolve ``/jev [toggle|on|off|<rule>]``.
+
+    Keywords are case-insensitive. Any other text is a rule (kept as typed,
+    minus surrounding whitespace) and turns Jev on.
+    """
+    text = argument.strip()
+    needle = text.lower()
+    if needle in _TOGGLE:
+        return JevChange(enabled=not current)
+    if needle in _ON:
+        return JevChange(enabled=True)
+    if needle in _OFF:
+        return JevChange(enabled=False)
+    return JevChange(enabled=True, rule=text)

coding_agent/config/__init__.py

@@ -0,0 +1,51 @@
+"""Configuration, credentials, personalities, and prompts for coding_agent."""
+
+from coding_agent.config.config import (
+    ApprovalConfig,
+    BashConfig,
+    CodingAgentConfig,
+    CompactionConfig,
+    EvaluationConfig,
+    LEARNING_MIN_OUTPUT_TOKENS,
+    LangfuseConfig,
+    LearningConfig,
+    PluginsConfig,
+    ReadFileConfig,
+    SPAWN_SETTINGS_NAME,
+    SearchConfig,
+    SkillsConfig,
+    SettingsSource,
+    ToolsConfig,
+    WebSearchConfig,
+    default_coding_agent_harness,
+    ensure_spawn_settings,
+    load_coding_agent_config,
+    resolve_coding_agent_config,
+    spawn_settings_path,
+    symphony_dir,
+)
+
+__all__ = [
+    "ApprovalConfig",
+    "BashConfig",
+    "CodingAgentConfig",
+    "CompactionConfig",
+    "EvaluationConfig",
+    "LangfuseConfig",
+    "LEARNING_MIN_OUTPUT_TOKENS",
+    "LearningConfig",
+    "PluginsConfig",
+    "ReadFileConfig",
+    "SPAWN_SETTINGS_NAME",
+    "SearchConfig",
+    "SkillsConfig",
+    "SettingsSource",
+    "ToolsConfig",
+    "WebSearchConfig",
+    "default_coding_agent_harness",
+    "ensure_spawn_settings",
+    "load_coding_agent_config",
+    "resolve_coding_agent_config",
+    "spawn_settings_path",
+    "symphony_dir",
+]