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

finetune/splits.py

@@ -0,0 +1,54 @@
+"""Turn (user, assistant) pairs into mlx-lm chat JSONL splits."""
+
+from __future__ import annotations
+
+import json
+import random
+from pathlib import Path
+
+
+def chat_row(system: str, user: str, assistant: str) -> dict:
+    return {
+        "messages": [
+            {"role": "system", "content": system},
+            {"role": "user", "content": user},
+            {"role": "assistant", "content": assistant},
+        ]
+    }
+
+
+def write_splits(
+    pairs: list[tuple[str, str]],
+    system: str,
+    dest: Path,
+    *,
+    seed: int = 7,
+    valid_frac: float = 0.12,
+    test_frac: float = 0.12,
+) -> dict[str, int]:
+    if len(pairs) < 12:
+        raise ValueError(f"need at least 12 pairs, got {len(pairs)}")
+
+    rng = random.Random(seed)
+    shuffled = list(pairs)
+    rng.shuffle(shuffled)
+
+    n = len(shuffled)
+    n_test = max(2, int(n * test_frac))
+    n_valid = max(2, int(n * valid_frac))
+    test = shuffled[:n_test]
+    valid = shuffled[n_test : n_test + n_valid]
+    train = shuffled[n_test + n_valid :]
+    if not train:
+        raise ValueError("train split is empty — add more examples")
+
+    dest.mkdir(parents=True, exist_ok=True)
+    counts = {}
+    for name, rows in (("train", train), ("valid", valid), ("test", test)):
+        path = dest / f"{name}.jsonl"
+        with path.open("w", encoding="utf-8") as fh:
+            for user, assistant in rows:
+                fh.write(json.dumps(chat_row(system, user, assistant), ensure_ascii=False))
+                fh.write("\n")
+        counts[name] = len(rows)
+    return counts

finetune/systems.py

@@ -0,0 +1,9 @@
+"""System prompt baked into every training example."""
+
+PYTHON_VIBE_SYSTEM = """\
+You are a Python vibe-coding pair.
+
+Ship working Python 3.12+ first. Prefer the standard library. Short note, \
+then the code. No essays, no extra abstractions, no 'as an AI' preamble. \
+Type-hint public functions. Skip comments that restate the next line.
+"""

harness/__init__.py

@@ -0,0 +1,42 @@
+"""py-harness: a deterministic harness around a small local model.
+
+The model drafts; the harness decides what ships.
+
+    from harness import Agent, AgentOptions
+
+    agent = Agent(AgentOptions(project=Path("~/app"), scope="src"))
+    result = agent.run("add multiply(a, b) and a unit test")
+    print(result.summary, result.writes)
+
+Read-only is one flag:
+
+    AgentOptions(project=..., allow_writes=False)
+
+Command line and HTTP are the same object:
+
+    python -m harness run ~/app "fix the NameError"
+    python -m harness serve --project ~/app
+"""
+
+from harness.agent import Agent, AgentOptions, AgentResult, Question, Step
+
+# The one thing the command line needs from the model package. Going
+# through here keeps that package's shape private: the CLI and the
+# server do not import harness.model.* directly.
+from harness.model.route import route_advice
+from harness.guard.python_vibe import PythonVibeGuard
+from harness.guard.run import complete
+from harness.guard.types import Finding, Outcome
+
+__all__ = [
+    "Agent",
+    "AgentOptions",
+    "route_advice",
+    "AgentResult",
+    "Question",
+    "Step",
+    "PythonVibeGuard",
+    "complete",
+    "Finding",
+    "Outcome",
+]

harness/__main__.py

@@ -0,0 +1,8 @@
+"""`python -m harness`."""
+
+import sys
+
+from harness.cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

harness/act/__init__.py

@@ -0,0 +1,6 @@
+"""Read a proposed action and carry it out on the file system.
+
+Parses one action from the model's reply and provides the operations it can
+request: search, read, patch, replace and run. All file writes pass through
+the path restriction and backup in `harness.act.code`.
+"""

harness/act/autofix/__init__.py

@@ -0,0 +1,110 @@
+"""Repairs the harness can make on its own, before any model turn.
+
+One file of nine hundred lines held six separate jobs: repairing a
+name, resolving a conflict, writing a test, adding a function, adding
+an import, and the pass that runs them in order. They are six modules
+now, and this is the door on to them.
+"""
+
+from __future__ import annotations
+
+from harness.act.autofix.names import (
+    UnboundTypo,
+    _all_defined_names,
+    _bound_in_scope,
+    _class_body_ids,
+    _is_typo,
+    _rename_name_tokens,
+    apply_person_bind,
+    apply_typo_fixes,
+    apply_zero_return_sum,
+    levenshtein,
+    replacement_from_answer,
+    typo_pairs,
+    unbound_typo,
+)
+from harness.act.autofix.conflicts import (
+    CONFLICT_END,
+    CONFLICT_MID,
+    CONFLICT_START,
+    _resolve_conflict,
+    conflict_blocks,
+    looks_like_conflict,
+    resolve_keeping_both,
+)
+from harness.act.autofix.cover import (
+    MIN_SHARE_REACHED,
+    _add_import_symbol,
+    _append_class_method,
+    _body_lines,
+    _candidates,
+    _find_callable,
+    _imports,
+    _lines_reached,
+    _sample_values,
+    _test_file_for,
+    apply_cover_test,
+)
+from harness.act.autofix.additions import (
+    _COUNT_NAME,
+    _assign_names_for_module,
+    _impl_py,
+    _top_level_names,
+    append_instead_of_replacing,
+    apply_add_function,
+    apply_function_rename,
+    usual_first_arg,
+)
+from harness.act.autofix.missing_imports import (
+    apply_missing_imports,
+)
+from harness.act.autofix.moves import (
+    apply_file_move,
+    apply_function_move,
+    module_name,
+    move_targets,
+)
+from harness.act.autofix.mechanical import (
+    apply_mechanical,
+)
+from harness.act.autofix.scaffold import (
+    apply_cli_mock_test,
+    apply_home_config,
+    apply_list_page_query,
+    apply_package_scaffold,
+)
+
+__all__ = [
+    "apply_file_move",
+    "move_targets",
+    "CONFLICT_END",
+    "CONFLICT_MID",
+    "CONFLICT_START",
+    "MIN_SHARE_REACHED",
+    "UnboundTypo",
+    "_is_typo",
+    "_rename_name_tokens",
+    "_sample_values",
+    "_test_file_for",
+    "append_instead_of_replacing",
+    "apply_add_function",
+    "apply_cover_test",
+    "apply_function_rename",
+    "apply_cli_mock_test",
+    "apply_home_config",
+    "apply_list_page_query",
+    "apply_mechanical",
+    "apply_package_scaffold",
+    "apply_missing_imports",
+    "apply_person_bind",
+    "apply_typo_fixes",
+    "apply_zero_return_sum",
+    "conflict_blocks",
+    "levenshtein",
+    "looks_like_conflict",
+    "replacement_from_answer",
+    "resolve_keeping_both",
+    "typo_pairs",
+    "unbound_typo",
+    "usual_first_arg",
+]

harness/act/autofix/additions.py

@@ -0,0 +1,217 @@
+"""Adding a small function, and appending rather than replacing."""
+
+from __future__ import annotations
+
+"""Mechanical fixes the 8B fails to express. Deterministic. No model.
+
+Live 8B (29 Aug 2026): left `subtotal` unbound after a NameError task, and
+spent twelve `Find:` turns that never matched `def calc(x: int, ...)`.
+Those are compiler jobs. The harness does them, then runs the suite,
+before the first generate. A green suite ends the run without a model.
+"""
+import ast
+import re
+from pathlib import Path
+from harness.act.code import apply_source
+from harness.task import (
+    looks_like_add_feature,
+    named_project_file,
+    question_symbol,
+)
+
+
+
+
+def _top_level_names(tree: ast.Module) -> set[str]:
+    """Names a module defines at its top level."""
+    found: set[str] = set()
+    for node in tree.body:
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+            found.add(node.name)
+        else:
+            found.update(_assign_names_for_module(node))
+    return found
+
+
+def _assign_names_for_module(node: ast.AST) -> set[str]:
+    if isinstance(node, ast.Assign):
+        names: set[str] = set()
+        for target in node.targets:
+            if isinstance(target, ast.Name):
+                names.add(target.id)
+        return names
+    if isinstance(node, ast.AnnAssign) and isinstance(node.target, ast.Name):
+        return {node.target.id}
+    if isinstance(node, (ast.Import, ast.ImportFrom)):
+        return {alias.asname or alias.name.split(".")[0] for alias in node.names}
+    return set()
+
+
+def append_instead_of_replacing(original: str, draft: str) -> str:
+    """Merge a short draft of new definitions onto the file, or "".
+
+    `edit` replaces a whole file, so a correct new function sent on its
+    own is shorter than what it would replace and is refused for that.
+    A live 8B wrote a working `slugify`, had it thrown away twice — once
+    for a missing fence, then for being 89 characters against 276 — and
+    spent the rest of its budget sending the same correct code back.
+
+    Appending is what it meant, and it is safe: nothing in the file is
+    removed. Only when every top-level name in the draft is new, so this
+    cannot quietly drop a rewrite of something that already exists.
+    """
+    if not original.strip() or not draft.strip():
+        return ""
+    if len(draft) >= max(40, (len(original) * 2) // 3):
+        return ""  # long enough to be a real rewrite; leave it alone
+    try:
+        first, second = ast.parse(original), ast.parse(draft)
+    except (SyntaxError, ValueError):
+        return ""
+    allowed = (
+        ast.FunctionDef,
+        ast.AsyncFunctionDef,
+        ast.ClassDef,
+        ast.Import,
+        ast.ImportFrom,
+    )
+    if not second.body or not all(isinstance(n, allowed) for n in second.body):
+        return ""
+    added = _top_level_names(second)
+    if not added or added & _top_level_names(first):
+        return ""
+    merged = original.rstrip() + "\n\n\n" + draft.strip() + "\n"
+    try:
+        ast.parse(merged)
+    except SyntaxError:
+        return ""
+    return merged
+
+
+def apply_function_rename(source: str, old: str, new: str) -> str:
+    """Rename one `def old` and `old(` calls. Keep the rest of the signature.
+
+    Matching requires a call shape, so prose that merely mentions the name
+    is left alone. Text inside a string that looks like a call is rewritten
+    too; for a message naming the function that is usually wanted, and it
+    is the same on every supported Python version, which a token-based
+    rename would not be.
+    """
+    if not old or not new or old == new:
+        return source
+    if not re.search(rf"^def {re.escape(old)}\b", source, re.MULTILINE):
+        return source
+    if re.search(rf"^def {re.escape(new)}\b", source, re.MULTILINE):
+        return source
+    text = re.sub(
+        rf"^def {re.escape(old)}\b",
+        f"def {new}",
+        source,
+        count=1,
+        flags=re.MULTILINE,
+    )
+    return re.sub(rf"\b{re.escape(old)}\s*\(", f"{new}(", text)
+
+
+def _impl_py(project: Path) -> list[tuple[Path, str]]:
+    """First-party Python files that are not tests, with project-relative paths."""
+    from harness.scan.project_brief import iter_text_files
+
+    root = Path(project).resolve()
+    found: list[tuple[Path, str]] = []
+    for path, _size in iter_text_files(root):
+        if path.suffix != ".py":
+            continue
+        rel = path.resolve().relative_to(root).as_posix()
+        if "test" in rel.lower():
+            continue
+        found.append((path, rel))
+    return found
+
+
+_COUNT_NAME = re.compile(r"(lines?|count|^n_)", re.I)
+
+
+def usual_first_arg(source: str) -> tuple[str, str]:
+    """Most common first parameter and its annotation, or empty strings."""
+    found: list[tuple[str, str]] = []
+    try:
+        tree = ast.parse(source)
+    except (SyntaxError, ValueError):
+        return "", ""
+    for node in tree.body:
+        if not isinstance(node, ast.FunctionDef):
+            continue
+        args = [a for a in node.args.args if a.arg not in {"self", "cls"}]
+        if not args:
+            continue
+        hint = ast.unparse(args[0].annotation) if args[0].annotation else ""
+        found.append((args[0].arg, hint))
+    if not found:
+        return "", ""
+    name = max(set(item[0] for item in found), key=lambda n: sum(1 for a, _h in found if a == n))
+    hints = [hint for arg, hint in found if arg == name and hint]
+    hint = max(set(hints), key=hints.count) if hints else "list[int]"
+    return name, hint
+
+
+def _spells_another_argument(task: str, symbol: str, neighbor: str) -> bool:
+    """True when the task wrote the signature and it is not this one.
+
+    `word_count(text)` says the argument is text. Guessing `prices` from
+    the neighbours then writes `return len(prices)`, a word counter that
+    counts list items — and this path writes the test too, so the suite
+    agrees with it and the run reports success having done the wrong
+    thing in zero model steps.
+
+    A task that spells its own arguments has already answered the
+    question this function guesses at, so when the two disagree there is
+    nothing to add mechanically and the model should do the work.
+    """
+    spelled = re.search(rf"\b{re.escape(symbol)}\s*\(([^)]*)\)", task)
+    if not spelled:
+        return False
+    written = [a.strip().split(":")[0].strip() for a in spelled.group(1).split(",")]
+    written = [a for a in written if a]
+    return bool(written) and neighbor not in written
+
+
+def apply_add_function(project: Path, task: str, *, write: bool = True) -> str:
+    """Add a count function that matches its neighbors. Empty if unsure.
+
+    Live 8B read `add a function total_lines` as a file-line counter and
+    opened a path. In an orders module the usual argument is `prices`.
+    """
+    if not looks_like_add_feature(task):
+        return ""
+    symbol = question_symbol(task)
+    if not symbol or not _COUNT_NAME.search(symbol):
+        return ""
+    from harness.skillkit.target import pick_module
+
+    dest = named_project_file(task, project) or pick_module(project, "", task)
+    if not dest:
+        return ""
+    path = Path(project) / dest
+    if not path.is_file():
+        return ""
+    try:
+        body = path.read_text(encoding="utf-8")
+    except OSError:
+        return ""
+    if re.search(rf"^def {re.escape(symbol)}\b", body, re.MULTILINE):
+        return ""
+    name, hint = usual_first_arg(body)
+    if name != "prices" or "list" not in hint.lower():
+        return ""
+    if _spells_another_argument(task, symbol, name):
+        return ""
+    stub = f"\n\ndef {symbol}({name}: {hint}) -> int:\n    return len({name})\n"
+    merged = body.rstrip() + stub
+    try:
+        ast.parse(merged)
+    except SyntaxError:
+        return ""
+    if write:
+        apply_source(path, merged, original=body)
+    return f"added def {symbol}({name}) in {dest}"

harness/act/autofix/conflicts.py

@@ -0,0 +1,124 @@
+"""Resolving a merge conflict where keeping both sides is safe."""
+
+from __future__ import annotations
+
+"""Mechanical fixes the 8B fails to express. Deterministic. No model.
+
+Live 8B (29 Aug 2026): left `subtotal` unbound after a NameError task, and
+spent twelve `Find:` turns that never matched `def calc(x: int, ...)`.
+Those are compiler jobs. The harness does them, then runs the suite,
+before the first generate. A green suite ends the run without a model.
+"""
+import ast
+from pathlib import Path
+from harness.act.code import apply_source
+
+
+
+
+CONFLICT_START = "<<<<<<< "
+
+
+CONFLICT_MID = "======="
+
+
+CONFLICT_END = ">>>>>>> "
+
+
+def conflict_blocks(source: str) -> list[tuple[list[str], list[str]]]:
+    """The two sides of every merge conflict in `source`."""
+    blocks: list[tuple[list[str], list[str]]] = []
+    lines = source.splitlines(keepends=True)
+    index = 0
+    while index < len(lines):
+        if not lines[index].startswith(CONFLICT_START):
+            index += 1
+            continue
+        index += 1
+        ours: list[str] = []
+        while index < len(lines) and lines[index].rstrip("\n") != CONFLICT_MID:
+            ours.append(lines[index])
+            index += 1
+        index += 1
+        theirs: list[str] = []
+        while index < len(lines) and not lines[index].startswith(CONFLICT_END):
+            theirs.append(lines[index])
+            index += 1
+        index += 1
+        blocks.append((ours, theirs))
+    return blocks
+
+
+def resolve_keeping_both(source: str) -> str:
+    """Merge every conflict by keeping both sides, or "" if that is unsafe.
+
+    Two branches that each added something to the same file is the common
+    case and the safe one: nothing is lost by keeping both. A conflict
+    where one side is empty is a deletion against an edit, and which one
+    is wanted is not something to guess at.
+
+    Asked to resolve a real conflict, a live 8B spent twenty steps and
+    left all three markers in place. Asked to resolve one in a file that
+    had none, it reported the conflict resolved. Neither needed a model.
+    """
+    blocks = conflict_blocks(source)
+    if not blocks:
+        return ""
+    if any(not "".join(ours).strip() or not "".join(theirs).strip()
+           for ours, theirs in blocks):
+        return ""
+    out: list[str] = []
+    lines = source.splitlines(keepends=True)
+    index = 0
+    while index < len(lines):
+        if not lines[index].startswith(CONFLICT_START):
+            out.append(lines[index])
+            index += 1
+            continue
+        index += 1
+        ours = []
+        while lines[index].rstrip("\n") != CONFLICT_MID:
+            ours.append(lines[index]); index += 1
+        index += 1
+        theirs = []
+        while not lines[index].startswith(CONFLICT_END):
+            theirs.append(lines[index]); index += 1
+        index += 1
+        out.extend(ours)
+        # Two definitions need air between them; two import lines do not.
+        if theirs and theirs[0].lstrip().startswith(("def ", "class ", "@")):
+            out.append("\n\n")
+        out.extend(theirs)
+    merged = "".join(out)
+    try:
+        ast.parse(merged)
+    except SyntaxError:
+        return ""
+    return merged
+
+
+def looks_like_conflict(task: str) -> bool:
+    """Whether the task is about a merge conflict."""
+    lowered = task.lower()
+    return "conflict" in lowered and any(
+        word in lowered for word in ("merge", "resolve", "rebase", "<<<<")
+    )
+
+
+def _resolve_conflict(path: Path, rel: str, original: str, *, write: bool) -> str:
+    """Keep both sides of every conflict in the file, or say what is there."""
+    blocks = conflict_blocks(original)
+    if not blocks:
+        # Saying so is the point. Asked to resolve a conflict in a file
+        # that had none, a live 8B reported the conflict resolved.
+        return f"{rel} has no merge conflict in it. Nothing to resolve"
+    merged = resolve_keeping_both(original)
+    if not merged:
+        return (
+            f"{rel} has {len(blocks)} conflict(s) where one side is empty. "
+            "That is a deletion against an edit, and which one you want is "
+            "not something to guess"
+        )
+    if write:
+        apply_source(path, merged, original=original)
+    return f"kept both sides of {len(blocks)} conflict(s) in {rel}"