py-harness-cli 0.3.0__py3-none-any.whl

harness/act/code.py

@@ -0,0 +1,157 @@
+"""Pull a Python block out of a vibe draft and write or run it locally."""
+
+from __future__ import annotations
+
+import ast
+import re
+import subprocess
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+from harness.paths import SECRET_NAMES, TEXT_SUFFIXES, as_project_rel
+
+_FENCE = re.compile(r"```(?:python|py)?\s*\n(.*?)```", re.DOTALL | re.IGNORECASE)
+_SKIP_PARTS = {".git", ".venv", "node_modules", "adapters", "fused", "__pycache__"}
+MAX_FILE_CHARS = 3500
+# Small files are read whole so nearby constants (env, argv) stay in the quote.
+WHOLE_FILE_CHARS = 12_000
+# How much of the middle to keep when the task points at it.
+MIDDLE_WINDOW_CHARS = 1200
+
+
+def extract_python(text: str) -> str | None:
+    blocks = [m.group(1).strip() for m in _FENCE.finditer(text)]
+    if blocks:
+        return max(blocks, key=len)
+    stripped = text.strip()
+    if stripped.startswith(("import ", "from ", "def ", "class ", "#!/")):
+        return stripped
+    return None
+
+
+@dataclass(frozen=True)
+class RunResult:
+    code: int
+    stdout: str
+    stderr: str
+
+
+def write_and_run(
+    source: str,
+    dest: Path,
+    argv: list[str] | None = None,
+    *,
+    cwd: Path | None = None,
+    timeout: float = 12,
+    stdin: str | None = None,
+) -> RunResult:
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    dest.write_text(source.rstrip() + "\n", encoding="utf-8")
+    proc = subprocess.run(
+        [sys.executable, str(dest), *(argv or [])],
+        cwd=cwd or dest.parent,
+        capture_output=True,
+        text=True,
+        timeout=timeout,
+        check=False,
+        input=stdin,
+    )
+    return RunResult(proc.returncode, proc.stdout, proc.stderr)
+
+
+def resolve_project_file(project: Path, rel: str) -> Path:
+    root = project.resolve()
+    rel = as_project_rel(rel)
+    path = (root / rel).resolve() if not Path(rel).is_absolute() else Path(rel).resolve()
+    try:
+        path.relative_to(root)
+    except ValueError as exc:
+        raise ValueError(f"{path} is outside {root}") from exc
+    if any(part in _SKIP_PARTS for part in path.parts):
+        raise ValueError(f"refusing {path}")
+    if path.name.lower() in {item.lower() for item in SECRET_NAMES}:
+        raise ValueError(f"refusing secret filename {path.name}")
+    if path.suffix.lower() not in TEXT_SUFFIXES:
+        raise ValueError(
+            "only project text files: " + ", ".join(sorted(TEXT_SUFFIXES))
+        )
+    return path
+
+
+def _window_around(text: str, about: str, width: int) -> tuple[int, int] | None:
+    """Character range covering the first mention of `about`, or None."""
+    if not about:
+        return None
+    at = text.find(about)
+    if at < 0:
+        return None
+    half = width // 2
+    start = max(0, at - half)
+    return start, min(len(text), start + width)
+
+
+def read_project_file(
+    path: Path, *, limit: int = MAX_FILE_CHARS, about: str = ""
+) -> str:
+    """The file, or as much of it as fits, keeping the part that matters.
+
+    A file too long to send whole used to be sent as its head and its
+    tail, with the middle dropped. Asked to add a field to a dict two
+    thirds of the way down a 13,476-character file, the model was handed
+    3,500 characters from the top and 800 from the bottom — and the dict
+    was in neither. It then invented a `Find:` line that was not in the
+    file, was refused, and sent it again.
+
+    `about` names what the task is for. When the text contains it, a
+    window around it is kept as well, so the part being changed is one
+    of the parts that arrives.
+    """
+    text = path.read_text(encoding="utf-8")
+    cap = WHOLE_FILE_CHARS if limit == MAX_FILE_CHARS else limit
+    if len(text) <= cap:
+        return text
+    tail = min(800, max(0, len(text) - limit))
+    omitted = len(text) - limit - tail
+    if omitted <= 0:
+        return text
+    window = _window_around(text, about, MIDDLE_WINDOW_CHARS)
+    if window is None or window[0] < limit:
+        # Either nothing to centre on, or it is inside the head already.
+        return (
+            text[:limit]
+            + f"\n# … truncated {omitted} chars …\n"
+            + text[-tail:]
+        )
+    start, end = window
+    before = start - limit
+    after = max(0, len(text) - tail - end)
+    return (
+        text[:limit]
+        + f"\n# … truncated {before} chars …\n"
+        + text[start:end]
+        + f"\n# … truncated {after} chars …\n"
+        + text[-tail:]
+    )
+
+def apply_source(path: Path, source: str, *, original: str) -> None:
+    if not source.strip():
+        raise ValueError("empty draft")
+    if original and len(source) < max(40, (len(original) * 2) // 3):
+        raise ValueError(
+            f"draft is too short ({len(source)} chars vs {len(original)}) — "
+            "use Action: patch for a small change"
+        )
+    if path.suffix in {".py", ".pyi"}:
+        try:
+            ast.parse(source)
+        except SyntaxError as exc:
+            raise ValueError(
+                f"syntax error: {exc} — file not written. "
+                "Use a full unique line for Find: (not a prefix of def …)"
+            ) from exc
+    bak = path.with_suffix(path.suffix + ".bak")
+    if path.is_file():
+        bak.write_text(path.read_text(encoding="utf-8"), encoding="utf-8")
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(source.rstrip() + "\n", encoding="utf-8")

harness/act/gate.py

@@ -0,0 +1,229 @@
+"""May this draft be written? One question, asked before any file changes.
+
+The tools carry a change out. This decides whether it may happen: a
+module that already exists under another name, an import with nothing
+behind it, a style rule the project keeps, a definition already in the
+file. Keeping it apart from `tools` means the answer to "where are the
+tools" is one file, and so is the answer to "what stops a bad write".
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+
+import re
+from pathlib import Path
+
+from harness.paths import rel_posix
+from harness.skillkit.refuse_change import (
+    refuse_add_opens_file,
+    refuse_layout,
+    refuse_opaque_module,
+    refuse_opaque_names,
+    refuse_ops_draft,
+    refuse_platform_draft,
+    refuse_rename_incomplete,
+    refuse_shell_fetch,
+    refuse_stdlib_shadow,
+    refuse_stub_body,
+    refuse_test_in_impl,
+    refuse_undefined_draft,
+    refuse_weak_test,
+)
+
+
+
+_TEST_METH = re.compile(r"def\s+(test_\w+)\s*\(")
+_ASSERT_CALL = re.compile(r"assertEqual\s*\(\s*([A-Za-z_]\w+)\s*\(")
+_IMPORT_LINE = re.compile(r"^(from\s+\S+\s+import\s+)(.+)$")
+
+
+def _add_import_symbol(text: str, name: str) -> str:
+    if not name or name in {"self", "True", "False", "None"}:
+        return text
+    for line in text.splitlines():
+        match = _IMPORT_LINE.match(line)
+        if not match:
+            continue
+        imported = {part.strip() for part in match.group(2).split(",")}
+        if name in imported:
+            return text
+        if any(skip in line for skip in ("unittest", "pathlib", "typing")):
+            continue
+        return text.replace(line, f"{match.group(1)}{match.group(2).rstrip()}, {name}", 1)
+    return text
+
+
+def _called_name(original: str, append: str) -> str:
+    """The function the new test needs imported.
+
+    It used to be read out of `assertEqual(multiply(...))`. The change rules
+    ask for the opposite shape — `got = multiply(...)`, then assert `got` —
+    so following them meant the import was never added and the suite broke.
+    Reading the names the new test leaves unbound covers both shapes.
+    """
+    from harness.scan.names import new_undefined
+
+    for name in new_undefined(original, original.rstrip() + "\n\n" + append):
+        return name
+    match = _ASSERT_CALL.search(append)
+    return match.group(1) if match else ""
+
+
+def repair_unittest_append(original: str, append: str) -> str | None:
+    """8B Append: often lands after if __name__ and skips the import."""
+    if "def test_" not in append:
+        return None
+    if "TestCase" not in original and "unittest" not in original:
+        return None
+    meth = _TEST_METH.search(append)
+    if not meth or re.search(rf"def\s+{re.escape(meth.group(1))}\s*\(", original):
+        return None
+    lines = append.strip("\n").splitlines()
+    while lines and not lines[0].strip():
+        lines.pop(0)
+    if not lines:
+        return None
+    base = len(lines[0]) - len(lines[0].lstrip())
+    dedented = "\n".join(
+        line[base:] if len(line) >= base else line.lstrip() for line in lines
+    )
+    method = "    " + dedented.replace("\n", "\n    ")
+    text = _add_import_symbol(original, _called_name(original, append))
+    marker = "\nif __name__"
+    if marker in text:
+        return text.replace(marker, "\n" + method + "\n" + marker, 1)
+    return text.rstrip() + "\n\n" + method + "\n"
+
+
+def refuse_duplicate_module(project: Path, rel: str, original: str) -> str:
+    """Refuse a new file that repeats a module this project already has.
+
+    Watched a run write the same function to `pkg/orders.py` and then
+    `src/orders.py`. Two modules with one name is worse than either: an
+    import finds whichever comes first on the path, and the other rots.
+    """
+    if original.strip():
+        return ""
+    from harness.paths import as_project_rel, rel_posix
+
+    wanted = Path(as_project_rel(rel))
+    if wanted.name.startswith("test_") or "tests" in wanted.parts:
+        return ""
+    root = Path(project).resolve()
+    for existing in sorted(root.rglob(f"{wanted.stem}.py")):
+        if any(part in {".git", ".venv", "__pycache__"} for part in existing.parts):
+            continue
+        found = rel_posix(existing, root)
+        if found != wanted.as_posix():
+            return (
+                f"{found} is already this project's {wanted.stem} module. "
+                f"Action: patch Path: {found} Append: the new function"
+            )
+    return ""
+
+
+def refuse_missing_import_target(project: Path, rel: str, draft: str) -> str:
+    """Refuse a file importing a name this project has not defined yet.
+
+    Asked to create a module and a test for it, the model wrote only the
+    test, importing a function nobody had written. That reads as valid
+    Python — the import binds the name — and fails when the suite runs. The
+    function has to exist first.
+    """
+    from harness.scan.names import missing_import_targets
+
+    missing = missing_import_targets(project, draft)
+    if not missing:
+        return ""
+    module, name = missing[0]
+    return (
+        f"{module} does not define {name} yet. Write the function first: "
+        f"Action: patch Path: {module.replace('.', '/')}.py Append: def {name}(...)"
+    )
+
+
+@dataclass(frozen=True)
+class ProposedChange:
+    """One change the model has proposed, and what it is judged on.
+
+    Fields:
+        task: what the user asked for, in their own words.
+        rel: the file the change targets, project-relative.
+        original: the file as it stands, or "" when it is new.
+        draft: the file as this change would leave it.
+        fragment: only the part being added, when the change appends.
+            Judging a whole file as one test turns a single inline
+            assertion anywhere into a refusal for everything in it.
+    """
+
+    task: str
+    rel: str
+    original: str
+    draft: str
+    fragment: str = ""
+
+
+# Every rule a proposed change is put through, in the order they run.
+# This was thirty lines of `blocked = rule(...); if blocked: return
+# blocked`, eleven times over, which hid both the order and the fact that
+# a new rule has to be added to it. A rule written and not listed here
+# does nothing, and a test below checks for exactly that.
+CHANGE_RULES: tuple[tuple[str, Callable[[ProposedChange], str]], ...] = (
+    ("stdlib shadow", lambda c: refuse_stdlib_shadow(c.rel, c.original)),
+    ("layout", lambda c: refuse_layout(c.rel, c.original, c.draft)),
+    ("opens a file", lambda c: refuse_add_opens_file(c.task, c.rel, c.draft)),
+    ("shell fetch", lambda c: refuse_shell_fetch(c.rel, c.draft)),
+    ("platform draft", lambda c: refuse_platform_draft(c.rel, c.draft)),
+    ("operations draft", lambda c: refuse_ops_draft(c.rel, c.draft)),
+    ("test in implementation", lambda c: refuse_test_in_impl(c.rel, c.draft)),
+    ("stub body", lambda c: refuse_stub_body(c.task, c.rel, c.draft)),
+    (
+        "undefined name",
+        lambda c: refuse_undefined_draft(c.task, c.rel, c.original, c.draft),
+    ),
+    (
+        "half a rename",
+        lambda c: refuse_rename_incomplete(c.task, c.rel, c.draft),
+    ),
+    ("weak test", lambda c: refuse_weak_test(c.rel, c.fragment or c.draft)),
+    ("opaque names", lambda c: refuse_opaque_names(c.draft, c.task)),
+    ("opaque module", lambda c: refuse_opaque_module(c.rel, c.original)),
+)
+
+
+def first_refusal(
+    task: str, rel: str, original: str, draft: str, fragment: str = ""
+) -> str:
+    """The first refusal a proposed change earns, or "" if it earns none."""
+    change = ProposedChange(task, rel, original, draft, fragment)
+    for _name, rule in CHANGE_RULES:
+        refusal = rule(change)
+        if refusal:
+            return refusal
+    return ""
+
+
+def already_defined(original: str, append: str, rel: str) -> str:
+    """Refuse appending a definition the file already has, or "".
+
+    Only test methods were checked, so an ordinary function could be
+    added twice: a live run appended `def slugify` to the same file on
+    two separate turns and left both in place.
+    """
+    meth = _TEST_METH.search(append)
+    if meth and re.search(rf"def\s+{re.escape(meth.group(1))}\s*\(", original):
+        return (
+            f"{meth.group(1)} already exists. Action: done Summary: "
+            "that function is already covered."
+        )
+    for name in re.findall(r"(?m)^def\s+(\w+)\s*\(", append):
+        if re.search(rf"(?m)^def\s+{re.escape(name)}\s*\(", original):
+            return (
+                f"{name} is already defined in {rel}. Action: done "
+                "Summary: say what it does, or patch the existing one."
+            )
+    return ""
+
+

harness/act/parse.py

@@ -0,0 +1,247 @@
+"""Parse one agent turn. Deterministic. No model."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+from harness.act.code import extract_python
+
+# A chat model decorates the line the harness is trying to read. It
+# emboldens the label (`**Action:** patch`), numbers its steps
+# (`1. Action: patch`), or explains the verb in the same breath
+# (`Action: patch to add slugify`). Local weights write the bare line,
+# so an anchored pattern was enough until the harness was pointed at a
+# model it does not run itself — and then the turn parsed to nothing.
+#
+# Only `*`, `#`, `>` and list numbering are allowed as decoration, and
+# never `_`, because a value may legitimately start with one and
+# `Name: _helpers` must keep its underscore.
+_DECOR = r"[ \t>*#-]{0,6}(?:\d{1,2}[.)][ \t]*)?[ \t>*]{0,4}"
+_AFTER_KEY = r"[* \t]*"
+
+# Hyphens are allowed so a skill name works as an action: every kit
+# skill is hyphenated, and `\w+` could not match one. There is no `$`:
+# anything after the verb is the model thinking aloud, and an unknown
+# verb is still rejected by KNOWN_ACTIONS below.
+_ACTION = re.compile(
+    rf"^{_DECOR}Action:{_AFTER_KEY}([\w-]+)", re.MULTILINE | re.IGNORECASE
+)
+# Every verb the loop can carry out. A model that writes `Action: find`
+# has put a field name on the Action line; that block is skipped so the
+# turn is not spent on an unknown verb.
+KNOWN_ACTIONS = frozenset(
+    {
+        "glob", "grep", "read", "edit", "patch", "run", "map", "plan",
+        "skill", "locate", "layout", "ask", "done",
+        "issue", "branch", "commit", "push", "pr", "merge",
+    }
+)
+_FIELD = re.compile(
+    rf"^{_DECOR}(Path|File|Query|Pattern|Argv|Summary|Scope|Name|Number|Title):"
+    rf"{_AFTER_KEY}(.+?)[ \t*]*$",
+    re.MULTILINE,
+)
+_STOP = re.compile(
+    rf"^{_DECOR}(Action|Path|File|Query|Pattern|Argv|Summary|Scope|Name|Number"
+    rf"|Title|Body|Find|Replace|Append|Add):{_AFTER_KEY}",
+    re.IGNORECASE,
+)
+
+
+# A model that answers in chat wraps code in a fence. Local weights
+# happen not to; every hosted one does, so this only bites the moment
+# the harness is pointed at a model it does not run itself.
+# A fence marker alone on the last line, with or without a language:
+# a whole-reply fence closing, or a second block the model opened
+# and never filled. Either way it is not Python.
+_CLOSING = re.compile(r"^[ \t]*```[\w+-]*[ \t]*$")
+_FENCED = re.compile(
+    r"^[^\S\n]*```[\w+-]*[^\S\n]*\n(.*?)\n[^\S\n]*```",
+    re.DOTALL,
+)
+
+
+def unfenced(body: str) -> str:
+    """The code inside a markdown fence, or the text unchanged.
+
+    An `Append:` body arriving as ```python … ``` used to reach the file
+    with the backticks still on it. What landed was a SyntaxError, and
+    by its third turn a hosted 32B was reporting an unterminated string
+    literal in a file it had broken itself. Nine of ten runs then spent
+    the whole budget writing nothing that would load.
+
+    Anything after the closing fence goes too. A model that signs off
+    with "That should do it." puts that sentence inside the fence's
+    file otherwise, which fails exactly the same way the backticks do.
+    """
+    found = _FENCED.match(body)
+    if found:
+        return found.group(1)
+    # The model fenced its whole reply rather than the code, so the
+    # block never opened with a fence and the closing one is left
+    # trailing on the end of it. That reaches the file and is the same
+    # SyntaxError, arriving by a different route.
+    lines = body.splitlines()
+    if lines and _CLOSING.match(lines[-1]):
+        return "\n".join(lines[:-1]).rstrip()
+    return body
+
+
+def _block(text: str, key: str) -> str:
+    match = re.search(
+        rf"^{_DECOR}{key}:{_AFTER_KEY}(.*?)[ \t*]*$",
+        text,
+        re.MULTILINE | re.IGNORECASE,
+    )
+    if not match:
+        return ""
+    lines: list[str] = []
+    first = match.group(1).rstrip()
+    if first:
+        lines.append(first)
+    for line in text[match.end() :].lstrip("\n").splitlines():
+        if _STOP.match(line):
+            break
+        lines.append(line.rstrip())
+    return "\n".join(lines).rstrip()
+
+
+@dataclass(frozen=True)
+class AgentTurn:
+    action: str
+    path: str = ""
+    query: str = ""
+    pattern: str = ""
+    argv: tuple[str, ...] = ()
+    summary: str = ""
+    source: str | None = None
+    find: str = ""
+    replace: str = ""
+    scope: str = ""
+    name: str = ""
+    append: str = ""
+    number: str = ""
+    title: str = ""
+    body: str = ""
+
+
+_PREFERRED_WRITE = ("patch", "edit", "run", "locate", "done")
+_PREFERRED_QUESTION = ("done", "locate", "grep", "read")
+_PREFERRED_SHIP = (
+    "issue",
+    "branch",
+    "commit",
+    "push",
+    "pr",
+    "merge",
+    "patch",
+    "done",
+)
+
+
+# A field name written on the Action line. The model means the action that
+# field belongs to, and every such turn was spent on "unknown Action".
+_FIELD_AS_ACTION = {
+    "append": "patch",
+    "add": "patch",
+    "find": "patch",
+    "replace": "patch",
+    "summary": "done",
+}
+
+
+def _body_after_action(text: str) -> str:
+    """The code below the Action line, with the field lines left out.
+
+    `Action: append` is followed by `Path:` and then the function. Stopping
+    at the first field line returned nothing, so the turn was spent for no
+    reason.
+    """
+    match = _ACTION.search(text)
+    if not match:
+        return ""
+    lines = [
+        line.rstrip()
+        for line in text[match.end():].splitlines()
+        if not _STOP.match(line)
+    ]
+    while lines and not lines[0].strip():
+        lines.pop(0)
+    return "\n".join(lines).strip("\n")
+
+
+def parse_turn(text: str) -> AgentTurn | None:
+    match = _ACTION.search(text)
+    if not match:
+        return None
+    action = match.group(1).lower()
+    body_as_append = ""
+    if action in _FIELD_AS_ACTION and action not in KNOWN_ACTIONS:
+        if action in {"append", "add"}:
+            body_as_append = _body_after_action(text)
+        action = _FIELD_AS_ACTION[action]
+    fields = {m.group(1).lower(): m.group(2).strip() for m in _FIELD.finditer(text)}
+    argv = tuple(part for part in fields.get("argv", "").split() if part)
+    source = extract_python(text) if action == "edit" else None
+    if action == "edit" and not source:
+        extra = _block(text, "Append") or _block(text, "Add")
+        if extra:
+            source = extra
+    return AgentTurn(
+        action=action,
+        path=fields.get("path") or fields.get("file", ""),
+        query=fields.get("query", ""),
+        pattern=fields.get("pattern", ""),
+        argv=argv,
+        summary=fields.get("summary", ""),
+        source=source,
+        find=unfenced(_block(text, "Find")),
+        replace=unfenced(_block(text, "Replace")),
+        scope=fields.get("scope", ""),
+        name=fields.get("name", ""),
+        append=unfenced(
+            _block(text, "Append") or _block(text, "Add") or body_as_append
+        ),
+        number=fields.get("number", ""),
+        title=fields.get("title", ""),
+        body=_block(text, "Body"),
+    )
+
+
+def _is_skill_name(verb: str) -> bool:
+    """`Action: write-tests` names a skill, which the loop loads."""
+    return "-" in verb or "_" in verb
+
+
+def parse_turn_smart(
+    text: str, *, question: bool = False, ship: bool = False
+) -> AgentTurn | None:
+    """Small models paste the Action menu. Pick one block by task kind."""
+    matches = [
+        match
+        for match in _ACTION.finditer(text)
+        if match.group(1).lower() in KNOWN_ACTIONS or _is_skill_name(match.group(1))
+    ]
+    if not matches:
+        return parse_turn(text)
+    if len(matches) == 1:
+        return parse_turn(text[matches[0].start() :])
+    if question:
+        prefer = _PREFERRED_QUESTION
+    elif ship:
+        prefer = _PREFERRED_SHIP
+    else:
+        prefer = _PREFERRED_WRITE
+    chosen = matches[0]
+    for match in matches:
+        if match.group(1).lower() in prefer:
+            chosen = match
+            break
+    start = chosen.start()
+    end = len(text)
+    for match in matches:
+        if match.start() > start:
+            end = match.start()
+            break
+    return parse_turn(text[start:end])