development-engine-vector 0.3.0__py3-none-any.whl

dev/kernel/selfcheck.py

@@ -0,0 +1,137 @@
+"""dev.kernel.selfcheck — the engine knows itself.
+
+Checks:
+  version       — version file exists and is valid semver, matches __version__
+  install_path  — editable install of dev resolves to this source directory
+  db            — dev.db accessible with WAL mode (soft — OK if not yet created)
+  tools         — required tools (git, python3) are on PATH
+  dependencies  — all required imports load without error
+"""
+
+import importlib
+import re
+import shutil
+import sqlite3
+import subprocess
+import sys
+from pathlib import Path
+from typing import Optional
+
+from dev.kernel.paths import DB_PATH
+
+PACKAGE_DIR = Path(__file__).resolve().parent.parent  # dev/
+SOURCE_DIR = PACKAGE_DIR.parent  # source/
+VERSION_FILE = SOURCE_DIR / "version"
+
+REQUIRED_TOOLS = ["git", "python3"]
+OPTIONAL_TOOLS = ["twine"]
+REQUIRED_IMPORTS = ["click", "sqlite3"]
+
+
+# ── result builders ──────────────────────────────────────────────────────────
+
+def _ok(name: str, message: str, details: Optional[str] = None) -> dict:
+    r = {"name": name, "passed": True, "message": message}
+    if details:
+        r["details"] = details
+    return r
+
+
+def _fail(name: str, message: str, details: Optional[str] = None) -> dict:
+    r = {"name": name, "passed": False, "message": message}
+    if details:
+        r["details"] = details
+    return r
+
+
+# ── individual checks ─────────────────────────────────────────────────────────
+
+def check_version() -> dict:
+    if not VERSION_FILE.exists():
+        return _fail("version", "version file not found")
+    version = VERSION_FILE.read_text().strip()
+    if not re.fullmatch(r"\d+\.\d+\.\d+", version):
+        return _fail("version", f"version is not valid semver: {version!r}")
+    try:
+        from dev import __version__
+        if __version__ != version:
+            return _fail(
+                "version",
+                f"version file ({version}) does not match __version__ ({__version__})")
+    except (ImportError, AttributeError):
+        pass
+    return _ok("version", f"version is valid semver: {version}")
+
+
+def check_install_path() -> dict:
+    try:
+        result = subprocess.run(
+            [sys.executable, "-c",
+             "import dev, pathlib; "
+             "print(pathlib.Path(dev.__file__).parent.parent.resolve())"],
+            capture_output=True, text=True,
+        )
+        if result.returncode != 0:
+            return _fail("install_path", "dev not importable — editable install broken")
+        install_dir = Path(result.stdout.strip()).resolve()
+        if install_dir == SOURCE_DIR:
+            return _ok("install_path", f"editable install → {install_dir}")
+        return _fail(
+            "install_path",
+            f"install points to wrong path: {install_dir} (expected {SOURCE_DIR})")
+    except Exception as exc:
+        return _fail("install_path", f"install_path check error: {exc}")
+
+
+def check_db() -> dict:
+    if not DB_PATH.exists():
+        return _ok("db", "dev.db not yet created (will be on first run)")
+    try:
+        conn = sqlite3.connect(f"file:{DB_PATH}?mode=ro", uri=True, timeout=5)
+        row = conn.execute("PRAGMA journal_mode").fetchone()
+        conn.close()
+        mode = row[0] if row else "unknown"
+        if mode != "wal":
+            return _fail("db", f"DB accessible but journal_mode={mode} (expected wal)")
+        return _ok("db", "dev.db present and accessible (WAL mode)")
+    except sqlite3.DatabaseError as exc:
+        return _fail("db", f"DB is corrupt or unreadable: {exc}")
+
+
+def check_tools() -> dict:
+    missing = [t for t in REQUIRED_TOOLS if not shutil.which(t)]
+    if missing:
+        return _fail("tools", f"Required tools missing: {', '.join(missing)}")
+    optional_missing = [t for t in OPTIONAL_TOOLS if not shutil.which(t)]
+    opt_details: Optional[str] = (
+        f"Optional tools not found: {', '.join(optional_missing)}"
+        if optional_missing else None
+    )
+    return _ok("tools", "All required tools present", opt_details)
+
+
+def check_dependencies() -> dict:
+    failed = []
+    for mod in REQUIRED_IMPORTS:
+        try:
+            importlib.import_module(mod)
+        except ImportError:
+            failed.append(mod)
+    if failed:
+        return _fail("dependencies", f"Missing imports: {', '.join(failed)}")
+    return _ok("dependencies", f"All {len(REQUIRED_IMPORTS)} required imports load")
+
+
+# ── runner ────────────────────────────────────────────────────────────────────
+
+def run_all() -> dict:
+    """Run all selfchecks. Returns summary dict with checks list."""
+    checks = [
+        check_version(),
+        check_install_path(),
+        check_db(),
+        check_tools(),
+        check_dependencies(),
+    ]
+    passed = sum(1 for c in checks if c["passed"])
+    return {"checks": checks, "passed": passed, "failed": len(checks) - passed}

dev/ui/actions.py

@@ -0,0 +1,47 @@
+import subprocess
+import sys
+import threading
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict
+
+ACTION_STATE: Dict[str, Any] = {}
+ACTION_LOCK = threading.Lock()
+
+# vet.py lives at control/scripts/vet.py relative to source/
+_VET_SCRIPT = Path(__file__).resolve().parents[3] / "control" / "scripts" / "vet.py"
+
+
+def run_action_background(action_id, action_name):
+    """Execute a control action in a background thread."""
+    with ACTION_LOCK:
+        ACTION_STATE[action_id] = {
+            "status": "running",
+            "action": action_name,
+            "started_at": datetime.now().isoformat(),
+            "output": "",
+        }
+
+    try:
+        if action_name == "vet":
+            result = subprocess.run(
+                [sys.executable, str(_VET_SCRIPT)],
+                capture_output=True,
+                text=True,
+                timeout=300,
+            )
+        else:
+            result = None
+
+        with ACTION_LOCK:
+            if result:
+                ACTION_STATE[action_id]["status"] = "completed" if result.returncode == 0 else "failed"
+                ACTION_STATE[action_id]["output"] = result.stdout + result.stderr
+                ACTION_STATE[action_id]["returncode"] = result.returncode
+            ACTION_STATE[action_id]["completed_at"] = datetime.now().isoformat()
+
+    except Exception as e:
+        with ACTION_LOCK:
+            ACTION_STATE[action_id]["status"] = "error"
+            ACTION_STATE[action_id]["output"] = str(e)
+            ACTION_STATE[action_id]["completed_at"] = datetime.now().isoformat()

dev/ui/db/__init__.py

@@ -0,0 +1,26 @@
+from .base import get_db, query_rows, query_one, safe_rows, safe_one, table_exists, execute_stmt
+from .overview import get_overview
+from .runs import get_runs, get_run_detail
+from .health import get_health
+from .checks import get_checks
+from .manifest import get_manifest
+from .identity import get_identity
+from .events import get_events
+
+__all__ = [
+    "get_db",
+    "query_rows",
+    "query_one",
+    "safe_rows",
+    "safe_one",
+    "table_exists",
+    "execute_stmt",
+    "get_overview",
+    "get_runs",
+    "get_run_detail",
+    "get_health",
+    "get_checks",
+    "get_manifest",
+    "get_identity",
+    "get_events",
+]

dev/ui/db/base.py

@@ -0,0 +1,75 @@
+import os
+import sqlite3
+from pathlib import Path
+
+# Control DB: adjacent to source/ in the intel system layout.
+# Overridable via DEV_CONTROL_DB env var for non-standard installs.
+_DEFAULT = Path(__file__).resolve().parents[4] / "control" / "data" / "control.db"
+CONTROL_DB_PATH = Path(os.environ.get("DEV_CONTROL_DB", str(_DEFAULT)))
+
+
+def get_db():
+    """Get a WAL connection to the control database."""
+    conn = sqlite3.connect(str(CONTROL_DB_PATH), timeout=10)
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA journal_mode=WAL")
+    conn.execute("PRAGMA synchronous=NORMAL")
+    return conn
+
+
+def query_rows(sql, params=()):
+    """Execute SELECT and return rows as dicts."""
+    try:
+        conn = get_db()
+        cursor = conn.execute(sql, params)
+        rows = [dict(row) for row in cursor.fetchall()]
+        conn.close()
+        return rows
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def query_one(sql, params=()):
+    """Execute SELECT and return single row or None."""
+    rows = query_rows(sql, params)
+    if isinstance(rows, dict) and "error" in rows:
+        return rows
+    return rows[0] if rows else None
+
+
+def safe_rows(rows):
+    """Normalize query_rows output to an array for APIs."""
+    if isinstance(rows, dict) and "error" in rows:
+        return []
+    return rows or []
+
+
+def safe_one(row):
+    """Normalize query_one output to a dict or None."""
+    if isinstance(row, dict) and "error" in row:
+        return None
+    return row
+
+
+def table_exists(table_name):
+    """Return True if a table exists in the control database."""
+    try:
+        row = query_one(
+            "SELECT name FROM sqlite_master WHERE type='table' AND name=?",
+            (table_name,)
+        )
+        return bool(row)
+    except Exception:
+        return False
+
+
+def execute_stmt(sql, params=()):
+    """Execute INSERT/UPDATE/DELETE statement."""
+    try:
+        conn = get_db()
+        conn.execute(sql, params)
+        conn.commit()
+        conn.close()
+        return {"ok": True}
+    except Exception as e:
+        return {"error": str(e)}

dev/ui/db/checks.py

@@ -0,0 +1,16 @@
+from .base import query_rows, safe_rows
+
+
+def get_checks():
+    """Return all check definitions."""
+    try:
+        rows = safe_rows(query_rows(
+            """
+            SELECT id, name, kind, command, workdir, enabled, order_idx, timeout, added_at
+            FROM checks
+            ORDER BY order_idx, id
+            """
+        ))
+        return {"checks": rows, "total": len(rows)}
+    except Exception as e:
+        return {"error": str(e)}

dev/ui/db/events.py

@@ -0,0 +1,18 @@
+from .base import query_rows, safe_rows
+
+
+def get_events(limit=100):
+    """Return recent events."""
+    try:
+        rows = safe_rows(query_rows(
+            """
+            SELECT id, occurred_at, kind, actor, subject, detail
+            FROM events
+            ORDER BY id DESC
+            LIMIT ?
+            """,
+            (limit,),
+        ))
+        return {"events": rows, "total": len(rows)}
+    except Exception as e:
+        return {"error": str(e)}

dev/ui/db/health.py

@@ -0,0 +1,34 @@
+from .base import query_rows, safe_rows
+
+
+def get_health(check_name=None, limit=200):
+    """Return health check results, optionally filtered by check name."""
+    try:
+        if check_name:
+            rows = safe_rows(query_rows(
+                """
+                SELECT h.id, h.run_at, h.check_name, h.passed, h.message,
+                       r.id as run_id, r.exit_code as run_exit_code
+                FROM health h
+                LEFT JOIN runs r ON r.started_at = h.run_at
+                WHERE h.check_name = ?
+                ORDER BY h.id DESC
+                LIMIT ?
+                """,
+                (check_name, limit),
+            ))
+        else:
+            rows = safe_rows(query_rows(
+                """
+                SELECT h.id, h.run_at, h.check_name, h.passed, h.message,
+                       r.id as run_id, r.exit_code as run_exit_code
+                FROM health h
+                LEFT JOIN runs r ON r.started_at = h.run_at
+                ORDER BY h.id DESC
+                LIMIT ?
+                """,
+                (limit,),
+            ))
+        return {"health": rows, "total": len(rows)}
+    except Exception as e:
+        return {"error": str(e)}

dev/ui/db/identity.py

@@ -0,0 +1,12 @@
+from .base import query_rows, safe_rows
+
+
+def get_identity():
+    """Return all identity key-value records."""
+    try:
+        rows = safe_rows(query_rows(
+            "SELECT id, key, value, updated_at FROM identity ORDER BY key"
+        ))
+        return {"identity": rows, "total": len(rows)}
+    except Exception as e:
+        return {"error": str(e)}

dev/ui/db/manifest.py

@@ -0,0 +1,35 @@
+from .base import query_rows, safe_rows
+
+
+def get_manifest(q=None, limit=200, offset=0):
+    """Return manifest entries, optionally filtered by filename/path."""
+    try:
+        total_rows = query_rows("SELECT COUNT(*) as total FROM manifest")
+        total = total_rows[0]["total"] if total_rows and not isinstance(total_rows, dict) else 0
+
+        if q:
+            rows = safe_rows(query_rows(
+                """
+                SELECT id, relative_path, filename, extension, size_bytes,
+                       file_type, is_tracked, is_gitignored, is_binary, mtime
+                FROM manifest
+                WHERE relative_path LIKE ? OR filename LIKE ?
+                ORDER BY relative_path
+                LIMIT ? OFFSET ?
+                """,
+                (f"%{q}%", f"%{q}%", limit, offset),
+            ))
+        else:
+            rows = safe_rows(query_rows(
+                """
+                SELECT id, relative_path, filename, extension, size_bytes,
+                       file_type, is_tracked, is_gitignored, is_binary, mtime
+                FROM manifest
+                ORDER BY relative_path
+                LIMIT ? OFFSET ?
+                """,
+                (limit, offset),
+            ))
+        return {"files": rows, "total": total}
+    except Exception as e:
+        return {"error": str(e)}

dev/ui/db/overview.py

@@ -0,0 +1,47 @@
+from .base import query_one, query_rows, safe_one, safe_rows, table_exists
+
+
+def get_overview():
+    """Dashboard overview stats."""
+    try:
+        has_runs = table_exists("runs")
+        has_health = table_exists("health")
+        has_checks = table_exists("checks")
+        has_manifest = table_exists("manifest")
+
+        stats = query_one(f"""
+            SELECT
+                {("(SELECT COUNT(*) FROM runs)" if has_runs else "0")} as total_runs,
+                {("(SELECT COUNT(*) FROM checks WHERE enabled=1)" if has_checks else "0")} as enabled_checks,
+                {("(SELECT COUNT(*) FROM manifest)" if has_manifest else "0")} as manifest_files,
+                {("(SELECT exit_code FROM runs ORDER BY id DESC LIMIT 1)" if has_runs else "NULL")} as last_exit_code,
+                {("(SELECT finished_at FROM runs ORDER BY id DESC LIMIT 1)" if has_runs else "NULL")} as last_run_at,
+                {("(SELECT notes FROM runs ORDER BY id DESC LIMIT 1)" if has_runs else "NULL")} as last_notes,
+                {("(SELECT COUNT(*) FROM runs WHERE exit_code=0)" if has_runs else "0")} as clean_runs,
+                {("(SELECT COUNT(*) FROM runs WHERE exit_code!=0 AND exit_code IS NOT NULL)" if has_runs else "0")} as failed_runs
+        """)
+
+        recent_runs = safe_rows(query_rows("""
+            SELECT id, started_at, finished_at, trigger, exit_code, notes
+            FROM runs
+            ORDER BY id DESC
+            LIMIT 10
+        """)) if has_runs else []
+
+        check_pass_rates = safe_rows(query_rows("""
+            SELECT h.check_name,
+                   COUNT(*) as total,
+                   SUM(h.passed) as passed,
+                   ROUND(100.0 * SUM(h.passed) / COUNT(*), 1) as pass_rate
+            FROM health h
+            GROUP BY h.check_name
+            ORDER BY h.check_name
+        """)) if has_health else []
+
+        return {
+            "stats": dict(safe_one(stats)) if safe_one(stats) else {},
+            "recent_runs": recent_runs,
+            "check_pass_rates": check_pass_rates,
+        }
+    except Exception as e:
+        return {"error": str(e)}

dev/ui/db/runs.py

@@ -0,0 +1,47 @@
+from .base import query_rows, safe_rows
+
+
+def get_runs(limit=50, offset=0):
+    """Return paginated vet run history."""
+    try:
+        total_row = query_rows("SELECT COUNT(*) as total FROM runs")
+        total = total_row[0]["total"] if total_row and not isinstance(total_row, dict) else 0
+
+        rows = safe_rows(query_rows(
+            """
+            SELECT id, started_at, finished_at, trigger, exit_code, notes
+            FROM runs
+            ORDER BY id DESC
+            LIMIT ? OFFSET ?
+            """,
+            (limit, offset),
+        ))
+        return {"runs": rows, "total": total}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def get_run_detail(run_id):
+    """Return a single run with its per-check health rows."""
+    try:
+        run_rows = query_rows(
+            "SELECT id, started_at, finished_at, trigger, exit_code, notes FROM runs WHERE id=?",
+            (run_id,),
+        )
+        if not run_rows or isinstance(run_rows, dict):
+            return {"error": "run not found"}
+        run = run_rows[0]
+
+        health = safe_rows(query_rows(
+            """
+            SELECT h.check_name, h.passed, h.message
+            FROM health h
+            WHERE h.run_at = ?
+            ORDER BY h.check_name
+            """,
+            (run["started_at"],),
+        ))
+
+        return {"run": run, "health": health}
+    except Exception as e:
+        return {"error": str(e)}

dev/ui/routes.py

@@ -0,0 +1,114 @@
+import json
+import threading
+import time
+import traceback
+from urllib.parse import parse_qs
+
+from dev.ui.actions import run_action_background
+from dev.ui.db import (
+    get_overview, get_runs, get_run_detail, get_health,
+    get_checks, get_manifest, get_identity, get_events,
+    query_rows,
+)
+from dev.ui.templates import INDEX_HTML, PAGE_REGISTRY_JS
+
+from pathlib import Path
+
+_static_dir = Path(__file__).parent / "static"
+_CSS = (_static_dir / "web.css").read_text(encoding="utf-8")
+_STATIC_JS = (_static_dir / "web.js").read_text(encoding="utf-8")
+_APP_JS = PAGE_REGISTRY_JS + _STATIC_JS
+
+
+def application(environ, start_response):
+    """WSGI application."""
+    method = environ["REQUEST_METHOD"]
+    path = environ["PATH_INFO"]
+    query = parse_qs(environ.get("QUERY_STRING", ""))
+
+    try:
+        if path == "/":
+            response = (
+                INDEX_HTML
+                .replace("{{STYLE_CSS}}", _CSS)
+                .replace("{{APP_JS}}", _APP_JS)
+                .encode("utf-8")
+            )
+            start_response("200 OK", [("Content-Type", "text/html; charset=utf-8")])
+            return [response]
+
+        elif path == "/api/overview":
+            data = get_overview()
+            start_response("200 OK", [("Content-Type", "application/json")])
+            return [json.dumps(data).encode("utf-8")]
+
+        elif path == "/api/runs":
+            limit = int(query.get("limit", ["50"])[0])
+            offset = int(query.get("offset", ["0"])[0])
+            data = get_runs(limit, offset)
+            start_response("200 OK", [("Content-Type", "application/json")])
+            return [json.dumps(data).encode("utf-8")]
+
+        elif path == "/api/run":
+            run_id = int(query.get("run_id", ["0"])[0])
+            data = get_run_detail(run_id)
+            start_response("200 OK", [("Content-Type", "application/json")])
+            return [json.dumps(data).encode("utf-8")]
+
+        elif path == "/api/health":
+            check_name = query.get("check", [None])[0]
+            data = get_health(check_name)
+            start_response("200 OK", [("Content-Type", "application/json")])
+            return [json.dumps(data).encode("utf-8")]
+
+        elif path == "/api/checks":
+            data = get_checks()
+            start_response("200 OK", [("Content-Type", "application/json")])
+            return [json.dumps(data).encode("utf-8")]
+
+        elif path == "/api/manifest":
+            q = query.get("q", [""])[0]
+            data = get_manifest(q if q else None)
+            start_response("200 OK", [("Content-Type", "application/json")])
+            return [json.dumps(data).encode("utf-8")]
+
+        elif path == "/api/identity":
+            data = get_identity()
+            start_response("200 OK", [("Content-Type", "application/json")])
+            return [json.dumps(data).encode("utf-8")]
+
+        elif path == "/api/events":
+            data = get_events()
+            start_response("200 OK", [("Content-Type", "application/json")])
+            return [json.dumps(data).encode("utf-8")]
+
+        elif path == "/api/action" and method == "POST":
+            body = environ["wsgi.input"].read()
+            payload = json.loads(body.decode("utf-8"))
+            action = payload.get("action", "")
+
+            action_id = f"{action}_{int(time.time() * 1000)}"
+            thread = threading.Thread(target=run_action_background, args=(action_id, action))
+            thread.daemon = True
+            thread.start()
+
+            data = {"ok": True, "action": action, "action_id": action_id, "message": f"Started {action}..."}
+            start_response("200 OK", [("Content-Type", "application/json")])
+            return [json.dumps(data).encode("utf-8")]
+
+        elif path == "/api/query" and method == "POST":
+            body = environ["wsgi.input"].read()
+            payload = json.loads(body.decode("utf-8"))
+            sql = payload.get("sql", "")
+            rows = query_rows(sql)
+            start_response("200 OK", [("Content-Type", "application/json")])
+            return [json.dumps({"rows": rows}).encode("utf-8")]
+
+        else:
+            start_response("404 Not Found", [("Content-Type", "text/plain")])
+            return [b"Not Found"]
+
+    except Exception as e:
+        traceback.print_exc()
+        start_response("500 Internal Server Error", [("Content-Type", "application/json")])
+        return [json.dumps({"error": str(e)}).encode("utf-8")]