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

dev/kernel/config.py

@@ -0,0 +1,46 @@
+from pathlib import Path
+
+DEFAULT_CONFIG_NAMES = [".dev-cli.toml", "dev-cli.toml"]
+
+
+def load_toml_file(path):
+    try:
+        import tomllib  # type: ignore[import-not-found]
+    except ModuleNotFoundError:
+        import tomli as tomllib  # type: ignore[import-not-found,no-redef]
+
+    return tomllib.loads(Path(path).read_text())
+
+
+class DevConfig:
+    """Load dev-cli project configuration."""
+
+    def __init__(self, project_dir=".", config_path=None):
+        self.project_dir = Path(project_dir).resolve()
+        self.config_path = self._resolve_config_path(config_path)
+        self.data = self._load() if self.config_path else {}
+
+    def _resolve_config_path(self, config_path):
+        if config_path:
+            candidate = Path(config_path)
+            return candidate.resolve() if candidate.exists() else None
+
+        for name in DEFAULT_CONFIG_NAMES:
+            candidate = self.project_dir / name
+            if candidate.exists():
+                return candidate.resolve()
+
+        return None
+
+    def _load(self):
+        try:
+            return load_toml_file(self.config_path)
+        except Exception as exc:
+            raise ValueError(f"Invalid dev-cli config {self.config_path}: {exc}")
+
+    def get(self, section, key, default=None):
+        return self.data.get(section, {}).get(key, default)
+
+    def get_bool(self, section, key, default=None):
+        value = self.get(section, key, default)
+        return bool(value) if value is not None else None

dev/kernel/db.py

@@ -0,0 +1,129 @@
+"""dev.kernel.db — persistent run history for the Development Engine Vector.
+
+Schema:
+  runs     — every workflow action: preflight, build, publish, release, check
+  projects — registry of known projects with last known version and release time
+
+All writes use WAL mode. Reads are safe to do concurrently.
+"""
+
+import json
+import sqlite3
+from datetime import datetime, timezone
+from typing import Optional
+
+from dev.kernel.paths import DATA_DIR, DB_PATH
+
+
+_SCHEMA = """
+CREATE TABLE IF NOT EXISTS runs (
+    id          INTEGER PRIMARY KEY AUTOINCREMENT,
+    project     TEXT    NOT NULL,
+    action      TEXT    NOT NULL,
+    version     TEXT,
+    outcome     TEXT    NOT NULL,
+    started_at  TEXT    NOT NULL,
+    finished_at TEXT,
+    details     TEXT
+);
+
+CREATE TABLE IF NOT EXISTS projects (
+    id               INTEGER PRIMARY KEY AUTOINCREMENT,
+    name             TEXT    NOT NULL UNIQUE,
+    path             TEXT    NOT NULL,
+    last_version     TEXT,
+    last_release_at  TEXT,
+    registered_at    TEXT    NOT NULL
+);
+"""
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def connect() -> sqlite3.Connection:
+    """Open (or create) dev.db with WAL mode and schema applied."""
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(DB_PATH, timeout=10)
+    conn.execute("PRAGMA journal_mode=WAL")
+    conn.execute("PRAGMA foreign_keys=ON")
+    conn.executescript(_SCHEMA)
+    conn.commit()
+    return conn
+
+
+def record_run(project: str, action: str, outcome: str,
+               version: Optional[str] = None, details: Optional[dict] = None) -> int:
+    """Insert a run record. Returns the new run id."""
+    conn = connect()
+    cur = conn.execute(
+        "INSERT INTO runs (project, action, version, outcome, started_at, details)"
+        " VALUES (?, ?, ?, ?, ?, ?)",
+        (project, action, version, outcome, _now(),
+         json.dumps(details) if details else None),
+    )
+    conn.commit()
+    run_id = cur.lastrowid
+    conn.close()
+    return run_id if run_id is not None else -1
+
+
+def finish_run(run_id: int, outcome: str, details: Optional[dict] = None) -> None:
+    """Update an existing run record with final outcome and finish time."""
+    conn = connect()
+    conn.execute(
+        "UPDATE runs SET outcome=?, finished_at=?, details=? WHERE id=?",
+        (outcome, _now(), json.dumps(details) if details else None, run_id),
+    )
+    conn.commit()
+    conn.close()
+
+
+def upsert_project(name: str, path: str, version: Optional[str] = None,
+                   release_at: Optional[str] = None) -> None:
+    """Register or update a project in the local registry."""
+    conn = connect()
+    conn.execute(
+        "INSERT INTO projects (name, path, last_version, last_release_at, registered_at)"
+        " VALUES (?, ?, ?, ?, ?)"
+        " ON CONFLICT(name) DO UPDATE SET"
+        "   path=excluded.path,"
+        "   last_version=COALESCE(excluded.last_version, last_version),"
+        "   last_release_at=COALESCE(excluded.last_release_at, last_release_at)",
+        (name, path, version, release_at, _now()),
+    )
+    conn.commit()
+    conn.close()
+
+
+def get_recent_runs(project: Optional[str] = None, limit: int = 20) -> list:
+    """Return recent runs, optionally filtered by project name."""
+    conn = connect()
+    if project:
+        rows = conn.execute(
+            "SELECT id, project, action, version, outcome, started_at, finished_at"
+            " FROM runs WHERE project=? ORDER BY id DESC LIMIT ?",
+            (project, limit),
+        ).fetchall()
+    else:
+        rows = conn.execute(
+            "SELECT id, project, action, version, outcome, started_at, finished_at"
+            " FROM runs ORDER BY id DESC LIMIT ?",
+            (limit,),
+        ).fetchall()
+    conn.close()
+    cols = ["id", "project", "action", "version", "outcome", "started_at", "finished_at"]
+    return [dict(zip(cols, r)) for r in rows]
+
+
+def get_projects() -> list:
+    """Return all registered projects."""
+    conn = connect()
+    rows = conn.execute(
+        "SELECT id, name, path, last_version, last_release_at, registered_at"
+        " FROM projects ORDER BY name"
+    ).fetchall()
+    conn.close()
+    cols = ["id", "name", "path", "last_version", "last_release_at", "registered_at"]
+    return [dict(zip(cols, r)) for r in rows]

dev/kernel/paths.py

@@ -0,0 +1,85 @@
+"""dev.kernel.paths — canonical path resolution for the Development Engine Vector.
+
+DEV_HOME is the single root for all runtime state (DB, logs, config).
+Resolved at import time via:
+
+  1. DEV_HOME environment variable (absolute path)
+  2. ~/Library/goCosmix/tools/dev/   (macOS default)
+  3. ~/.gocosmix/tools/dev/           (fallback on non-macOS)
+
+All goCosmix apps share the ~/Library/goCosmix/ namespace:
+
+  ~/Library/goCosmix/
+  ├── apps/
+  │   ├── code-data-ark/   ← long-running services
+  │   └── ...
+  ├── tools/
+  │   ├── dev/             ← DEV_HOME
+  │   └── ...
+  └── system/              ← shared goCosmix infrastructure
+"""
+
+import os
+from pathlib import Path
+
+
+# ── home resolution ──────────────────────────────────────────────────────────
+
+def _default_dev_home() -> Path:
+    """Platform-appropriate default for DEV_HOME."""
+    library = Path.home() / "Library"
+    if library.exists():  # macOS
+        return library / "goCosmix" / "tools" / "dev"
+    return Path.home() / ".gocosmix" / "tools" / "dev"
+
+
+def get_dev_home() -> Path:
+    """Return the DEV home directory, creating it if needed."""
+    env = os.environ.get("DEV_HOME")
+    if env:
+        home = Path(env).expanduser().resolve()
+    else:
+        home = _default_dev_home()
+    home.mkdir(parents=True, exist_ok=True)
+    return home
+
+
+# ── goCosmix namespace (shared across all goCosmix apps) ────────────────────
+
+def get_gocosmix_home() -> Path:
+    """Return ~/Library/goCosmix (macOS) or ~/.gocosmix (other)."""
+    library = Path.home() / "Library"
+    if library.exists():
+        return library / "goCosmix"
+    return Path.home() / ".gocosmix"
+
+
+GOCOSMIX_HOME = get_gocosmix_home()
+GOCOSMIX_APPS = GOCOSMIX_HOME / "apps"
+GOCOSMIX_TOOLS = GOCOSMIX_HOME / "tools"
+GOCOSMIX_SYSTEM = GOCOSMIX_HOME / "system"
+
+
+# ── canonical paths (computed once at import) ────────────────────────────────
+
+DEV_HOME = get_dev_home()
+DATA_DIR = DEV_HOME / "data"
+RUN_DIR = DEV_HOME / "run"
+LOG_DIR = DEV_HOME / "logs"
+CONFIG_DIR = DEV_HOME / "config"
+PMF_DIR = DEV_HOME / "pmf"
+
+DB_PATH = DATA_DIR / "dev.db"
+UI_PID_FILE = RUN_DIR / "ui.pid"
+UI_LOG_FILE = LOG_DIR / "ui.log"
+PMF_LOG_DIR = PMF_DIR / "logs"
+RUNTIME_FILE = PMF_DIR / "runtime.json"
+
+DEFAULT_PORT = 9001
+
+
+def ensure_dirs() -> None:
+    """Create all runtime directories. Safe to call multiple times."""
+    for d in (GOCOSMIX_HOME, GOCOSMIX_APPS, GOCOSMIX_TOOLS, GOCOSMIX_SYSTEM,
+              DATA_DIR, RUN_DIR, LOG_DIR, CONFIG_DIR, PMF_DIR, PMF_LOG_DIR):
+        d.mkdir(parents=True, exist_ok=True)

dev/kernel/pmf_kernel.py

@@ -0,0 +1,432 @@
+"""dev.kernel.pmf_kernel — embedded PMF service manager for the Development Engine Vector.
+
+Manages the web UI as a background process with PID tracking and launchd integration.
+Port 9001 — tools namespace (9000 reserved for the future tool orchestrator).
+"""
+
+import json
+import os
+import shutil
+import signal
+import socket
+import subprocess
+import sys
+import time
+import webbrowser
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from dev.kernel.paths import (
+    LOG_DIR, RUNTIME_FILE,
+    UI_PID_FILE, DEV_HOME,
+    ensure_dirs,
+    DEFAULT_PORT,
+)
+
+DEFAULT_HOST = "127.0.0.1"
+
+# ── launchd integration ──────────────────────────────────────────────────────
+
+PLIST_LABEL = "com.gocosmix.dev"
+
+
+def plist_path() -> Path:
+    return Path.home() / "Library" / "LaunchAgents" / f"{PLIST_LABEL}.plist"
+
+
+def generate_plist(dev_bin: str, dev_home: Path) -> str:
+    log = dev_home / "logs" / "launchd.log"
+    return f"""<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>{PLIST_LABEL}</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>{dev_bin}</string>
+        <string>pmf</string>
+        <string>up</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <false/>
+    <key>StandardOutPath</key>
+    <string>{log}</string>
+    <key>StandardErrorPath</key>
+    <string>{log}</string>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>DEV_HOME</key>
+        <string>{dev_home}</string>
+        <key>PATH</key>
+        <string>{os.path.dirname(dev_bin)}:/usr/local/bin:/usr/bin:/bin</string>
+    </dict>
+</dict>
+</plist>
+"""
+
+
+def install_launchd(dev_home: Path) -> Path:
+    """Write the LaunchAgent plist and load it with launchctl."""
+    dev_bin = shutil.which("dev")
+    if not dev_bin:
+        raise PMFKernelError("dev binary not found on PATH — cannot generate plist")
+
+    target = plist_path()
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(generate_plist(dev_bin, dev_home))
+
+    subprocess.run(["launchctl", "unload", str(target)], capture_output=True)
+    result = subprocess.run(["launchctl", "load", str(target)], capture_output=True, text=True)
+    if result.returncode != 0:
+        raise PMFKernelError(f"launchctl load failed: {result.stderr.strip()}")
+
+    return target
+
+
+def uninstall_launchd() -> None:
+    """Unload and remove the LaunchAgent plist."""
+    target = plist_path()
+    if target.exists():
+        subprocess.run(["launchctl", "unload", str(target)], capture_output=True)
+        target.unlink(missing_ok=True)
+
+
+def open_browser_when_ready(
+    url: str,
+    host: str = DEFAULT_HOST,
+    port: int = DEFAULT_PORT,
+    timeout: float = 12.0,
+) -> None:
+    """Poll host:port in a daemon thread and open browser when ready."""
+    import threading
+
+    def _wait_and_open():
+        elapsed = 0.0
+        while elapsed < timeout:
+            try:
+                with socket.create_connection((host, port), timeout=0.5):
+                    webbrowser.open(url)
+                    return
+            except OSError:
+                time.sleep(0.25)
+                elapsed += 0.25
+
+    threading.Thread(target=_wait_and_open, daemon=True).start()
+
+
+def wait_for_port_and_open_browser(
+    url: str,
+    host: str = DEFAULT_HOST,
+    port: int = DEFAULT_PORT,
+    timeout: float = 8.0,
+) -> bool:
+    """Block until host:port accepts connections, then open browser."""
+    elapsed = 0.0
+    while elapsed < timeout:
+        try:
+            with socket.create_connection((host, port), timeout=0.5):
+                webbrowser.open(url)
+                return True
+        except OSError:
+            time.sleep(0.25)
+            elapsed += 0.25
+    return False
+
+
+ensure_dirs()
+
+
+def _now_ts() -> int:
+    return int(time.time() * 1000)
+
+
+def _now_iso() -> str:
+    return time.strftime("%Y-%m-%dT%H:%M:%S", time.localtime())
+
+
+@dataclass
+class ServiceSpec:
+    service_id: str
+    label: str
+    service_type: str
+    description: str
+    command: Optional[List[str]] = None
+    cwd: Optional[Path] = None
+    env: Optional[Dict[str, str]] = None
+    pid_file: Optional[Path] = None
+    log_file: Optional[Path] = None
+    allowed_actions: Optional[List[str]] = None
+
+    def build_command(self, options: Optional[Dict[str, str]] = None) -> List[str]:
+        if self.service_id == "ui":
+            host = options.get("host", DEFAULT_HOST) if options else DEFAULT_HOST
+            port = options.get("port", DEFAULT_PORT) if options else DEFAULT_PORT
+            return [
+                sys.executable,
+                "-c",
+                (
+                    "import dev.ui.web as w; "
+                    f"w.start_server(host={json.dumps(host)}, port={port})"
+                ),
+            ]
+        if self.command is not None:
+            return list(self.command)
+        raise RuntimeError(f"No command configured for service: {self.service_id}")
+
+
+SERVICE_SPECS: Dict[str, ServiceSpec] = {
+    "ui": ServiceSpec(
+        service_id="ui",
+        label="Web UI",
+        service_type="daemon",
+        description="Embedded dev dashboard — runs, health, manifest, identity.",
+        cwd=DEV_HOME,
+        pid_file=UI_PID_FILE,
+        log_file=LOG_DIR / "ui.log",
+        allowed_actions=["start", "stop", "restart", "status"],
+    ),
+}
+
+
+def _default_state() -> Dict:
+    return {"services": {sid: {
+        "service_id": sid,
+        "status": "stopped",
+        "pid": None,
+        "exit_code": None,
+        "started_at": None,
+        "updated_at": None,
+        "last_error": None,
+    } for sid in SERVICE_SPECS}}
+
+
+class PMFKernelError(Exception):
+    pass
+
+
+class PMFKernel:
+    def __init__(self) -> None:
+        self.state_path = RUNTIME_FILE
+        self.state = self._load_state()
+
+    def _load_state(self) -> Dict:
+        if self.state_path.exists():
+            try:
+                return json.loads(self.state_path.read_text())
+            except Exception:
+                pass
+        state = _default_state()
+        self._save_state(state)
+        return state
+
+    def _save_state(self, state: Optional[Dict] = None) -> None:
+        if state is None:
+            state = self.state
+        self.state_path.write_text(json.dumps(state, indent=2))
+
+    def _is_alive(self, pid: int) -> bool:
+        try:
+            os.kill(pid, 0)
+            return True
+        except OSError:
+            return False
+
+    def _refresh(self, service_id: str) -> Dict:
+        spec = SERVICE_SPECS[service_id]
+        state = self.state["services"][service_id]
+
+        pid = state.get("pid")
+        if pid and self._is_alive(pid):
+            if state["status"] not in ("running", "starting"):
+                state["status"] = "running"
+                state["updated_at"] = _now_iso()
+            return state
+
+        if spec.pid_file and spec.pid_file.exists():
+            try:
+                file_pid = int(spec.pid_file.read_text().strip())
+                if self._is_alive(file_pid):
+                    state["pid"] = file_pid
+                    state["status"] = "running"
+                    state["updated_at"] = _now_iso()
+                    self._save_state()
+                    return state
+            except Exception:
+                pass
+
+        if pid and not self._is_alive(pid):
+            state["status"] = "stopped"
+            state["pid"] = None
+            self._save_state()
+
+        return state
+
+    def _spec(self, service_id: str) -> ServiceSpec:
+        spec = SERVICE_SPECS.get(service_id)
+        if not spec:
+            raise PMFKernelError(f"Unknown service: {service_id}")
+        return spec
+
+    def services(self) -> List[Dict]:
+        results = []
+        for sid in SERVICE_SPECS:
+            spec = SERVICE_SPECS[sid]
+            state = self._refresh(sid)
+            results.append({
+                "service_id": sid,
+                "label": spec.label,
+                "description": spec.description,
+                "service_type": spec.service_type,
+                "status": state["status"],
+                "pid": state.get("pid"),
+                "exit_code": state.get("exit_code"),
+                "started_at": state.get("started_at"),
+                "updated_at": state.get("updated_at"),
+                "log_file": str(spec.log_file) if spec.log_file else None,
+                "allowed_actions": spec.allowed_actions,
+            })
+        return results
+
+    def service_status(self, service_id: str) -> Dict:
+        spec = self._spec(service_id)
+        state = self._refresh(service_id)
+        return {
+            "service_id": service_id,
+            "label": spec.label,
+            "description": spec.description,
+            "service_type": spec.service_type,
+            "status": state["status"],
+            "pid": state.get("pid"),
+            "exit_code": state.get("exit_code"),
+            "started_at": state.get("started_at"),
+            "updated_at": state.get("updated_at"),
+            "log_file": str(spec.log_file) if spec.log_file else None,
+            "allowed_actions": spec.allowed_actions,
+        }
+
+    def start_service(self, service_id: str, options: Optional[Dict[str, str]] = None) -> Dict:
+        spec = self._spec(service_id)
+        state = self.state["services"][service_id]
+
+        if spec.pid_file and spec.pid_file.exists():
+            try:
+                existing_pid = int(spec.pid_file.read_text().strip())
+                if self._is_alive(existing_pid):
+                    raise PMFKernelError(f"{spec.label} is already running (pid={existing_pid})")
+                spec.pid_file.unlink(missing_ok=True)
+            except ValueError:
+                spec.pid_file.unlink(missing_ok=True)
+
+        command = spec.build_command(options or {})
+        log_file = spec.log_file or LOG_DIR / f"{service_id}.log"
+
+        with open(log_file, "a") as fh:
+            proc = subprocess.Popen(
+                command,
+                cwd=str(spec.cwd or DEV_HOME),
+                env={**os.environ, **(spec.env or {})},
+                stdout=fh,
+                stderr=fh,
+                preexec_fn=os.setsid,
+            )
+
+        state["pid"] = proc.pid
+        state["status"] = "starting"
+        state["started_at"] = _now_iso()
+        state["exit_code"] = None
+        state["last_error"] = None
+        state["updated_at"] = _now_iso()
+        self._save_state()
+
+        # Wait briefly for pid file
+        if spec.pid_file:
+            for _ in range(12):
+                if spec.pid_file.exists():
+                    try:
+                        pid = int(spec.pid_file.read_text().strip())
+                        if self._is_alive(pid):
+                            state["pid"] = pid
+                            state["status"] = "running"
+                            state["updated_at"] = _now_iso()
+                            self._save_state()
+                            return self.service_status(service_id)
+                    except Exception:
+                        pass
+                time.sleep(0.25)
+            # Write pid ourselves if server didn't
+            if self._is_alive(proc.pid):
+                try:
+                    spec.pid_file.write_text(str(proc.pid))
+                    state["pid"] = proc.pid
+                except Exception:
+                    pass
+
+        state["status"] = "running"
+        self._save_state()
+        return self.service_status(service_id)
+
+    def stop_service(self, service_id: str) -> Dict:
+        spec = self._spec(service_id)
+        state = self.state["services"][service_id]
+
+        pid = None
+        if spec.pid_file and spec.pid_file.exists():
+            try:
+                pid = int(spec.pid_file.read_text().strip())
+            except Exception:
+                pass
+        if pid is None:
+            pid = state.get("pid")
+        if pid is None:
+            raise PMFKernelError(f"No running PID found for {spec.label}")
+
+        if not self._is_alive(pid):
+            state["status"] = "stopped"
+            state["pid"] = None
+            self._save_state()
+            return self.service_status(service_id)
+
+        try:
+            os.kill(pid, signal.SIGTERM)
+            time.sleep(0.5)
+        except OSError as exc:
+            raise PMFKernelError(f"Failed to stop {spec.label}: {exc}")
+
+        if spec.pid_file and spec.pid_file.exists():
+            spec.pid_file.unlink(missing_ok=True)
+
+        state["status"] = "stopped"
+        state["pid"] = None
+        state["updated_at"] = _now_iso()
+        self._save_state()
+        return self.service_status(service_id)
+
+    def restart_service(self, service_id: str, options: Optional[Dict[str, str]] = None) -> Dict:
+        try:
+            self.stop_service(service_id)
+        except PMFKernelError:
+            pass
+        time.sleep(0.5)
+        return self.start_service(service_id, options=options or {})
+
+    def tail_log(self, service_id: str, lines: int = 200) -> str:
+        spec = self._spec(service_id)
+        if not spec.log_file or not spec.log_file.exists():
+            return ""
+        with open(spec.log_file, "rb") as fh:
+            fh.seek(0, os.SEEK_END)
+            pos = fh.tell()
+            chunk = bytearray()
+            while pos > 0 and len(chunk) < 8192 * lines:
+                step = min(4096, pos)
+                pos -= step
+                fh.seek(pos)
+                chunk[:0] = fh.read(step)
+                if chunk.count(b"\n") > lines:
+                    break
+            text = chunk.decode("utf-8", errors="replace")
+        return "\n".join(text.strip().splitlines()[-lines:])