feed-the-machine 1.5.0 → 1.6.0

package/ftm-inbox/backend/db/connection.py

@@ -1,54 +1,54 @@
-"""
-SQLite connection helper for ftm-inbox.
-
-Uses WAL journal mode for better read concurrency and sets a sensible
-busy timeout so concurrent writer contention fails gracefully rather
-than immediately.
-"""
-
-import sqlite3
-import threading
-from pathlib import Path
-
-_local = threading.local()
-
-DEFAULT_DB_PATH = Path(__file__).resolve().parent.parent.parent / "ftm-inbox.db"
-
-
-def get_connection(db_path: Path | None = None) -> sqlite3.Connection:
-    """
-    Return a thread-local SQLite connection.
-
-    The connection is configured with:
-      - WAL journal mode for concurrent reads during writes
-      - 5-second busy timeout to handle writer contention
-      - Row factory set to sqlite3.Row for dict-like access
-      - Foreign keys enabled
-    """
-    path = db_path or DEFAULT_DB_PATH
-
-    if not hasattr(_local, "conn") or _local.conn is None:
-        _local.conn = _open_connection(path)
-
-    return _local.conn
-
-
-def _open_connection(path: Path) -> sqlite3.Connection:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    conn = sqlite3.connect(str(path), check_same_thread=False)
-    conn.row_factory = sqlite3.Row
-
-    conn.execute("PRAGMA journal_mode=WAL")
-    conn.execute("PRAGMA busy_timeout=5000")
-    conn.execute("PRAGMA foreign_keys=ON")
-    conn.execute("PRAGMA synchronous=NORMAL")
-    conn.commit()
-
-    return conn
-
-
-def close_connection() -> None:
-    """Close the thread-local connection if open."""
-    if hasattr(_local, "conn") and _local.conn is not None:
-        _local.conn.close()
-        _local.conn = None
+"""
+SQLite connection helper for ftm-inbox.
+
+Uses WAL journal mode for better read concurrency and sets a sensible
+busy timeout so concurrent writer contention fails gracefully rather
+than immediately.
+"""
+
+import sqlite3
+import threading
+from pathlib import Path
+
+_local = threading.local()
+
+DEFAULT_DB_PATH = Path(__file__).resolve().parent.parent.parent / "ftm-inbox.db"
+
+
+def get_connection(db_path: Path | None = None) -> sqlite3.Connection:
+    """
+    Return a thread-local SQLite connection.
+
+    The connection is configured with:
+      - WAL journal mode for concurrent reads during writes
+      - 5-second busy timeout to handle writer contention
+      - Row factory set to sqlite3.Row for dict-like access
+      - Foreign keys enabled
+    """
+    path = db_path or DEFAULT_DB_PATH
+
+    if not hasattr(_local, "conn") or _local.conn is None:
+        _local.conn = _open_connection(path)
+
+    return _local.conn
+
+
+def _open_connection(path: Path) -> sqlite3.Connection:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(str(path), check_same_thread=False)
+    conn.row_factory = sqlite3.Row
+
+    conn.execute("PRAGMA journal_mode=WAL")
+    conn.execute("PRAGMA busy_timeout=5000")
+    conn.execute("PRAGMA foreign_keys=ON")
+    conn.execute("PRAGMA synchronous=NORMAL")
+    conn.commit()
+
+    return conn
+
+
+def close_connection() -> None:
+    """Close the thread-local connection if open."""
+    if hasattr(_local, "conn") and _local.conn is not None:
+        _local.conn.close()
+        _local.conn = None

package/ftm-inbox/backend/db/schema.py

@@ -1,78 +1,78 @@
-"""
-SQLite schema definitions for ftm-inbox.
-
-Tables:
-  - inbox       : normalized items from all pollers
-  - events      : raw event log from all sources
-  - plans       : structured YAML plans linked to inbox tasks
-  - audit_log   : immutable record of every mutation performed by the executor
-"""
-
-SCHEMA_SQL = """
-CREATE TABLE IF NOT EXISTS inbox (
-    id              INTEGER PRIMARY KEY AUTOINCREMENT,
-    source          TEXT NOT NULL,
-    source_id       TEXT NOT NULL,
-    title           TEXT NOT NULL DEFAULT '',
-    body            TEXT NOT NULL DEFAULT '',
-    status          TEXT NOT NULL DEFAULT 'open',
-    priority        TEXT NOT NULL DEFAULT 'medium',
-    assignee        TEXT,
-    requester       TEXT,
-    created_at      TEXT,
-    updated_at      TEXT,
-    tags            TEXT NOT NULL DEFAULT '[]',
-    custom_fields   TEXT NOT NULL DEFAULT '{}',
-    raw_payload     TEXT NOT NULL DEFAULT '{}',
-    source_url      TEXT,
-    content_hash    TEXT NOT NULL UNIQUE,
-    ingested_at     TEXT NOT NULL DEFAULT (datetime('now'))
-);
-
-CREATE INDEX IF NOT EXISTS idx_inbox_source ON inbox(source);
-CREATE INDEX IF NOT EXISTS idx_inbox_status ON inbox(status);
-CREATE INDEX IF NOT EXISTS idx_inbox_content_hash ON inbox(content_hash);
-
-CREATE TABLE IF NOT EXISTS events (
-    id          INTEGER PRIMARY KEY AUTOINCREMENT,
-    type        TEXT NOT NULL,
-    payload     TEXT NOT NULL DEFAULT '{}',
-    created_at  TEXT NOT NULL DEFAULT (datetime('now'))
-);
-
-CREATE INDEX IF NOT EXISTS idx_events_type ON events(type);
-CREATE INDEX IF NOT EXISTS idx_events_created_at ON events(created_at);
-
-CREATE TABLE IF NOT EXISTS plans (
-    id              INTEGER PRIMARY KEY AUTOINCREMENT,
-    task_id         INTEGER NOT NULL REFERENCES inbox(id) ON DELETE CASCADE,
-    yaml_content    TEXT NOT NULL,
-    status          TEXT NOT NULL DEFAULT 'draft',
-    created_at      TEXT NOT NULL DEFAULT (datetime('now')),
-    updated_at      TEXT NOT NULL DEFAULT (datetime('now'))
-);
-
-CREATE INDEX IF NOT EXISTS idx_plans_task_id ON plans(task_id);
-CREATE INDEX IF NOT EXISTS idx_plans_status ON plans(status);
-
-CREATE TABLE IF NOT EXISTS audit_log (
-    id                  INTEGER PRIMARY KEY AUTOINCREMENT,
-    step_id             TEXT NOT NULL,
-    action_type         TEXT NOT NULL,
-    target_system       TEXT NOT NULL,
-    target_object       TEXT NOT NULL,
-    mutation_performed  TEXT NOT NULL,
-    result              TEXT NOT NULL DEFAULT '{}',
-    rollback_available  INTEGER NOT NULL DEFAULT 0,
-    created_at          TEXT NOT NULL DEFAULT (datetime('now'))
-);
-
-CREATE INDEX IF NOT EXISTS idx_audit_step_id ON audit_log(step_id);
-CREATE INDEX IF NOT EXISTS idx_audit_action_type ON audit_log(action_type);
-"""
-
-
-def initialize_schema(conn) -> None:
-    """Execute all CREATE TABLE and CREATE INDEX statements."""
-    conn.executescript(SCHEMA_SQL)
-    conn.commit()
+"""
+SQLite schema definitions for ftm-inbox.
+
+Tables:
+  - inbox       : normalized items from all pollers
+  - events      : raw event log from all sources
+  - plans       : structured YAML plans linked to inbox tasks
+  - audit_log   : immutable record of every mutation performed by the executor
+"""
+
+SCHEMA_SQL = """
+CREATE TABLE IF NOT EXISTS inbox (
+    id              INTEGER PRIMARY KEY AUTOINCREMENT,
+    source          TEXT NOT NULL,
+    source_id       TEXT NOT NULL,
+    title           TEXT NOT NULL DEFAULT '',
+    body            TEXT NOT NULL DEFAULT '',
+    status          TEXT NOT NULL DEFAULT 'open',
+    priority        TEXT NOT NULL DEFAULT 'medium',
+    assignee        TEXT,
+    requester       TEXT,
+    created_at      TEXT,
+    updated_at      TEXT,
+    tags            TEXT NOT NULL DEFAULT '[]',
+    custom_fields   TEXT NOT NULL DEFAULT '{}',
+    raw_payload     TEXT NOT NULL DEFAULT '{}',
+    source_url      TEXT,
+    content_hash    TEXT NOT NULL UNIQUE,
+    ingested_at     TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_inbox_source ON inbox(source);
+CREATE INDEX IF NOT EXISTS idx_inbox_status ON inbox(status);
+CREATE INDEX IF NOT EXISTS idx_inbox_content_hash ON inbox(content_hash);
+
+CREATE TABLE IF NOT EXISTS events (
+    id          INTEGER PRIMARY KEY AUTOINCREMENT,
+    type        TEXT NOT NULL,
+    payload     TEXT NOT NULL DEFAULT '{}',
+    created_at  TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_events_type ON events(type);
+CREATE INDEX IF NOT EXISTS idx_events_created_at ON events(created_at);
+
+CREATE TABLE IF NOT EXISTS plans (
+    id              INTEGER PRIMARY KEY AUTOINCREMENT,
+    task_id         INTEGER NOT NULL REFERENCES inbox(id) ON DELETE CASCADE,
+    yaml_content    TEXT NOT NULL,
+    status          TEXT NOT NULL DEFAULT 'draft',
+    created_at      TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at      TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_plans_task_id ON plans(task_id);
+CREATE INDEX IF NOT EXISTS idx_plans_status ON plans(status);
+
+CREATE TABLE IF NOT EXISTS audit_log (
+    id                  INTEGER PRIMARY KEY AUTOINCREMENT,
+    step_id             TEXT NOT NULL,
+    action_type         TEXT NOT NULL,
+    target_system       TEXT NOT NULL,
+    target_object       TEXT NOT NULL,
+    mutation_performed  TEXT NOT NULL,
+    result              TEXT NOT NULL DEFAULT '{}',
+    rollback_available  INTEGER NOT NULL DEFAULT 0,
+    created_at          TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_audit_step_id ON audit_log(step_id);
+CREATE INDEX IF NOT EXISTS idx_audit_action_type ON audit_log(action_type);
+"""
+
+
+def initialize_schema(conn) -> None:
+    """Execute all CREATE TABLE and CREATE INDEX statements."""
+    conn.executescript(SCHEMA_SQL)
+    conn.commit()

package/ftm-inbox/backend/executor/__init__.py

@@ -1,7 +1,7 @@
-"""
-Execution engine package for ftm-inbox.
-
-Components:
-  - engine.py     : ExecutionEngine — orchestrates sequential step execution
-  - step_runner.py: StepRunner — executes a single plan step via Claude CLI
-"""
+"""
+Execution engine package for ftm-inbox.
+
+Components:
+  - engine.py     : ExecutionEngine — orchestrates sequential step execution
+  - step_runner.py: StepRunner — executes a single plan step via Claude CLI
+"""

package/ftm-inbox/backend/executor/engine.py

@@ -1,149 +1,149 @@
-"""
-ExecutionEngine — orchestrates sequential execution of approved plan steps.
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-from datetime import datetime, timezone
-from typing import Any, Callable
-
-from backend.db.connection import get_connection
-from backend.executor.step_runner import StepRunner
-
-logger = logging.getLogger(__name__)
-
-
-class ExecutionEngine:
-    """Executes approved plan steps in sequence with pause/resume support."""
-
-    def __init__(self, task_id: int, plan_id: int) -> None:
-        self.task_id = task_id
-        self.plan_id = plan_id
-        self._paused = False
-        self._callbacks: list[Callable[[str], None]] = []
-        self._invocation_count = 0
-
-    def on_output(self, callback: Callable[[str], None]) -> None:
-        """Register a callback for streaming output."""
-        self._callbacks.append(callback)
-
-    def pause(self) -> None:
-        self._paused = True
-
-    def resume(self) -> None:
-        self._paused = False
-
-    def _emit(self, text: str) -> None:
-        for cb in self._callbacks:
-            try:
-                cb(text)
-            except Exception:
-                pass
-
-    async def execute(self) -> dict[str, Any]:
-        """Execute all approved steps in sequence."""
-        conn = get_connection()
-        steps = self._load_approved_steps(conn)
-        task_context = self._load_task_context(conn)
-
-        if not steps:
-            return {"status": "no_steps", "message": "No approved steps to execute"}
-
-        self._update_plan_status(conn, "executing")
-        results: list[dict] = []
-
-        for step in steps:
-            if self._paused:
-                self._emit("Execution paused. Use resume to continue.")
-                return {"status": "paused", "last_step_id": step["id"], "results": results}
-
-            step_id = step["id"]
-            self._update_step_status(conn, step_id, "running")
-            self._emit(f"Step {step_id}: {step.get('title', '...')}")
-
-            result = await StepRunner.run(step, task_context)
-            self._invocation_count += 1
-            results.append({"step_id": step_id, **result})
-
-            if result["status"] == "completed":
-                self._update_step_status(conn, step_id, "completed")
-                self._log_audit(conn, step, result)
-                self._emit(f"Step {step_id} completed ({result['duration_ms']}ms)")
-            else:
-                self._update_step_status(conn, step_id, "failed")
-                self._mark_dependents_blocked(conn, step_id, steps)
-                self._log_audit(conn, step, result)
-                self._emit(f"Step {step_id} failed: {result.get('error', 'unknown')}")
-                self._update_plan_status(conn, "failed")
-                return {"status": "failed", "failed_step": step_id, "results": results}
-
-        self._update_plan_status(conn, "completed")
-        self._emit(f"Execution complete. {len(steps)} steps, {self._invocation_count} CLI invocations.")
-        return {"status": "completed", "results": results, "invocations": self._invocation_count}
-
-    def _load_approved_steps(self, conn) -> list[dict]:
-        row = conn.execute(
-            "SELECT yaml_content FROM plans WHERE id = ?", (self.plan_id,)
-        ).fetchone()
-        if not row:
-            return []
-        import yaml
-        plan_data = yaml.safe_load(row["yaml_content"]) or {}
-        steps = plan_data.get("steps", [])
-        return [s for s in steps if s.get("status") in ("approved", "pending")]
-
-    def _load_task_context(self, conn) -> dict:
-        row = conn.execute(
-            "SELECT * FROM inbox WHERE id = ?", (self.task_id,)
-        ).fetchone()
-        return dict(row) if row else {}
-
-    def _update_step_status(self, conn, step_id: int, status: str) -> None:
-        row = conn.execute(
-            "SELECT yaml_content FROM plans WHERE id = ?", (self.plan_id,)
-        ).fetchone()
-        if not row:
-            return
-        import yaml
-        plan_data = yaml.safe_load(row["yaml_content"]) or {}
-        for step in plan_data.get("steps", []):
-            if step.get("id") == step_id:
-                step["status"] = status
-        updated = yaml.dump(plan_data, default_flow_style=False)
-        conn.execute(
-            "UPDATE plans SET yaml_content = ?, updated_at = datetime('now') WHERE id = ?",
-            (updated, self.plan_id),
-        )
-        conn.commit()
-
-    def _update_plan_status(self, conn, status: str) -> None:
-        conn.execute(
-            "UPDATE plans SET status = ?, updated_at = datetime('now') WHERE id = ?",
-            (status, self.plan_id),
-        )
-        conn.commit()
-
-    def _mark_dependents_blocked(self, conn, failed_step_id: int, all_steps: list[dict]) -> None:
-        for step in all_steps:
-            if step.get("id", 0) > failed_step_id and step.get("status") != "completed":
-                self._update_step_status(conn, step["id"], "blocked")
-
-    def _log_audit(self, conn, step: dict, result: dict) -> None:
-        conn.execute(
-            """INSERT INTO audit_log
-               (step_id, action_type, target_system, target_object,
-                mutation_performed, result, rollback_available)
-            VALUES (?, ?, ?, ?, ?, ?, ?)""",
-            (
-                str(step.get("id", "")),
-                "execute_step",
-                step.get("target_system", ""),
-                step.get("title", ""),
-                result.get("output", "")[:500],
-                json.dumps({"status": result["status"], "duration_ms": result.get("duration_ms", 0)}),
-                1 if step.get("rollback") else 0,
-            ),
-        )
-        conn.commit()
+"""
+ExecutionEngine — orchestrates sequential execution of approved plan steps.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from datetime import datetime, timezone
+from typing import Any, Callable
+
+from backend.db.connection import get_connection
+from backend.executor.step_runner import StepRunner
+
+logger = logging.getLogger(__name__)
+
+
+class ExecutionEngine:
+    """Executes approved plan steps in sequence with pause/resume support."""
+
+    def __init__(self, task_id: int, plan_id: int) -> None:
+        self.task_id = task_id
+        self.plan_id = plan_id
+        self._paused = False
+        self._callbacks: list[Callable[[str], None]] = []
+        self._invocation_count = 0
+
+    def on_output(self, callback: Callable[[str], None]) -> None:
+        """Register a callback for streaming output."""
+        self._callbacks.append(callback)
+
+    def pause(self) -> None:
+        self._paused = True
+
+    def resume(self) -> None:
+        self._paused = False
+
+    def _emit(self, text: str) -> None:
+        for cb in self._callbacks:
+            try:
+                cb(text)
+            except Exception:
+                pass
+
+    async def execute(self) -> dict[str, Any]:
+        """Execute all approved steps in sequence."""
+        conn = get_connection()
+        steps = self._load_approved_steps(conn)
+        task_context = self._load_task_context(conn)
+
+        if not steps:
+            return {"status": "no_steps", "message": "No approved steps to execute"}
+
+        self._update_plan_status(conn, "executing")
+        results: list[dict] = []
+
+        for step in steps:
+            if self._paused:
+                self._emit("Execution paused. Use resume to continue.")
+                return {"status": "paused", "last_step_id": step["id"], "results": results}
+
+            step_id = step["id"]
+            self._update_step_status(conn, step_id, "running")
+            self._emit(f"Step {step_id}: {step.get('title', '...')}")
+
+            result = await StepRunner.run(step, task_context)
+            self._invocation_count += 1
+            results.append({"step_id": step_id, **result})
+
+            if result["status"] == "completed":
+                self._update_step_status(conn, step_id, "completed")
+                self._log_audit(conn, step, result)
+                self._emit(f"Step {step_id} completed ({result['duration_ms']}ms)")
+            else:
+                self._update_step_status(conn, step_id, "failed")
+                self._mark_dependents_blocked(conn, step_id, steps)
+                self._log_audit(conn, step, result)
+                self._emit(f"Step {step_id} failed: {result.get('error', 'unknown')}")
+                self._update_plan_status(conn, "failed")
+                return {"status": "failed", "failed_step": step_id, "results": results}
+
+        self._update_plan_status(conn, "completed")
+        self._emit(f"Execution complete. {len(steps)} steps, {self._invocation_count} CLI invocations.")
+        return {"status": "completed", "results": results, "invocations": self._invocation_count}
+
+    def _load_approved_steps(self, conn) -> list[dict]:
+        row = conn.execute(
+            "SELECT yaml_content FROM plans WHERE id = ?", (self.plan_id,)
+        ).fetchone()
+        if not row:
+            return []
+        import yaml
+        plan_data = yaml.safe_load(row["yaml_content"]) or {}
+        steps = plan_data.get("steps", [])
+        return [s for s in steps if s.get("status") in ("approved", "pending")]
+
+    def _load_task_context(self, conn) -> dict:
+        row = conn.execute(
+            "SELECT * FROM inbox WHERE id = ?", (self.task_id,)
+        ).fetchone()
+        return dict(row) if row else {}
+
+    def _update_step_status(self, conn, step_id: int, status: str) -> None:
+        row = conn.execute(
+            "SELECT yaml_content FROM plans WHERE id = ?", (self.plan_id,)
+        ).fetchone()
+        if not row:
+            return
+        import yaml
+        plan_data = yaml.safe_load(row["yaml_content"]) or {}
+        for step in plan_data.get("steps", []):
+            if step.get("id") == step_id:
+                step["status"] = status
+        updated = yaml.dump(plan_data, default_flow_style=False)
+        conn.execute(
+            "UPDATE plans SET yaml_content = ?, updated_at = datetime('now') WHERE id = ?",
+            (updated, self.plan_id),
+        )
+        conn.commit()
+
+    def _update_plan_status(self, conn, status: str) -> None:
+        conn.execute(
+            "UPDATE plans SET status = ?, updated_at = datetime('now') WHERE id = ?",
+            (status, self.plan_id),
+        )
+        conn.commit()
+
+    def _mark_dependents_blocked(self, conn, failed_step_id: int, all_steps: list[dict]) -> None:
+        for step in all_steps:
+            if step.get("id", 0) > failed_step_id and step.get("status") != "completed":
+                self._update_step_status(conn, step["id"], "blocked")
+
+    def _log_audit(self, conn, step: dict, result: dict) -> None:
+        conn.execute(
+            """INSERT INTO audit_log
+               (step_id, action_type, target_system, target_object,
+                mutation_performed, result, rollback_available)
+            VALUES (?, ?, ?, ?, ?, ?, ?)""",
+            (
+                str(step.get("id", "")),
+                "execute_step",
+                step.get("target_system", ""),
+                step.get("title", ""),
+                result.get("output", "")[:500],
+                json.dumps({"status": result["status"], "duration_ms": result.get("duration_ms", 0)}),
+                1 if step.get("rollback") else 0,
+            ),
+        )
+        conn.commit()