sid-harness 0.3.0__py3-none-any.whl

sid_harness/tools/skills.py

@@ -0,0 +1,185 @@
+"""Skills loader for the SID harness (the repo's ``.opencode/skills`` pattern).
+
+A skill is a directory containing ``SKILL.md`` with a YAML frontmatter block
+(``name``, ``description``) and a markdown body. This module reads that layout
+and renders a skill into prompt text so the loop can load a workstream skill
+without a third-party YAML dependency. The frontmatter subset the repo uses —
+scalars plus ``|`` / ``|-`` / ``>`` / ``>-`` block scalars — is parsed directly.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+_BLOCK_MARKERS = ("|", "|-", "|+", ">", ">-", ">+")
+
+
+class SkillError(RuntimeError):
+    """A skill file or directory could not be loaded."""
+
+
+@dataclass(frozen=True)
+class Skill:
+    name: str
+    description: str
+    body: str
+    path: Path
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+def _strip_quotes(value: str) -> str:
+    if len(value) >= 2 and value[0] == value[-1] and value[0] in ("'", '"'):
+        return value[1:-1]
+    return value
+
+
+def _read_block(
+    lines: list[str], start: int, *, folded: bool, strip_chomp: bool
+) -> tuple[str, int]:
+    collected: list[str] = []
+    indent: int | None = None
+    index = start
+    while index < len(lines):
+        line = lines[index]
+        if line.strip() == "":
+            collected.append("")
+            index += 1
+            continue
+        current = len(line) - len(line.lstrip(" "))
+        if current == 0:
+            break
+        if indent is None:
+            indent = current
+        if current < indent:
+            break
+        collected.append(line[indent:])
+        index += 1
+    while collected and collected[-1] == "":
+        collected.pop()
+    text = " ".join(part for part in collected) if folded else "\n".join(collected)
+    if strip_chomp:
+        text = text.rstrip("\n")
+    return text, index
+
+
+def parse_frontmatter(text: str) -> tuple[dict[str, Any], str]:
+    """Split ``text`` into (frontmatter mapping, body). Missing frontmatter -> ({}, text)."""
+    lines = text.split("\n")
+    if not lines or lines[0].strip() != "---":
+        return {}, text
+    meta: dict[str, Any] = {}
+    index = 1
+    while index < len(lines) and lines[index].strip() != "---":
+        raw = lines[index]
+        if not raw.strip() or raw.lstrip().startswith("#"):
+            index += 1
+            continue
+        if ":" not in raw:
+            raise SkillError(f"invalid frontmatter line: {raw!r}")
+        key, _, rest = raw.partition(":")
+        key = key.strip()
+        rest = rest.strip()
+        if not key:
+            raise SkillError(f"invalid frontmatter line: {raw!r}")
+        if rest in _BLOCK_MARKERS:
+            block, index = _read_block(
+                lines,
+                index + 1,
+                folded=rest.startswith(">"),
+                strip_chomp=rest.endswith("-"),
+            )
+            meta[key] = block
+        else:
+            meta[key] = _strip_quotes(rest)
+            index += 1
+    body = "\n".join(lines[index + 1 :]) if index < len(lines) else ""
+    return meta, body.lstrip("\n")
+
+
+def load_skill(path: str | os.PathLike[str]) -> Skill:
+    skill_path = Path(path)
+    try:
+        text = skill_path.read_text(encoding="utf-8")
+    except OSError as exc:
+        raise SkillError(f"cannot read skill {skill_path}: {exc}") from exc
+    meta, body = parse_frontmatter(text)
+    name = str(meta.get("name") or skill_path.parent.name).strip()
+    if not name:
+        raise SkillError(f"skill {skill_path} has no name")
+    description = str(meta.get("description") or "").strip()
+    return Skill(
+        name=name,
+        description=description,
+        body=body,
+        path=skill_path,
+        metadata=meta,
+    )
+
+
+def load_skills(root: str | os.PathLike[str]) -> list[Skill]:
+    base = Path(root).expanduser()
+    if not base.is_dir():
+        raise SkillError(f"skills directory not found: {base}")
+    skills: list[Skill] = []
+    for entry in sorted(base.iterdir(), key=lambda item: item.name):
+        if not entry.is_dir():
+            continue
+        skill_file = entry / "SKILL.md"
+        if skill_file.is_file():
+            skills.append(load_skill(skill_file))
+    return skills
+
+
+def default_skills_root(start: str | os.PathLike[str] | None = None) -> Path | None:
+    """Walk up from ``start`` (or cwd) to the nearest ``.opencode/skills``."""
+    here = Path(start).expanduser().resolve() if start else Path.cwd().resolve()
+    for candidate in (here, *here.parents):
+        probe = candidate / ".opencode" / "skills"
+        if probe.is_dir():
+            return probe
+    return None
+
+
+class SkillCatalog:
+    """Named skills with prompt rendering."""
+
+    def __init__(self, skills: list[Skill] | None = None) -> None:
+        self._by_name: dict[str, Skill] = {}
+        for skill in skills or []:
+            self._by_name[skill.name] = skill
+
+    @classmethod
+    def load(cls, root: str | os.PathLike[str]) -> SkillCatalog:
+        return cls(load_skills(root))
+
+    def names(self) -> list[str]:
+        return sorted(self._by_name)
+
+    def get(self, name: str) -> Skill:
+        if name not in self._by_name:
+            raise SkillError(f"unknown skill {name!r}; known: {', '.join(self.names())}")
+        return self._by_name[name]
+
+    def render(self, names: list[str]) -> str:
+        parts: list[str] = []
+        for name in names:
+            skill = self.get(name)
+            header = f"## skill: {skill.name}"
+            if skill.description:
+                header = f"{header}\n{skill.description}"
+            parts.append(f"{header}\n\n{skill.body}".rstrip())
+        return "\n\n".join(parts)
+
+
+__all__ = [
+    "Skill",
+    "SkillCatalog",
+    "SkillError",
+    "default_skills_root",
+    "load_skill",
+    "load_skills",
+    "parse_frontmatter",
+]

sid_harness/tools/subagents.py

@@ -0,0 +1,112 @@
+"""Subagent fan-out over the SAME native loop (SUB-56).
+
+Each sub-task is a bounded ``native_agent.run_native_agent`` run — the exact
+engine the main loop uses, driven by the caller's ``complete`` callback so every
+model call still settles through the gateway under the caller's key. There is no
+second engine and no second verify path; this module only schedules the same
+loop concurrently, with a bounded number in flight.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass, field
+from typing import Any
+
+from sid_harness.gateway import native_agent
+
+Complete = Callable[[list[dict[str, Any]], list[dict[str, Any]]], Awaitable[dict[str, Any]]]
+RunTests = Callable[[dict[str, str]], Awaitable[dict[str, Any]]]
+
+DEFAULT_MAX_CONCURRENCY = 4
+
+
+class SubagentError(ValueError):
+    """A subagent fan-out was requested with invalid inputs."""
+
+
+@dataclass
+class SubTask:
+    id: str
+    task: str
+    acceptance_criteria: list[str] = field(default_factory=list)
+    out_of_scope: list[str] = field(default_factory=list)
+    workspace_files: dict[str, str] | None = None
+
+
+def _summarize(subtask: SubTask, result: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "id": subtask.id,
+        "task": subtask.task,
+        "changed": result.get("changed", []),
+        "diff": result.get("diff"),
+        "final_response": result.get("final_response"),
+        "steps": result.get("steps"),
+        "tool_calls": result.get("tool_calls"),
+        "model": result.get("model"),
+    }
+
+
+async def fan_out(
+    *,
+    tasks: list[SubTask],
+    complete: Complete,
+    run_tests: RunTests,
+    workspace_files: dict[str, str],
+    max_concurrency: int = DEFAULT_MAX_CONCURRENCY,
+) -> list[dict[str, Any]]:
+    """Run each sub-task through the shared native loop, bounded concurrency.
+
+    Each sub-task gets its own copy of the workspace, so sub-runs cannot see
+    each other's edits; the caller's ``complete``/``run_tests`` callbacks keep
+    every model call and every test on the single gateway path.
+    """
+    if max_concurrency < 1:
+        raise SubagentError("max_concurrency must be at least 1")
+    if not tasks:
+        return []
+    seen: set[str] = set()
+    for subtask in tasks:
+        if subtask.id in seen:
+            raise SubagentError(f"duplicate sub-task id {subtask.id!r}")
+        seen.add(subtask.id)
+
+    semaphore = asyncio.Semaphore(max_concurrency)
+
+    async def run_one(subtask: SubTask) -> dict[str, Any]:
+        async with semaphore:
+            files = dict(
+                subtask.workspace_files
+                if subtask.workspace_files is not None
+                else workspace_files
+            )
+            result = await native_agent.run_native_agent(
+                task=subtask.task,
+                workspace_files=files,
+                acceptance_criteria=subtask.acceptance_criteria
+                or ["Complete the sub-task described in the goal."],
+                out_of_scope=subtask.out_of_scope,
+                test_argv=[],
+                complete=complete,
+                run_tests=run_tests,
+            )
+            return _summarize(subtask, result)
+
+    return list(await asyncio.gather(*(run_one(subtask) for subtask in tasks)))
+
+
+def fan_out_sync(**kwargs: Any) -> list[dict[str, Any]]:
+    """Blocking wrapper around ``fan_out`` for callers without an event loop."""
+    return asyncio.run(fan_out(**kwargs))
+
+
+__all__ = [
+    "Complete",
+    "DEFAULT_MAX_CONCURRENCY",
+    "RunTests",
+    "SubTask",
+    "SubagentError",
+    "fan_out",
+    "fan_out_sync",
+]

sid_harness/tui.py

@@ -0,0 +1,96 @@
+"""Minimal interactive terminal UI — the same engine as ``sid run``.
+
+Standard library only (``input()``); no curses dependency. Each entered task is
+one bounded run against the same directory, writing its own receipt.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from .cli import (
+    _approved_test_argv,
+    _build_registry,
+    _file_link,
+    _git_write_approver,
+    _resolve_bounds,
+)
+from .client import SIDClient, SIDClientError
+from .local_workspace import LocalWorkspaceError
+from .runner import RunError, execute_run
+from .session.bounds import BoundsError
+from .workspace import WorkspaceError
+
+
+def run_tui(args: argparse.Namespace) -> int:
+    try:
+        client = SIDClient(
+            base_url=args.base_url,
+            api_key=args.api_key,
+            routing_profile=args.routing_profile,
+        )
+        bounds = _resolve_bounds(args)
+        registry, closers = _build_registry(args)
+    except (SIDClientError, BoundsError) as exc:
+        print(f"BLOCKED: {exc}", file=sys.stderr)
+        return 2
+
+    print("sid-harness TUI — enter a task; an empty line or Ctrl-D exits.")
+    try:
+        while True:
+            try:
+                task = input("sid> ").strip()
+            except (EOFError, KeyboardInterrupt):
+                print()
+                return 0
+            if not task:
+                return 0
+            git_write = bool(getattr(args, "git_write", False))
+            try:
+                outcome = execute_run(
+                    task=task,
+                    directory=args.dir,
+                    client=client,
+                    model=args.model,
+                    criteria=args.criteria,
+                    out_of_scope=args.out_of_scope,
+                    test_argv=_approved_test_argv(args),
+                    max_tokens=args.max_tokens,
+                    reasoning_effort=args.reasoning_effort,
+                    verify=args.verify,
+                    write=getattr(args, "write", False),
+                    git_write=git_write,
+                    git_branch=getattr(args, "git_branch", None),
+                    git_message=getattr(args, "git_message", None),
+                    git_base=getattr(args, "git_base", None),
+                    git_pr=not getattr(args, "no_pr", False),
+                    git_approve=_git_write_approver(args) if git_write else None,
+                    receipt_path=args.receipt,
+                    context=getattr(args, "context", False),
+                    context_k=getattr(args, "context_k", 4),
+                    registry=registry,
+                    bounds=bounds,
+                    skills=getattr(args, "skills", None),
+                    skills_root=getattr(args, "skills_root", None),
+                    subagents=getattr(args, "subagent", None),
+                    plan=bool(getattr(args, "plan", False)),
+                    todos=getattr(args, "todo", None),
+                )
+            except (SIDClientError, WorkspaceError, LocalWorkspaceError, BoundsError, RunError) as exc:
+                print(f"BLOCKED: {exc}", file=sys.stderr)
+                continue
+            receipt = outcome.receipt
+            print(f"changed: {', '.join(receipt['changed']) or '(none)'}")
+            git_block = receipt.get("git_write")
+            if git_block:
+                print(
+                    f"git_write: {git_block.get('status')}  branch: "
+                    f"{git_block.get('branch')}  commit: {git_block.get('commit')}  "
+                    f"pr: {git_block.get('pr_url')}"
+                )
+            print(receipt["final_response"])
+            print(f"receipt: {_file_link(outcome.receipt_path)}")
+    finally:
+        for mcp in closers:
+            mcp.close()

sid_harness/workspace.py

@@ -0,0 +1,107 @@
+"""Load a local directory into the native loop's bounded in-memory workspace.
+
+v1 is READ-ONLY: it selects eligible text files from ``--dir`` and never writes
+back to the user's tree (local FS writes are SUB-54). Eligibility and the secret
+/ dependency / VCS denylist come from the shared ``native_agent._safe_path`` —
+the harness does not carry a second safety model.
+
+SUB-54 adds an optional ``ignore`` predicate (used by ``local_workspace`` for
+``.gitignore``); the walk, the shared denylist, and the bounds stay here so
+there is one selection path, not two.
+"""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+
+from .gateway import native_agent
+
+DEFAULT_MAX_FILES = native_agent.MAX_FILES
+DEFAULT_MAX_WORKSPACE_BYTES = native_agent.MAX_WORKSPACE_BYTES
+DEFAULT_MAX_FILE_BYTES = native_agent.MAX_FILE_BYTES
+
+# Pruned during the walk purely for speed; correctness still runs every file
+# through native_agent._safe_path, which enforces the same denylist.
+_SKIP_DIRS = {".git", "node_modules", ".venv", "venv", "__pycache__"}
+
+
+class WorkspaceError(RuntimeError):
+    """The local directory could not be loaded into a bounded workspace."""
+
+
+@dataclass(frozen=True)
+class WorkspaceSelection:
+    root: Path
+    files: dict[str, str]
+    skipped: list[tuple[str, str]]
+
+    @property
+    def total_bytes(self) -> int:
+        return sum(len(value.encode("utf-8")) for value in self.files.values())
+
+    def skipped_report(self) -> list[dict[str, str]]:
+        return [{"path": path, "reason": reason} for path, reason in self.skipped]
+
+
+def _iter_files(root: Path):
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = sorted(
+            name for name in dirnames if name.lower() not in _SKIP_DIRS
+        )
+        for name in sorted(filenames):
+            yield Path(dirpath) / name
+
+
+def load_workspace(
+    root: str | os.PathLike[str],
+    *,
+    max_files: int = DEFAULT_MAX_FILES,
+    max_bytes: int = DEFAULT_MAX_WORKSPACE_BYTES,
+    max_file_bytes: int = DEFAULT_MAX_FILE_BYTES,
+    ignore: Callable[[str], bool] | None = None,
+) -> WorkspaceSelection:
+    base = Path(root).expanduser().resolve()
+    if not base.is_dir():
+        raise WorkspaceError(f"--dir is not a directory: {base}")
+
+    files: dict[str, str] = {}
+    skipped: list[tuple[str, str]] = []
+    total = 0
+    for path in _iter_files(base):
+        rel = path.relative_to(base).as_posix()
+        try:
+            safe = native_agent._safe_path(rel)
+        except native_agent.NativeAgentError as exc:
+            skipped.append((rel, str(exc)))
+            continue
+        if ignore is not None and ignore(rel):
+            skipped.append((rel, "gitignored"))
+            continue
+        try:
+            size = path.stat().st_size
+        except OSError as exc:
+            skipped.append((rel, f"stat failed: {exc}"))
+            continue
+        if size > max_file_bytes:
+            skipped.append((rel, f"exceeds {max_file_bytes}-byte file limit"))
+            continue
+        if len(files) >= max_files:
+            skipped.append((rel, f"exceeds {max_files}-file workspace limit"))
+            continue
+        if total + size > max_bytes:
+            skipped.append((rel, f"exceeds {max_bytes}-byte workspace limit"))
+            continue
+        try:
+            text = path.read_text(encoding="utf-8")
+        except (OSError, UnicodeDecodeError) as exc:
+            skipped.append((rel, f"not readable utf-8 text: {exc}"))
+            continue
+        files[safe] = text
+        total += len(text.encode("utf-8"))
+
+    if not files:
+        raise WorkspaceError(f"no eligible text files found under {base}")
+    return WorkspaceSelection(root=base, files=files, skipped=skipped)

sid_harness-0.3.0.data/data/share/sid-harness/editors/README.md

@@ -0,0 +1,46 @@
+# SID editor integration
+
+A VS Code extension that drives the **same** SID engine as `sid run`, `sid tui`,
+and the Studio bridge. It does not carry a second loop, a second tool contract,
+or a second write path.
+
+## One install command
+
+```bash
+python -m sid_harness editor install
+# or, when the console script is on PATH:
+sid editor install
+```
+
+That copies `editors/vscode` into VS Code's extensions directory as
+`sid.sid-harness-<version>`. Reload VS Code to activate it. Set `SID_API_KEY` in
+the environment VS Code inherits (and optionally `sid.command` / `sid.testCommand`
+in Settings). Re-run with `--force` to refresh an existing install.
+
+## What the extension does
+
+| Command | Engine path |
+|---|---|
+| `SID: Open Coding Session` | `sid session start` (the one native loop) |
+| `SID: Show Proposed Diff` | the run receipt's `diff` |
+| `SID: Approve and Apply` | `sid apply --approve` (same `LocalWorkspace` + repo policy write path) |
+| `SID: Attach Selection as Context` | prepends the selection to the next session task |
+| `SID: Push Diagnostics to Session` | forwards VS Code diagnostics to `sid lsp` |
+
+The extension also starts `sid lsp --dir <workspace>` automatically. The server
+publishes real Python compiler diagnostics (`compile`) and ingests diagnostics
+from every other language server in VS Code through `sid/diagnostics`. It writes
+the merged feed to `<workspace>/.sid/diagnostics.json`; the loop reads that file
+and prepends a data-boundaried `COMPILER DIAGNOSTICS` block to the task, and the
+receipt records `diagnostics: {count, sources, path}`. Use `--no-diagnostics` to
+opt out for one run.
+
+## Install from a source checkout
+
+```bash
+cd infra/sid-harness
+python -m sid_harness editor install
+```
+
+`SID_HARNESS_EXTENSION_PATH` overrides extension discovery (for a packaged
+install). No `vsce`, npm dependency, or marketplace account is required.

sid_harness-0.3.0.data/data/share/sid-harness/editors/vscode/README.md

@@ -0,0 +1,32 @@
+# SID Harness for VS Code
+
+Drive SID's first-party coding loop without leaving the editor.
+
+## Install
+
+```bash
+python -m sid_harness editor install
+```
+
+Reload VS Code. The `SID:` commands appear in the Command Palette.
+
+## Requirements
+
+- The `sid` harness installed (`pip install sid-harness`) and on `PATH`, or set
+  `sid.command` to its executable.
+- `SID_API_KEY` in the environment VS Code inherits.
+- Open a folder; SID works on that folder only.
+
+## Commands
+
+- **SID: Open Coding Session** — runs `sid session start` and shows the result.
+- **SID: Show Proposed Diff** — opens the receipt's diff in a diff editor.
+- **SID: Approve and Apply** — asks for confirmation, then calls `sid apply`
+  (the same write path and repo policy as the CLI).
+- **SID: Attach Selection as Context** — includes the selected text in the next
+  session task.
+- **SID: Push Diagnostics to Session** — forwards VS Code diagnostics now.
+
+`sid lsp` starts with the extension (Settings → SID → `autoStartLsp`). It feeds
+compiler and language-server diagnostics into every session through the same
+loop the CLI and Studio use.