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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplicio-cli
-Version: 0.9.3
+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.3 → simplicio_cli-0.9.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simplicio-cli"
-version = "0.9.3"
+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.3 → 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.3 → simplicio_cli-0.9.5}/simplicio/mechanical_edit.py

@@ -5,7 +5,10 @@ from __future__ import annotations
 import difflib
 import io
 import json
+import os
+import shutil
 import subprocess
+import tempfile
 import tokenize
 from copy import deepcopy
 from pathlib import Path
@@ -61,6 +64,11 @@ def execute_plan(
     apply: bool = False,
 ) -> dict[str, Any]:
     root_path = Path(root)
+
+    native_result = _try_native_edit(plan, root_path, apply=apply)
+    if native_result is not None:
+        return native_result
+
     errors = _validate_shape(plan)
     operations = plan.get("operations") if isinstance(plan.get("operations"), list) else []
     touched_files = _declared_touched_files(plan, operations)
@@ -133,6 +141,178 @@ class MechanicalEditError(ValueError):
         return {"code": self.code, "message": self.message, **self.extra}
 
 
+# Timeout for delegating a plan to the native ``simplicio`` Rust binary.
+# Matches the precedent in commands/file_read.py's RUNTIME_DELEGATION_TIMEOUT_S
+# — generous enough for a real edit, short enough to never hang the caller
+# when the binary exists but misbehaves.
+_NATIVE_EDIT_TIMEOUT_S = 30.0
+
+
+def _native_edit_binary() -> str | None:
+    """Locate the native ``simplicio`` binary, honoring the dev-cli kill-switch.
+
+    Mirrors ``simplicio.commands.edit._runtime_edit_binary`` without importing
+    that module: ``commands/edit.py`` imports this module lazily (inside
+    ``run_mechanical_edit``), so a module-level import back here would invert
+    that dependency.
+    """
+    if os.environ.get("SIMPLICIO_DEV_CLI_NO_RUNTIME_EDIT"):
+        return None
+    return shutil.which("simplicio")
+
+
+def _try_native_edit(
+    plan: dict[str, Any],
+    root_path: Path,
+    *,
+    apply: bool,
+) -> dict[str, Any] | None:
+    """Attempt to delegate *plan* to the native ``simplicio edit`` binary.
+
+    Returns the translated result dict on a clean, schema-matching success.
+    Returns ``None`` on ANY failure — binary missing, subprocess error,
+    timeout, non-JSON stdout, or a JSON payload that doesn't match
+    ``RESULT_SCHEMA`` — so the caller falls through to the pure-Python
+    implementation below. Never raises.
+    """
+    binary = _native_edit_binary()
+    if binary is None:
+        return None
+
+    try:
+        plan_text = json.dumps(plan)
+    except (TypeError, ValueError):
+        return None
+
+    tmp_path: str | None = None
+    try:
+        try:
+            fd, tmp_path = tempfile.mkstemp(prefix="simplicio-edit-plan-", suffix=".json")
+            with os.fdopen(fd, "w", encoding="utf-8") as handle:
+                handle.write(plan_text)
+        except OSError:
+            return None
+
+        cmd = [binary, "edit", "--plan", tmp_path, "--repo", str(root_path), "--json"]
+        if not apply:
+            cmd.append("--dry-run")
+        try:
+            completed = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=_NATIVE_EDIT_TIMEOUT_S,
+            )
+        except (OSError, subprocess.TimeoutExpired):
+            return None
+
+        try:
+            payload = json.loads(completed.stdout)
+        except (json.JSONDecodeError, ValueError):
+            return None
+
+        return _translate_native_result(payload, root_path)
+    finally:
+        if tmp_path is not None:
+            try:
+                os.unlink(tmp_path)
+            except OSError:
+                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:
+    """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 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") != NATIVE_EDIT_RESULT_SCHEMA:
+        return None
+    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 (
+        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": "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": operations_applied,
+            "errors": errors,
+            "validation": [],
+        }
+    )
+    return result
+
+
 def _validate_shape(plan: dict[str, Any]) -> list[dict[str, Any]]:
     errors = []
     if plan.get("schema") != PLAN_SCHEMA:

{simplicio_cli-0.9.3 → simplicio_cli-0.9.5}/simplicio/pipeline.py

@@ -275,6 +275,14 @@ def build_retry_feedback(attempt, validation=None, test_log=""):
 
 
 def _git_apply_patch(root, patch):
+    # No native-first `simplicio` delegation here (unlike mechanical_edit.py's
+    # execute_plan). Confirmed against the installed `simplicio` binary's own
+    # --help: `simplicio edit` only accepts a JSON operations plan
+    # (`--plan <file|->` or a literal JSON positional argument) — there is no
+    # --diff/--patch flag to feed it a raw unified diff. Delegation to the
+    # native binary happens at the mechanical_edit.py layer instead; this
+    # git-apply path (which applies an LLM-generated unified diff, not a
+    # mechanical-edit plan) stays local-only.
     attempts = [
         ([], "git apply"),
         (["--recount"], "git apply --recount"),

{simplicio_cli-0.9.3 → 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.3
+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.3/simplicio/__init__.py

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