misterdev 0.2.0__py3-none-any.whl

misterdev/llm/responses/apply.py

@@ -0,0 +1,131 @@
+"""Apply anchored SEARCH/REPLACE hunks against on-disk file content."""
+
+from typing import List
+
+from .models import SearchReplaceEdit, EditConflictError
+
+
+def apply_search_replace(original: str, edits: List[SearchReplaceEdit]) -> str:
+    """Apply anchored hunks to ``original`` and return the full new content.
+
+    Each hunk's SEARCH snippet must resolve to exactly one location; a missing
+    or ambiguous anchor raises :class:`EditConflictError` so the caller can
+    retry rather than write a corrupt file. An empty SEARCH creates a new file
+    and is rejected if the file already has content. Matching is line-anchored
+    (never a bare substring, which would splice mid-line), with a per-line
+    whitespace/line-ending-tolerant comparison that absorbs the trailing-space
+    and CRLF drift models commonly introduce without ever matching more than one
+    place.
+    """
+    content = original
+    for edit in edits:
+        if not edit.search.strip():
+            if content.strip():
+                raise EditConflictError(
+                    f"{edit.path}: empty SEARCH block is only valid for a new "
+                    "file, but this file already has content. Anchor the edit "
+                    "to the exact lines you are replacing."
+                )
+            content = edit.replace
+            continue
+        content = _apply_one_hunk(content, edit)
+    return content
+
+
+def _apply_one_hunk(content: str, edit: SearchReplaceEdit) -> str:
+    spliced, hits = _line_splice(content, edit.search, edit.replace)
+    if hits == 1:
+        return spliced
+    if hits == 0:
+        raise EditConflictError(
+            f"{edit.path}: SEARCH block not found. It must match the current "
+            "file (whitespace aside). Re-read the file and copy the lines "
+            "verbatim."
+        )
+    raise EditConflictError(
+        f"{edit.path}: SEARCH block matches {hits} locations. Include more "
+        "surrounding context so it identifies exactly one place."
+    )
+
+
+def _line_splice(content: str, search: str, replace: str) -> tuple:
+    """Locate ``search`` as a window of whole LINES in ``content`` and replace it.
+
+    Line-anchored, never a bare substring: a single-line hunk like ``x = 1`` is
+    matched against whole lines, so it can never splice into the middle of a
+    longer line such as ``x = 10``. Two passes, each requiring exactly one
+    matching window (any other count is a conflict and the content is returned
+    unmutated):
+
+    1. right-stripped / CR-free lines — absorbs trailing-space and CRLF drift,
+       keeping indentation significant;
+    2. fully-stripped lines — absorbs wrong indentation too, then re-indents the
+       replacement to the file's actual indentation so formatting is preserved.
+
+    Replacement lines inherit the file's line ending, so a CRLF file stays CRLF.
+    """
+    crlf = "\r\n" in content
+    o_lines = content.split("\n")
+    s_lines = search.split("\n")
+    r_lines = replace.split("\n")
+
+    rstripped = [ln.replace("\r", "").rstrip() for ln in o_lines]
+    ns_r = [ln.replace("\r", "").rstrip() for ln in s_lines]
+    k = len(ns_r)
+    if k == 0 or k > len(o_lines):
+        return content, 0
+    hits = [i for i in range(len(rstripped) - k + 1) if rstripped[i : i + k] == ns_r]
+    if len(hits) == 1:
+        return _join_splice(o_lines, hits[0], k, r_lines, crlf), 1
+    if len(hits) > 1:
+        return content, len(hits)
+
+    # Pass 2: ignore indentation, then reapply the file's indentation.
+    stripped = [ln.strip() for ln in o_lines]
+    ns_s = [ln.strip() for ln in s_lines]
+    hits = [i for i in range(len(stripped) - k + 1) if stripped[i : i + k] == ns_s]
+    if len(hits) != 1:
+        return content, len(hits)
+    i = hits[0]
+    reindented = _reindent(o_lines[i : i + k], s_lines, r_lines)
+    return _join_splice(o_lines, i, k, reindented, crlf), 1
+
+
+def _join_splice(
+    o_lines: List[str], i: int, k: int, r_lines: List[str], crlf: bool
+) -> str:
+    """Splice ``r_lines`` over ``o_lines[i:i+k]``, giving the replacement lines the
+    file's line ending so a CRLF file does not end up with mixed CRLF/LF lines."""
+    if crlf:
+        r_lines = [ln if ln.endswith("\r") else ln + "\r" for ln in r_lines]
+    return "\n".join(o_lines[:i] + r_lines + o_lines[i + k :])
+
+
+def _leading_ws(line: str) -> str:
+    return line[: len(line) - len(line.lstrip())]
+
+
+def _reindent(matched: List[str], search: List[str], replace: List[str]) -> List[str]:
+    """Shift ``replace`` by the indent delta between matched and search anchors.
+
+    The delta is measured on the first non-blank line of each; applying it to
+    every non-blank replacement line lands the new code at the file's real
+    indentation even when the model used a different indent in its SEARCH.
+    """
+
+    def first_indent(lines: List[str]) -> str:
+        for ln in lines:
+            if ln.strip():
+                return _leading_ws(ln.replace("\r", ""))
+        return ""
+
+    target = first_indent(matched)
+    source = first_indent(search)
+    out = []
+    for ln in replace:
+        if not ln.strip():
+            out.append(ln)
+            continue
+        body = ln[len(source) :] if ln.startswith(source) else ln.lstrip()
+        out.append(target + body)
+    return out

misterdev/llm/responses/json_extract.py

@@ -0,0 +1,80 @@
+"""Extract JSON values embedded in prose or code fences from LLM output."""
+
+import json
+from typing import Any, Optional
+
+
+def extract_json_array(response: str, default: Optional[Any] = None) -> Any:
+    """Extract the outermost JSON array from an LLM response.
+
+    LLMs often wrap a JSON array in prose or code fences; this slices from the
+    first ``[`` to the last ``]`` and parses. Returns ``default`` (or ``[]``)
+    on any failure. Consolidates the find/slice/loads pattern that was copy-
+    pasted across the decomposer, advisor, sovereign, and metacognition.
+    """
+    if default is None:
+        default = []
+    text = (response or "").strip()
+    start = text.find("[")
+    end = text.rfind("]")
+    if start < 0 or end <= start:
+        return default
+    try:
+        return json.loads(text[start : end + 1])
+    except (json.JSONDecodeError, ValueError):
+        return default
+
+
+def extract_balanced_span(text: str, start: int) -> Optional[str]:
+    """Return the balanced ``{...}`` substring beginning at ``start`` (a ``{``).
+
+    Brace-counts while honoring braces inside double-quoted strings (with
+    escapes), so an object containing ``{`` or ``}`` in a string value is
+    extracted whole; tolerates the object spanning multiple lines. Returns None
+    if the span never balances. Consolidates the string-aware brace scan that was
+    duplicated in the goal check and the MCP gather loop.
+    """
+    depth = 0
+    in_string = False
+    escaped = False
+    for i in range(start, len(text)):
+        ch = text[i]
+        if in_string:
+            if escaped:
+                escaped = False
+            elif ch == "\\":
+                escaped = True
+            elif ch == '"':
+                in_string = False
+            continue
+        if ch == '"':
+            in_string = True
+        elif ch == "{":
+            depth += 1
+        elif ch == "}":
+            depth -= 1
+            if depth == 0:
+                return text[start : i + 1]
+    return None
+
+
+def extract_json_object(text: str) -> Optional[dict]:
+    """Return the first parseable top-level JSON object in ``text``, or None.
+
+    Scans each ``{`` for a balanced, string-aware span and json-loads it; a span
+    that fails to parse is skipped and the next ``{`` is tried. Survives leading
+    prose or a ```json fence around the object.
+    """
+    if not text:
+        return None
+    start = text.find("{")
+    while start != -1:
+        span = extract_balanced_span(text, start)
+        if span is not None:
+            try:
+                parsed = json.loads(span)
+                return parsed if isinstance(parsed, dict) else None
+            except ValueError:
+                pass  # malformed span; try the next '{'
+        start = text.find("{", start + 1)
+    return None

misterdev/llm/responses/models.py

@@ -0,0 +1,43 @@
+"""Edit shapes and errors shared across the response parsers."""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class FileEdit:
+    path: str
+    content: str
+    is_new: bool = False
+
+
+@dataclass
+class SearchReplaceEdit:
+    """A single anchored, surgical edit to one file.
+
+    ``search`` is the exact existing snippet to locate; ``replace`` is what
+    takes its place. An empty ``search`` means "create this file" and is only
+    valid when the file does not yet exist. Multiple edits may target the same
+    path and are applied in order against the evolving content.
+    """
+
+    path: str
+    search: str
+    replace: str
+
+
+class EditConflictError(Exception):
+    """A search/replace hunk could not be applied unambiguously.
+
+    Raised when the SEARCH snippet is absent, matches more than once, or would
+    blank/overwrite an existing file. The caller surfaces the message back to
+    the model as an error so it retries with a corrected anchor — a partial or
+    truncated file is never written.
+    """
+
+
+@dataclass
+class _CodeBlock:
+    lang: str
+    path_hint: str
+    content_lines: list
+    preceding_text: str