simplicio-cli 0.9.4__tar.gz → 0.9.5__tar.gz

{simplicio_cli-0.9.4 → simplicio_cli-0.9.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplicio-cli
-Version: 0.9.4
+Version: 0.9.5
 Summary: Portable task-to-code pipeline that works with any LLM. Turn a one-line task into a verified code change — diff + test + verify loop. +55 pts on a 156-check benchmark, 21% faster, ~same tokens.
 Author-email: Wesley Simplicio <wesleybob4@gmail.com>
 License: MIT

{simplicio_cli-0.9.4 → simplicio_cli-0.9.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simplicio-cli"
-version = "0.9.4"
+version = "0.9.5"
 description = "Portable task-to-code pipeline that works with any LLM. Turn a one-line task into a verified code change — diff + test + verify loop. +55 pts on a 156-check benchmark, 21% faster, ~same tokens."
 readme = "README.md"
 license = { text = "MIT" }

simplicio_cli-0.9.5/simplicio/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.9.5"

{simplicio_cli-0.9.4 → simplicio_cli-0.9.5}/simplicio/mapper.py

@@ -304,9 +304,112 @@ def rank_entries(
     return [entry for _score, entry in ranked[:limit]]
 
 
+# Timeout for delegating a precedent search to the native `simplicio` Rust
+# binary (`simplicio precedent search`, schema `simplicio.precedent-search/v1`).
+# Short because this only assists ranking before a prompt is built — a
+# slow/hanging binary must never block the existing artifact-file/embedding
+# fallback chain below.
+_NATIVE_PRECEDENT_TIMEOUT_S = 5.0
+
+
+def _native_precedent_binary() -> str | None:
+    """Locate the native `simplicio` binary, honoring this repo's dev-cli
+    kill-switch. Mirrors `simplicio.commands.edit._runtime_edit_binary` /
+    `simplicio.mechanical_edit._native_edit_binary` for this feature."""
+    if os.environ.get("SIMPLICIO_DEV_CLI_NO_RUNTIME_PRECEDENT"):
+        return None
+    return shutil.which("simplicio")
+
+
+def _translate_native_candidate(candidate: dict[str, Any]) -> dict[str, Any]:
+    """Reshape one `simplicio.precedent-search/v1` candidate (`precedent_id`,
+    `score`, `reuse_level`, `suggested_next_action`) into the item shape this
+    module's `rank_entries()`-backed candidates already carry (`path`,
+    `line`, `summary`, `tags`), so every existing caller of
+    `rank_precedents()` (`build_precedent_block()`, `build_mapper_context()`,
+    `_render_precedent_candidates_legacy/toon()`) keeps working unmodified.
+    The native fields are kept on the dict too, for any caller that wants
+    them directly."""
+    precedent_id = candidate.get("precedent_id")
+    reuse_level = candidate.get("reuse_level")
+    suggested_next_action = candidate.get("suggested_next_action")
+    return {
+        "precedent_id": precedent_id,
+        "score": candidate.get("score"),
+        "reuse_level": reuse_level,
+        "suggested_next_action": suggested_next_action,
+        "path": candidate.get("path") or f"precedent:{precedent_id or '?'}",
+        "line": candidate.get("line", 1),
+        "summary": candidate.get("summary")
+        or suggested_next_action
+        or (f"reuse_level={reuse_level}" if reuse_level else "runtime precedent"),
+        "tags": candidate.get("tags") or ([str(reuse_level)] if reuse_level else []),
+    }
+
+
+def _native_precedent_search(
+    root: str | os.PathLike[str], text: str, top_n: int
+) -> list[dict[str, Any]] | None:
+    """Delegate precedent ranking to `simplicio precedent search --json`.
+
+    Returns the translated candidate list on a clean, non-empty answer, or
+    `None` on ANY failure — binary missing/kill-switched, non-zero exit,
+    timeout, unparseable JSON, a payload missing `candidates`, or a valid
+    but *empty* candidate list. Empty is deliberately treated the same as
+    failure here (stricter than `simplicio-mapper`'s own `ask precedent`,
+    which trusts an empty native answer as final): the native precedent
+    memory (`.simplicio/precedents/*.sqlite`, built from run history) and
+    this module's `precedent-index.json` artifact are independent stores, so
+    an empty/uninitialized native store must not shadow real candidates the
+    artifact-file chain below might still have. Never raises.
+    """
+    binary = _native_precedent_binary()
+    if binary is None:
+        return None
+    top_n = top_n if isinstance(top_n, int) and top_n > 0 else 1
+    try:
+        completed = subprocess.run(
+            [
+                binary,
+                "precedent",
+                "search",
+                "--repo",
+                str(Path(root).resolve()),
+                "--text",
+                text,
+                "--top",
+                str(top_n),
+                "--json",
+            ],
+            capture_output=True,
+            text=True,
+            timeout=_NATIVE_PRECEDENT_TIMEOUT_S,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    if completed.returncode != 0:
+        return None
+    try:
+        payload = loads(completed.stdout)
+    except (ValueError, TypeError):
+        return None
+    if not isinstance(payload, dict):
+        return None
+    candidates = payload.get("candidates")
+    if not isinstance(candidates, list):
+        return None
+    translated = [_translate_native_candidate(c) for c in candidates[:top_n] if isinstance(c, dict)]
+    return translated or None
+
+
 def rank_precedents(
     root: str | os.PathLike[str], task: str, *, stack: str = "", k: int = 2
 ) -> list[dict[str, Any]]:
+    text = task.strip()
+    if text:
+        native = _native_precedent_search(root, text, k)
+        if native is not None:
+            return native[:k]
     loaded = load_precedent_index(root)
     if loaded is None:
         return []

{simplicio_cli-0.9.4 → simplicio_cli-0.9.5}/simplicio/mechanical_edit.py

@@ -220,47 +220,94 @@ def _try_native_edit(
                 pass
 
 
+
+# The native binary's *actual* `simplicio edit --json` output schema today —
+# confirmed by running it live. It does NOT match this module's own
+# RESULT_SCHEMA ("simplicio.mechanical-edit-result/v1"): the field shapes are
+# genuinely different (`changed`/`file`/`operations_applied` vs this module's
+# `noop`/`files`/`operation_count`), not just a schema-string typo. Translated
+# below rather than requiring the runtime to change its established contract.
+NATIVE_EDIT_RESULT_SCHEMA = "simplicio.edit-result/v1"
+
+
 def _translate_native_result(payload: Any, root_path: Path) -> dict[str, Any] | None:
-    """Validate *payload* against ``RESULT_SCHEMA`` and rebuild it in this
+    """Translate the native `simplicio edit --json` payload into this
     module's own result shape (same keys ``execute_plan`` always returns).
 
-    Returns ``None`` on any shape mismatch — a missing/renamed field is
-    treated the same as "the binary can't help here" rather than trusted
-    partially.
+    Returns ``None`` on any shape mismatch OR on `native_status ==
+    "checks_failed"` — a missing/renamed field is treated the same as "the
+    binary can't help here" rather than trusted partially. The
+    "checks_failed" exclusion is a real semantic gap, not caution for its own
+    sake: on a failed post-edit validation phase, the native binary has
+    already written the file and does NOT roll it back, while this module's
+    own Python path restores the pre-edit content on the same failure
+    (`_restore(root_path, backups)` in `execute_plan`). Translating that case
+    as a normal "refused" result would silently misrepresent the file as
+    unchanged when it is not — falling through to the Python path instead
+    preserves the rollback guarantee callers rely on.
     """
-    if not isinstance(payload, dict) or payload.get("schema") != RESULT_SCHEMA:
+    if not isinstance(payload, dict) or payload.get("schema") != NATIVE_EDIT_RESULT_SCHEMA:
         return None
-    status = payload.get("status")
-    applied = payload.get("applied")
-    noop = payload.get("noop")
-    planned_diff = payload.get("planned_diff")
-    files = payload.get("files")
-    operation_count = payload.get("operation_count")
-    errors = payload.get("errors")
-    validation = payload.get("validation")
+    native_status = payload.get("status")
+    if native_status == "checks_failed":
+        return None
+    file_abs = payload.get("file")
+    changed = payload.get("changed")
+    dry_run = payload.get("dry_run")
+    operations_applied = payload.get("operations_applied")
+    before_sha = payload.get("before_sha256")
+    after_sha = payload.get("after_sha256")
     if (
-        status not in ("ok", "refused")
-        or not isinstance(applied, bool)
-        or not isinstance(noop, bool)
-        or not isinstance(planned_diff, str)
-        or not isinstance(files, list)
-        or not isinstance(operation_count, int)
-        or not isinstance(errors, list)
-        or not isinstance(validation, list)
+        not isinstance(native_status, str)
+        or not isinstance(file_abs, str)
+        or not isinstance(changed, bool)
+        or not isinstance(dry_run, bool)
+        or not isinstance(operations_applied, int)
+        or not isinstance(before_sha, str)
+        or not isinstance(after_sha, str)
     ):
         return None
 
+    try:
+        rel_path = str(Path(file_abs).resolve().relative_to(root_path.resolve()))
+    except ValueError:
+        # Native binary reported a path outside root — untranslatable, not a
+        # crash; the Python path applies its own root-escape checks anyway.
+        return None
+
+    files = (
+        []
+        if before_sha == after_sha
+        else [{"path": rel_path, "before_sha256": before_sha, "after_sha256": after_sha}]
+    )
+    errors: list[dict[str, Any]] = []
+    if native_status != "ok":
+        skipped_reason = payload.get("post_edit_skipped_reason")
+        errors.append(
+            {
+                "code": "post_edit_phase_skipped",
+                "message": skipped_reason
+                if isinstance(skipped_reason, str)
+                else f"native status: {native_status}",
+            }
+        )
+
     result = _base_result(root_path)
     result.update(
         {
-            "status": status,
-            "applied": applied,
-            "noop": noop,
-            "planned_diff": planned_diff,
+            "status": "ok",
+            "applied": bool(not dry_run),
+            "noop": not changed,
+            # The native binary's --json output does not currently include a
+            # unified diff string (only prints one to the console in
+            # --review/--dry-run mode, not part of this JSON payload) — an
+            # empty string is the honest "not available" value here, not a
+            # claim that nothing changed (see `files`/`noop` for that).
+            "planned_diff": "",
             "files": files,
-            "operation_count": operation_count,
+            "operation_count": operations_applied,
             "errors": errors,
-            "validation": validation,
+            "validation": [],
         }
     )
     return result

{simplicio_cli-0.9.4 → simplicio_cli-0.9.5}/simplicio_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplicio-cli
-Version: 0.9.4
+Version: 0.9.5
 Summary: Portable task-to-code pipeline that works with any LLM. Turn a one-line task into a verified code change — diff + test + verify loop. +55 pts on a 156-check benchmark, 21% faster, ~same tokens.
 Author-email: Wesley Simplicio <wesleybob4@gmail.com>
 License: MIT

simplicio_cli-0.9.4/simplicio/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.9.4"