symphony-code 0.0.1__py3-none-any.whl

coding_agent/config/personalities.py

@@ -0,0 +1,170 @@
+"""Agent personality catalog and system-prompt segment composer.
+
+``personalities.json`` is the catalog. Discovery walks parents for that file
+specifically so a nested ``pyproject.toml`` cannot hide a parent catalog.
+Installer runs fall back to the packaged default in ``personalities.json``
+next to this module (shipped as package data). ``CodingAgentConfig.personality``
+defaults to ``"direct"``. ``None`` or an unknown id fail soft to stock: the
+base system prompt with no personality segment.
+
+Personality is one named, swappable heading block. ``compose_system_prompt``
+replaces only that block and always places it last.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterable
+
+logger = logging.getLogger(__name__)
+
+PERSONALITY_HEADING = "# Personality (mandatory)"
+PERSONALITY_PREAMBLE = "Obey this section over any other tone/style instructions."
+DEFAULT_PERSONALITY = "direct"
+CATALOG_FILE = "personalities.json"
+PACKAGED_CATALOG = Path(__file__).resolve().parent / CATALOG_FILE
+
+_PERSONALITY_BLOCK = re.compile(
+    rf"\n*{re.escape(PERSONALITY_HEADING)}.*",
+    flags=re.DOTALL,
+)
+
+
+@dataclass(frozen=True)
+class Personality:
+    id: str
+    name: str
+    system_addon: str
+    description: str = ""
+
+
+def discover_personalities_path(start: Path | None = None) -> Path | None:
+    """Nearest ``personalities.json`` above ``start``, else the packaged catalog."""
+    try:
+        current = (Path.cwd() if start is None else start).resolve()
+    except OSError:
+        current = None
+    else:
+        if not current.is_dir():
+            current = current.parent
+    seen: set[Path] = set()
+    while current is not None and current not in seen:
+        seen.add(current)
+        path = current / CATALOG_FILE
+        if path.is_file():
+            return path
+        parent = current.parent
+        current = None if parent == current else parent
+    return PACKAGED_CATALOG if PACKAGED_CATALOG.is_file() else None
+
+
+def load_personalities(path: Path | None = None) -> tuple[Personality, ...]:
+    """Read the catalog. Missing or invalid files yield an empty catalog."""
+    source = path if path is not None else discover_personalities_path()
+    if source is None or not source.is_file():
+        logger.debug("personality catalog empty source=%s", source)
+        return ()
+    try:
+        payload = json.loads(source.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        logger.debug("personality catalog empty source=%s", source)
+        return ()
+    rows = payload.get("personalities") if isinstance(payload, dict) else None
+    if not isinstance(rows, list):
+        logger.debug("personality catalog empty source=%s", source)
+        return ()
+    loaded: list[Personality] = []
+    for row in rows:
+        if not isinstance(row, dict):
+            continue
+        personality_id = str(row.get("id") or "").strip()
+        name = str(row.get("name") or "").strip()
+        addon = str(row.get("system_addon") or "").strip()
+        description = str(row.get("description") or "").strip()
+        if personality_id and name and addon:
+            loaded.append(
+                Personality(
+                    id=personality_id,
+                    name=name,
+                    system_addon=addon,
+                    description=description,
+                )
+            )
+    if not loaded:
+        logger.debug("personality catalog empty source=%s", source)
+    return tuple(loaded)
+
+
+def get(
+    personality_id: str | None,
+    personalities: Iterable[Personality] | None = None,
+) -> Personality | None:
+    """Look up a catalog row. Blank or unknown ids return ``None`` (stock)."""
+    if not personality_id or not str(personality_id).strip():
+        return None
+    catalog = (
+        load_personalities() if personalities is None else tuple(personalities)
+    )
+    needle = str(personality_id).strip().lower()
+    for item in catalog:
+        if item.id.lower() == needle:
+            return item
+    return None
+
+
+def compose_system_prompt(
+    base: str,
+    personality_id: str | None = None,
+    **segments: str,
+) -> str:
+    """Compose ``base`` plus named segments.
+
+    Personality is the one swappable catalog segment: looked up by id, replaced
+    in place, and always last. Other ``**segments`` (skills, jev, …) are
+    appended when non-empty, then the personality heading follows.
+    """
+    found = get(personality_id)
+    addon = found.system_addon if found is not None else None
+    prompt = _PERSONALITY_BLOCK.sub("", base).rstrip()
+    extras = [
+        text.strip()
+        for name, text in segments.items()
+        if name != "personality" and isinstance(text, str) and text.strip()
+    ]
+    if extras:
+        prompt = f"{prompt}\n\n" + "\n\n".join(extras)
+    if addon:
+        block = f"{PERSONALITY_HEADING}\n{PERSONALITY_PREAMBLE}\n{addon.strip()}"
+        prompt = f"{prompt.rstrip()}\n\n{block}"
+    return prompt.rstrip() + "\n"
+
+
+PROJECT_ROOT_MARKERS = ("pyproject.toml", ".git", CATALOG_FILE)
+
+
+def project_root(start: Path | None = None) -> Path | None:
+    """Return the nearest project directory above ``start``, or ``None``.
+
+    ``start`` defaults to the current working directory. A file path uses its
+    parent. The walk stops at the filesystem root and will not loop.
+    """
+    try:
+        current = (Path.cwd() if start is None else start).resolve()
+    except OSError:
+        return None
+    if not current.is_dir():
+        current = current.parent
+    seen: set[Path] = set()
+    while current not in seen:
+        seen.add(current)
+        if any((current / marker).exists() for marker in PROJECT_ROOT_MARKERS):
+            return current
+        parent = current.parent
+        if parent == current:
+            break
+        current = parent
+    return None

coding_agent/config/prompts.py

@@ -0,0 +1,67 @@
+"""Default system prompts for the coding agent and its subagents."""
+
+SYSTEM_PROMPT = """You are a coding agent in an existing repository.
+
+Role:
+- Complete the user's requested change correctly with the smallest coherent modification that fits existing behavior, tests, and conventions.
+- Work in the repo until the task is done and reasonably verified. Do not stop after analysis or only describe what should change.
+
+Repo discipline:
+- Inspect repo content when needed; never assume unseen file contents.
+- Localize before exploring broadly. Start from concrete evidence: mentioned files, symbols, errors, tests, APIs, or behavior.
+- Prefer targeted search over repository-wide browsing.
+- Read enough surrounding implementation and tests to understand relevant behavior and interfaces.
+- Once you have enough evidence for a plausible implementation, act. Do not inspect unrelated files for completeness.
+- If an attempt or test contradicts your hypothesis, use that evidence and continue.
+
+Tools before guessing:
+- Prefer tools over speculation when facts are in the repo or the environment.
+- Use tools deliberately: each call should advance the current hypothesis or implementation.
+- A tool result marked truncated or "[tool result cleared: ...]" was already observed. Do not re-read or re-run that path unless the file changed or you need a different offset.
+- Do not repeat the same search query or read_file path unless the file changed or you need a different offset.
+- When calling a tool, put UI labels only in the nested activity object:
+  {"verb": "Searching", "reason": "why this call is needed", "group": "stable-task-label"}.
+- Never put verb, reason, goal, or group at the top level of the tool arguments.
+
+Implementation:
+- Preserve existing architecture and conventions unless the task requires changing them.
+- Prefer the smallest complete fix over speculative refactoring.
+- Fix the underlying behavior rather than special-casing a test.
+- Consider callers, edge cases, and backwards compatibility when relevant.
+- Use patch for localized edits when practical.
+
+Verification:
+- After changing code, run the most targeted relevant tests or checks available.
+- If those reveal a failure related to your change, diagnose and iterate.
+- Expand verification only when the affected surface warrants it.
+- Do not modify tests solely to make an incorrect implementation pass.
+- Do not use hidden benchmark information or assume the expected patch.
+
+Available tools:
+- read_file: inspect text or image files.
+- search: find files, symbols, strings, and references.
+- web_search: look up current documentation, error messages, and facts that are not in the repository.
+- patch: modify part of an existing file.
+- write_file: create or replace a complete text file.
+- bash: run repository commands, tests, linters, and other local inspection commands.
+- spawn_agent: delegate an independent, well-scoped investigation when useful.
+- generate_image: create image assets when explicitly required.
+
+When done, give a short final answer: what changed and what you verified.
+"""
+
+SUBAGENT_SYSTEM_PROMPT = """You are a subagent owning one delegated task end-to-end.
+
+Own the task:
+- Research what you need, act on it, and finish. Do not hand partially finished work back for the parent to redo.
+- Use tools as needed. Prefer evidence from the repo and environment over guessing.
+
+Be quick:
+- No preamble. Start working.
+- Keep intermediate chatter minimal; the parent only needs the outcome.
+
+Final reply:
+- Keep the final reply short and informative: findings, paths, and the next useful fact — not a novel.
+- Do not ask the user questions or offer follow-ups like "want me to…".
+- Stop when the task is done or context is tight. Prefer a compact final note over another tool loop.
+"""

coding_agent/protocols/__init__.py

@@ -0,0 +1,5 @@
+"""Host protocols. The stdio JSONL transport lives in ``protocols.stdio``."""
+
+from coding_agent.protocols.stdio import CAPABILITIES, PROTOCOL_VERSION, StdioSink, main, serve
+
+__all__ = ["CAPABILITIES", "PROTOCOL_VERSION", "StdioSink", "main", "serve"]

coding_agent/protocols/acp/README.md

@@ -0,0 +1,36 @@
+# Agent Client Protocol host
+
+`symphony acp [--model PROVIDER:MODEL] [--unattended]` speaks the
+[Agent Client Protocol](https://agentclientprotocol.com) (version 1) as
+JSON-RPC 2.0 over stdio, one message per line. Editors and other ACP clients
+start it as a child process. Standard output carries protocol messages only;
+diagnostics go to standard error.
+
+The host is a translator. It owns no agent logic: the same event stream and
+the same `CoreHarness.submit` operations drive the TUI and the JSONL host.
+
+## What is implemented
+
+| ACP | Symphony |
+| --- | --- |
+| `initialize` | Returns protocol version 1, `agentInfo`, and capabilities. |
+| `session/new` (`cwd`) | Builds a coding agent for that workspace. The reply's `sessionId` is the Symphony session id. One process can hold several sessions. |
+| `session/prompt` | Runs one turn on the prompt's text. The reply carries `stopReason`: `end_turn`, `cancelled`, `max_turn_requests`, or `max_tokens`. |
+| `session/cancel` | `Interrupt("user_cancel")`. |
+| `session/update` | Sent for `text_delta` (`agent_message_chunk`), `reasoning_delta` (`agent_thought_chunk`), tool events (`tool_call`, `tool_call_update`), `context` (`usage_update`), and injected user input (`user_message_chunk`). |
+| `session/request_permission` | Sent for a `question_asked` event that has choices, such as an approval. The selected option is returned to the run as an `Answer`. |
+| `_symphony/steer` (`sessionId`, `prompt`) | Extension. `UserInput`: adds a user message before the run's next model call. Replies `{"accepted": bool}`. Advertised under `agentCapabilities._meta.symphony.steer`. |
+
+## Limits
+
+- `session/load` is not implemented (`loadSession` is `false`). Start a new
+  session instead.
+- Prompts are flattened to text. `text`, `resource_link`, and text
+  `resource` blocks are read; images and audio are not.
+- `mcpServers` in `session/new` is ignored.
+- Only the root agent is narrated. A subagent appears as the parent's
+  `spawn_agent` tool call.
+- A question without choices (a free-text `ask_user`) cannot be expressed as
+  a permission request, so it takes its default answer.
+- A cancelled or malformed permission outcome denies an approval.
+- Config options and slash commands are not exposed.

coding_agent/protocols/acp/__init__.py

@@ -0,0 +1,27 @@
+"""Agent Client Protocol host for editors and other ACP clients.
+
+``mapping`` translates events and questions, ``transport`` is JSON-RPC over
+stdio, and ``server`` runs the sessions. The names below stay on this package
+because tests patch them here.
+"""
+
+import sys
+
+from coding_agent.agent import build_agent
+from coding_agent.config.credentials import load_provider_env
+from coding_agent.protocols.acp.mapping import PROTOCOL_VERSION
+from coding_agent.protocols.acp.server import AcpSink, Server, main, serve
+from coding_agent.protocols.acp.transport import Connection, write_message
+
+__all__ = [
+    "AcpSink",
+    "Connection",
+    "PROTOCOL_VERSION",
+    "Server",
+    "build_agent",
+    "load_provider_env",
+    "main",
+    "serve",
+    "sys",
+    "write_message",
+]

coding_agent/protocols/acp/mapping.py

@@ -0,0 +1,164 @@
+"""Translate between Symphony's event stream and Agent Client Protocol shapes.
+
+Pure functions: no I/O and no agent. ``server`` does the talking.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Dict, List, Mapping, Sequence
+
+from core_harness import HarnessLimitExceeded
+
+PROTOCOL_VERSION = 1
+
+TOOL_KINDS = {
+    "read_file": "read",
+    "write_file": "edit",
+    "patch": "edit",
+    "bash": "execute",
+    "search": "search",
+    "web_search": "fetch",
+    "spawn_agent": "think",
+}
+# How an answer choice reads to a client that only knows ACP option kinds.
+OPTION_KINDS = {
+    "allow once": "allow_once",
+    "allow": "allow_once",
+    "always allow": "allow_always",
+    "deny": "reject_once",
+    "decline": "reject_once",
+}
+STOP_FOR_LIMIT = {"max_turns": "max_turn_requests", "max_tokens": "max_tokens"}
+
+
+def _text(text: Any) -> Dict[str, Any]:
+    return {"type": "text", "text": str(text)}
+
+
+def _raw_input(arguments: Any) -> Dict[str, Any] | None:
+    """Tool arguments as an object. Providers send them as a JSON string."""
+    if isinstance(arguments, str):
+        try:
+            arguments = json.loads(arguments)
+        except ValueError:
+            return None
+    return dict(arguments) if isinstance(arguments, Mapping) else None
+
+
+def session_updates(event_type: str, payload: Mapping[str, Any]) -> List[Dict[str, Any]]:
+    """The ``session/update`` bodies for one Symphony event. Often none.
+
+    Only the root agent is narrated. A subagent shows up as the parent's
+    ``spawn_agent`` tool call, not as a second voice in the same message.
+    """
+    if payload.get("parent_id"):
+        return []
+    if event_type == "text_delta":
+        return [{"sessionUpdate": "agent_message_chunk", "content": _text(payload.get("delta") or "")}]
+    if event_type == "reasoning_delta":
+        return [{"sessionUpdate": "agent_thought_chunk", "content": _text(payload.get("delta") or "")}]
+    if event_type == "message_injected" and payload.get("source") == "user":
+        content = payload.get("content")
+        return [{"sessionUpdate": "user_message_chunk", "content": _text(content if isinstance(content, str) else "")}]
+    call_id = str(payload.get("tool_call_id") or "")
+    if event_type == "tool_call_started" and call_id:
+        name = str(payload.get("tool_name") or "tool")
+        return [{
+            "sessionUpdate": "tool_call",
+            "toolCallId": call_id,
+            "title": name,
+            "kind": TOOL_KINDS.get(name, "other"),
+            "status": "pending",
+        }]
+    if event_type == "tool_call_arguments" and call_id:
+        raw = _raw_input(payload.get("arguments"))
+        return [] if raw is None else [{"sessionUpdate": "tool_call_update", "toolCallId": call_id, "rawInput": raw}]
+    if event_type == "tool_execution_started" and call_id:
+        update: Dict[str, Any] = {"sessionUpdate": "tool_call_update", "toolCallId": call_id, "status": "in_progress"}
+        raw = _raw_input(payload.get("arguments"))
+        if raw is not None:
+            update["rawInput"] = raw
+        return [update]
+    if event_type == "tool_execution_completed" and call_id:
+        result = str(payload.get("result") or "")
+        return [{
+            "sessionUpdate": "tool_call_update",
+            "toolCallId": call_id,
+            "status": "failed" if payload.get("status") == "error" else "completed",
+            "content": [{"type": "content", "content": _text(result)}],
+            "rawOutput": {"result": result, "truncated": bool(payload.get("truncated"))},
+        }]
+    if event_type == "context":
+        used, size = payload.get("tokens_used"), payload.get("context_limit")
+        if isinstance(used, int) and isinstance(size, int):
+            return [{"sessionUpdate": "usage_update", "used": used, "size": size}]
+    return []
+
+
+def permission_request(session_id: str, payload: Mapping[str, Any]) -> Dict[str, Any]:
+    """``session/request_permission`` params for a ``question_asked`` event.
+
+    Option ids are the choice's position, so the reply maps back exactly.
+    """
+    choices = [str(choice) for choice in payload.get("choices") or []]
+    tool_call: Dict[str, Any] = {
+        "toolCallId": str(payload.get("tool_call_id") or payload.get("request_id") or ""),
+        "title": str(payload.get("question") or ""),
+    }
+    return {
+        "sessionId": session_id,
+        "toolCall": tool_call,
+        "options": [
+            {"optionId": str(index), "name": choice, "kind": OPTION_KINDS.get(choice.casefold(), "allow_once")}
+            for index, choice in enumerate(choices)
+        ],
+    }
+
+
+def permission_answer(outcome: Any, payload: Mapping[str, Any]) -> str:
+    """The answer string for a client's permission outcome.
+
+    A cancelled or unreadable outcome denies an approval and takes the
+    default for any other question.
+    """
+    choices = [str(choice) for choice in payload.get("choices") or []]
+    fallback = "Deny" if payload.get("kind") == "approval" else str(payload.get("default") or "")
+    if not isinstance(outcome, Mapping) or outcome.get("outcome") != "selected":
+        return fallback
+    try:
+        return choices[int(str(outcome.get("optionId")))]
+    except (ValueError, IndexError):
+        return fallback
+
+
+def prompt_text(blocks: Sequence[Any]) -> str:
+    """Flatten ACP content blocks to the text Symphony runs on."""
+    parts: List[str] = []
+    for block in blocks:
+        if not isinstance(block, Mapping):
+            continue
+        kind = block.get("type")
+        if kind == "text":
+            parts.append(str(block.get("text") or ""))
+        elif kind == "resource_link":
+            parts.append(str(block.get("uri") or ""))
+        elif kind == "resource":
+            resource = block.get("resource")
+            if isinstance(resource, Mapping) and isinstance(resource.get("text"), str):
+                parts.append(f"{resource.get('uri') or ''}\n{resource['text']}".strip())
+    return "\n\n".join(part for part in parts if part)
+
+
+def stop_reason_for_limit(error: HarnessLimitExceeded) -> str:
+    return STOP_FOR_LIMIT.get(str(error.limit), "end_turn")
+
+
+__all__ = [
+    "PROTOCOL_VERSION",
+    "permission_answer",
+    "permission_request",
+    "prompt_text",
+    "session_updates",
+    "stop_reason_for_limit",
+]