asicode 0.2.6__tar.gz → 0.2.7__tar.gz

{asicode-0.2.6/asicode.egg-info → asicode-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: asicode
-Version: 0.2.6
+Version: 0.2.7
 Summary: Autonomous Software Improvement — AST-precise code editing agent with verification gates (CLI + MCP server)
 Author-email: socialherb <junddory@gmail.com>
 License-Expression: MIT

{asicode-0.2.6 → asicode-0.2.7/asicode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: asicode
-Version: 0.2.6
+Version: 0.2.7
 Summary: Autonomous Software Improvement — AST-precise code editing agent with verification gates (CLI + MCP server)
 Author-email: socialherb <junddory@gmail.com>
 License-Expression: MIT

{asicode-0.2.6 → asicode-0.2.7}/asicode.egg-info/SOURCES.txt

@@ -176,6 +176,7 @@ external_llm/edit_localization/request_analyzer.py
 external_llm/editor/_editor_core/__init__.py
 external_llm/editor/_editor_core/common/__init__.py
 external_llm/editor/_editor_core/common/import_normalizer.py
+external_llm/editor/_editor_core/common/strategy_priors.py
 external_llm/editor/_editor_core/ts_vm/__init__.py
 external_llm/editor/_editor_core/ts_vm/execution_vm/__init__.py
 external_llm/editor/_editor_core/ts_vm/execution_vm/ast_rewriter.py
@@ -353,4 +354,5 @@ tests/test_work_state_digest.py
 tests/test_write_safety_repair_path.py
 utils/__init__.py
 utils/llm_utils.py
-utils/string_helper.py
+utils/string_helper.py
+utils/version_check.py

asicode-0.2.7/external_llm/editor/_editor_core/common/strategy_priors.py

@@ -0,0 +1,67 @@
+"""Cold-start strategy priors — shared by the PLANNER lane strategy selector
+and the live weight-learning cold-start bias (agent/weight_learning.py).
+
+Lives in _editor_core/common (retained in the CLI-only distribution) so the
+live consumer keeps working when the lane/ package is excluded."""
+from __future__ import annotations
+
+# Repair_burden is on a 0-3 scale (none=0, low=1, medium=2, high=3).
+_COLD_PRIORS: dict[str, dict[str, float]] = {
+    "generic_create": {
+        "repair_burden": 0.50,
+        "success_rate":  0.80,
+        "contract_risk": 0.30,
+        "complexity":    0.30,
+        "cost":          0.20,
+    },
+    "reference_bound_create": {
+        "repair_burden": 0.30,
+        "success_rate":  0.85,
+        "contract_risk": 0.10,
+        "complexity":    0.40,
+        "cost":          0.25,
+    },
+    "symbol_guided_create": {
+        "repair_burden": 0.35,
+        "success_rate":  0.85,
+        "contract_risk": 0.15,
+        "complexity":    0.35,
+        "cost":          0.20,
+    },
+    "test_aware_create": {
+        "repair_burden": 0.40,
+        "success_rate":  0.82,
+        "contract_risk": 0.20,
+        "complexity":    0.35,
+        "cost":          0.25,
+    },
+    # P11: Modify/extend strategies
+    "symbol_edit": {
+        "repair_burden": 0.25,
+        "success_rate":  0.85,
+        "contract_risk": 0.15,
+        "complexity":    0.20,
+        "cost":          0.15,
+    },
+    "minimal_patch": {
+        "repair_burden": 0.15,
+        "success_rate":  0.88,
+        "contract_risk": 0.10,
+        "complexity":    0.10,
+        "cost":          0.10,
+    },
+    "refactor": {
+        "repair_burden": 0.60,
+        "success_rate":  0.70,
+        "contract_risk": 0.35,
+        "complexity":    0.55,
+        "cost":          0.30,
+    },
+    "test_first": {
+        "repair_burden": 0.35,
+        "success_rate":  0.80,
+        "contract_risk": 0.20,
+        "complexity":    0.30,
+        "cost":          0.25,
+    },
+}

{asicode-0.2.6 → asicode-0.2.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "asicode"
-version = "0.2.6"
+version = "0.2.7"
 description = "Autonomous Software Improvement — AST-precise code editing agent with verification gates (CLI + MCP server)"
 readme = "README.md"
 license = "MIT"

asicode-0.2.7/utils/version_check.py

@@ -0,0 +1,297 @@
+"""Background PyPI update check for the asicode CLI.
+
+Once per ``interval`` (default 24h) the PyPI JSON API is queried for the latest
+published version of the package; if it is newer than the running version a
+one-line upgrade hint is produced. The network call runs on a daemon thread so
+it never blocks CLI startup: a previously cached *latest* version is returned
+immediately, and a fresh fetch merely refreshes the cache for the next run.
+
+Design invariants
+-----------------
+* **Non-blocking.** The cache is read synchronously (cheap file read); the
+  network call is delegated to a daemon thread. ``collect(wait_s=0)`` never
+  blocks.
+* **Crash-safe cache.** Writes use ``mkstemp`` + ``fsync`` + ``os.replace``
+  (POSIX-atomic). A corrupt / partially-written / unreadable cache is ignored
+  on read and silently overwritten on the next write (resilient load).
+* **Testable.** The cache path is overridable via the
+  ``ASICODE_VERSION_CHECK_CACHE`` env var (mirrors the
+  ``ASICODE_WRITE_TOOL_FAILURE_LOG`` pattern), and the network call is pluggable
+  via the ``fetcher`` argument. No real network is touched by the unit tests.
+* **Fail-open.** Any unexpected error is swallowed — the update check must
+  *never* break the CLI itself.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+import threading
+import time
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any, Optional
+
+__all__ = [
+    "PACKAGE_NAME",
+    "UpdateCheckHandle",
+    "get_current_version",
+    "is_newer",
+    "start_update_check",
+]
+
+# ─── configuration ───────────────────────────────────────────────────────────
+PACKAGE_NAME = "asicode"
+_PYPI_URL = f"https://pypi.org/pypi/{PACKAGE_NAME}/json"
+# Network budget: PyPI JSON is tiny and fast; this is only a safety net against
+# a hung connection (mirrors the subprocess-hang discipline of bounding reads).
+_FETCH_TIMEOUT_S: float = 4.0
+_DEFAULT_INTERVAL_HOURS: float = 24.0
+
+
+# ─── current version ─────────────────────────────────────────────────────────
+def get_current_version() -> str:
+    """Return the installed package version, or ``"0.0.0"`` if unresolvable.
+
+    Uses ``importlib.metadata`` (stdlib). On a source checkout that is not
+    installed, the metadata lookup fails — we return the ``"0.0.0"`` sentinel,
+    which :func:`start_update_check` treats as "not pip-installed" and skips
+    the check entirely (a pip-upgrade hint would be wrong there).
+    """
+    try:
+        from importlib.metadata import PackageNotFoundError, version
+
+        try:
+            return str(version(PACKAGE_NAME))
+        except PackageNotFoundError:
+            return "0.0.0"
+    except Exception:
+        return "0.0.0"
+
+
+# ─── cache path ──────────────────────────────────────────────────────────────
+def _cache_path() -> Path:
+    """Resolve the cache file path.
+
+    Honors ``ASICODE_VERSION_CHECK_CACHE`` (absolute path override, used by
+    tests to redirect to a temp file). Defaults to ``~/.asicode/version_check.json``.
+    """
+    override = os.environ.get("ASICODE_VERSION_CHECK_CACHE")
+    if override:
+        return Path(override)
+    return Path(os.path.expanduser("~")) / ".asicode" / "version_check.json"
+
+
+def _read_cache() -> dict[str, Any]:
+    """Read & parse the cache. Returns ``{}`` if missing or corrupt.
+
+    Resilient load: a truncated/partial JSON file (e.g. crash mid-write of a
+    previous version that predated atomic writes, or external tampering) must
+    not raise — we treat it as an empty cache and let the next write repair it.
+    """
+    path = _cache_path()
+    try:
+        raw = path.read_text(encoding="utf-8")
+        data = json.loads(raw)
+        if isinstance(data, dict):
+            return data
+        return {}
+    except (OSError, ValueError):
+        return {}
+
+
+def _atomic_write_text(path: Path, content: str) -> None:
+    """Crash-safe text write: ``mkstemp`` + ``fsync`` + ``os.replace``.
+
+    A truncating ``open(path, "w")`` can leave a partial/empty file if the
+    process is interrupted mid-write; the atomic temp-file + rename sequence
+    guarantees the cache is either the previous contents or the new contents,
+    never a torn write.
+    """
+    path.parent.mkdir(parents=True, exist_ok=True)
+    base_dir = str(path.parent)
+    fd, tmp_path = tempfile.mkstemp(dir=base_dir, prefix=".vc-atomic-", suffix=".tmp")
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as f:
+            f.write(content)
+            f.flush()
+            os.fsync(f.fileno())
+        os.replace(tmp_path, path)
+    except BaseException:
+        # Best-effort cleanup of the temp file on any failure path.
+        try:
+            os.unlink(tmp_path)
+        except OSError:
+            pass
+        raise
+
+
+def _write_cache(data: dict[str, Any]) -> None:
+    """Persist the cache atomally (errors swallowed — fail-open)."""
+    try:
+        _atomic_write_text(_cache_path(), json.dumps(data))
+    except OSError:
+        pass
+
+
+# ─── version comparison ──────────────────────────────────────────────────────
+def is_newer(latest: str, current: str) -> bool:
+    """Return True iff ``latest`` is strictly newer than ``current``.
+
+    Uses ``packaging.version`` (bundled with pip/setuptools, so virtually always
+    present). Falls back to a conservative inequality check so a missing
+    ``packaging`` never breaks the feature.
+    """
+    try:
+        from packaging.version import InvalidVersion
+        from packaging.version import parse as _parse
+
+        try:
+            return _parse(latest) > _parse(current)
+        except InvalidVersion:
+            return False
+    except Exception:
+        return bool(latest) and bool(current) and latest != current
+
+
+# ─── network fetch (pluggable for tests) ─────────────────────────────────────
+def _default_fetch(url: str, timeout: float) -> Optional[str]:
+    """Query the PyPI JSON API and return the latest version string, or None.
+
+    Uses the project's existing ``httpx`` dependency (sync client). Any error —
+    DNS, timeout, non-200, malformed body — yields None so callers can treat
+    "no answer" uniformly.
+    """
+    import httpx
+
+    try:
+        with httpx.Client(timeout=timeout, follow_redirects=True) as client:
+            resp = client.get(url)
+            resp.raise_for_status()
+            data = resp.json()
+    except Exception:
+        return None
+    version = str((data.get("info") or {}).get("version", "")).strip()
+    return version or None
+
+
+# ─── notice formatting ───────────────────────────────────────────────────────
+def _format_notice(latest: str, current: str) -> str:
+    return (
+        f"[{PACKAGE_NAME}] update available: {latest} (current: {current})\n"
+        f"           pip install --upgrade {PACKAGE_NAME}"
+    )
+
+
+# ─── handle & entry point ────────────────────────────────────────────────────
+class UpdateCheckHandle:
+    """Opaque handle returned by :func:`start_update_check`.
+
+    Carries the immediately-known (cached) notice and (optionally) the daemon
+    thread performing a fresh fetch. ``collect`` lets a caller briefly wait for
+    the fetch to finish so a first-ever run (empty cache) can still surface a
+    notice this session.
+    """
+
+    __slots__ = ("_current", "_notice", "_thread")
+
+    def __init__(self, current: str) -> None:
+        self._thread: Optional[threading.Thread] = None
+        self._notice: Optional[str] = None
+        self._current: str = current
+
+    @property
+    def notice(self) -> Optional[str]:
+        """Notice string if a newer version is already known (cached); else None."""
+        return self._notice
+
+    def collect(self, wait_s: float = 0.0) -> Optional[str]:
+        """Optionally wait for the background fetch, then return the notice.
+
+        ``wait_s=0`` is fully non-blocking: it returns the cached notice
+        immediately. If a fetch thread is alive and ``wait_s>0`` is given, this
+        waits up to ``wait_s`` seconds; once the thread has finished it re-reads
+        the cache so a freshly-discovered version is reflected. Never raises.
+        """
+        thread = self._thread
+        if thread is not None and thread.is_alive() and wait_s > 0:
+            thread.join(wait_s)
+        if thread is not None and not thread.is_alive():
+            # Thread finished (now or just above): pick up any newer cached value.
+            try:
+                latest = _read_cache().get("latest")
+            except Exception:
+                latest = None
+            if latest and is_newer(str(latest), self._current):
+                self._notice = _format_notice(str(latest), self._current)
+        return self._notice
+
+
+def _bg_fetch(current: str, fetcher: Callable[[str, float], Optional[str]]) -> None:
+    """Daemon-thread body: fetch latest, refresh cache. All errors swallowed."""
+    try:
+        latest = fetcher(_PYPI_URL, _FETCH_TIMEOUT_S)
+    except Exception:
+        latest = None
+    if latest:
+        _write_cache(
+            {
+                "last_check_ts": time.time(),
+                "latest": latest,
+                "current_at_check": current,
+            }
+        )
+
+
+def start_update_check(
+    *,
+    interval_hours: float = _DEFAULT_INTERVAL_HOURS,
+    current_version: Optional[str] = None,
+    fetcher: Optional[Callable[[str, float], Optional[str]]] = None,
+    now_ts: Optional[float] = None,
+) -> UpdateCheckHandle:
+    """Start a (possibly skipped) background update check; return a handle.
+
+    Behaviour:
+    * The cache is read first; if it records a *latest* newer than the running
+      version, the handle's ``notice`` is populated **immediately** (no network).
+    * If the last successful check is older than ``interval_hours`` (or there is
+      no cache yet), a daemon thread performs a fresh fetch and refreshes the
+      cache for subsequent runs. The fetcher defaults to :func:`_default_fetch`
+      but is injectable for tests.
+
+    This function never raises — a failure here must not impair the CLI.
+    """
+    current = current_version if current_version is not None else get_current_version()
+    handle = UpdateCheckHandle(current)
+
+    # Uninstalled source checkout: there is no pip-managed install to upgrade,
+    # so a notice would be actionable-looking but wrong ("current: 0.0.0").
+    # Skip both the notice and the fetch entirely.
+    if current == "0.0.0":
+        return handle
+
+    try:
+        cache = _read_cache()
+        cached_latest = cache.get("latest")
+        if cached_latest and is_newer(str(cached_latest), current):
+            handle._notice = _format_notice(str(cached_latest), current)
+
+        last_check = float(cache.get("last_check_ts") or 0)
+        now = now_ts if now_ts is not None else time.time()
+        interval_s = max(0.0, interval_hours) * 3600.0
+        if now - last_check >= interval_s:
+            thread = threading.Thread(
+                target=_bg_fetch,
+                args=(current, fetcher or _default_fetch),
+                name=f"{PACKAGE_NAME}-version-check",
+                daemon=True,
+            )
+            handle._thread = thread
+            thread.start()
+    except Exception:
+        # Fail-open: any hiccup just yields a handle with no notice.
+        pass
+
+    return handle