feed-the-machine 1.5.0 → 1.6.0

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

@@ -1,98 +1,98 @@
-"""
-StepRunner — executes a single plan step via Claude CLI.
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-import subprocess
-import time
-from typing import Any
-
-logger = logging.getLogger(__name__)
-
-_STEP_TIMEOUT = 120  # seconds
-
-
-class StepRunner:
-    """Runs a single plan step by invoking Claude CLI."""
-
-    @staticmethod
-    async def run(step: dict, task_context: dict) -> dict[str, Any]:
-        """
-        Execute a plan step and return structured result.
-
-        Returns:
-            {"status": "completed"|"failed", "output": str, "error": str, "duration_ms": int}
-        """
-        prompt = (
-            f"Execute this plan step:\n\n"
-            f"Step: {step.get('title', '')}\n"
-            f"Target system: {step.get('target_system', 'local')}\n"
-            f"Method: {step.get('method_primary', '')}\n"
-            f"Fallback: {step.get('method_fallback', '')}\n\n"
-            f"Task context:\n"
-            f"Title: {task_context.get('title', '')}\n"
-            f"Source: {task_context.get('source', '')}\n"
-            f"Body: {task_context.get('body', '')}\n\n"
-            f"Execute the step and report what was done. "
-            f"If the action cannot be performed, explain why."
-        )
-
-        start = time.monotonic()
-        try:
-            result = subprocess.run(
-                ["claude", "-p", prompt, "--output-format", "json"],
-                capture_output=True,
-                text=True,
-                timeout=_STEP_TIMEOUT,
-            )
-            duration_ms = int((time.monotonic() - start) * 1000)
-
-            if result.returncode != 0:
-                return {
-                    "status": "failed",
-                    "output": result.stdout,
-                    "error": result.stderr or f"Exit code {result.returncode}",
-                    "duration_ms": duration_ms,
-                }
-
-            # Parse Claude JSON output
-            try:
-                data = json.loads(result.stdout)
-                text = data.get("result", result.stdout)
-            except json.JSONDecodeError:
-                text = result.stdout
-
-            return {
-                "status": "completed",
-                "output": text,
-                "error": "",
-                "duration_ms": duration_ms,
-            }
-
-        except subprocess.TimeoutExpired:
-            duration_ms = int((time.monotonic() - start) * 1000)
-            return {
-                "status": "failed",
-                "output": "",
-                "error": f"Step timed out after {_STEP_TIMEOUT}s",
-                "duration_ms": duration_ms,
-            }
-        except FileNotFoundError:
-            duration_ms = int((time.monotonic() - start) * 1000)
-            return {
-                "status": "failed",
-                "output": "",
-                "error": "Claude CLI not found on PATH",
-                "duration_ms": duration_ms,
-            }
-        except Exception as exc:
-            duration_ms = int((time.monotonic() - start) * 1000)
-            return {
-                "status": "failed",
-                "output": "",
-                "error": str(exc),
-                "duration_ms": duration_ms,
-            }
+"""
+StepRunner — executes a single plan step via Claude CLI.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import subprocess
+import time
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+_STEP_TIMEOUT = 120  # seconds
+
+
+class StepRunner:
+    """Runs a single plan step by invoking Claude CLI."""
+
+    @staticmethod
+    async def run(step: dict, task_context: dict) -> dict[str, Any]:
+        """
+        Execute a plan step and return structured result.
+
+        Returns:
+            {"status": "completed"|"failed", "output": str, "error": str, "duration_ms": int}
+        """
+        prompt = (
+            f"Execute this plan step:\n\n"
+            f"Step: {step.get('title', '')}\n"
+            f"Target system: {step.get('target_system', 'local')}\n"
+            f"Method: {step.get('method_primary', '')}\n"
+            f"Fallback: {step.get('method_fallback', '')}\n\n"
+            f"Task context:\n"
+            f"Title: {task_context.get('title', '')}\n"
+            f"Source: {task_context.get('source', '')}\n"
+            f"Body: {task_context.get('body', '')}\n\n"
+            f"Execute the step and report what was done. "
+            f"If the action cannot be performed, explain why."
+        )
+
+        start = time.monotonic()
+        try:
+            result = subprocess.run(
+                ["claude", "-p", prompt, "--output-format", "json"],
+                capture_output=True,
+                text=True,
+                timeout=_STEP_TIMEOUT,
+            )
+            duration_ms = int((time.monotonic() - start) * 1000)
+
+            if result.returncode != 0:
+                return {
+                    "status": "failed",
+                    "output": result.stdout,
+                    "error": result.stderr or f"Exit code {result.returncode}",
+                    "duration_ms": duration_ms,
+                }
+
+            # Parse Claude JSON output
+            try:
+                data = json.loads(result.stdout)
+                text = data.get("result", result.stdout)
+            except json.JSONDecodeError:
+                text = result.stdout
+
+            return {
+                "status": "completed",
+                "output": text,
+                "error": "",
+                "duration_ms": duration_ms,
+            }
+
+        except subprocess.TimeoutExpired:
+            duration_ms = int((time.monotonic() - start) * 1000)
+            return {
+                "status": "failed",
+                "output": "",
+                "error": f"Step timed out after {_STEP_TIMEOUT}s",
+                "duration_ms": duration_ms,
+            }
+        except FileNotFoundError:
+            duration_ms = int((time.monotonic() - start) * 1000)
+            return {
+                "status": "failed",
+                "output": "",
+                "error": "Claude CLI not found on PATH",
+                "duration_ms": duration_ms,
+            }
+        except Exception as exc:
+            duration_ms = int((time.monotonic() - start) * 1000)
+            return {
+                "status": "failed",
+                "output": "",
+                "error": str(exc),
+                "duration_ms": duration_ms,
+            }

package/ftm-inbox/backend/main.py

@@ -1,103 +1,103 @@
-"""
-ftm-inbox FastAPI application entry point.
-
-Default port: 8042 (override via FTM_INBOX_PORT env var).
-
-Startup sequence:
-  1. Open SQLite connection (WAL mode)
-  2. Initialize schema (idempotent CREATE TABLE IF NOT EXISTS)
-  3. Load adapter registry from config.yml (warn if missing, don't crash)
-  4. Register API routes
-
-CORS allows all localhost origins for development.
-"""
-
-import logging
-import os
-
-from fastapi import FastAPI
-from fastapi.middleware.cors import CORSMiddleware
-
-from backend.db.connection import get_connection
-from backend.db.schema import initialize_schema
-from backend.routes.health import router as health_router
-from backend.routes.inbox import router as inbox_router
-from backend.routes.plan import router as plan_router
-from backend.routes.execute import router as execute_router
-
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s  %(levelname)-8s  %(name)s  %(message)s",
-)
-logger = logging.getLogger("ftm-inbox")
-
-app = FastAPI(
-    title="FTM Inbox",
-    description="Operator Cockpit backend — aggregates tasks from all connected sources.",
-    version="0.1.0",
-)
-
-# CORS: allow all localhost origins (frontend dev server + any local tooling)
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=[
-        "http://localhost:5173",
-        "http://localhost:3000",
-        "http://127.0.0.1:5173",
-        "http://127.0.0.1:3000",
-    ],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# ---------------------------------------------------------------------------
-# Startup
-# ---------------------------------------------------------------------------
-
-@app.on_event("startup")
-async def startup() -> None:
-    logger.info("Starting ftm-inbox backend…")
-
-    # 1. Open DB and initialize schema
-    conn = get_connection()
-    initialize_schema(conn)
-    logger.info("Database initialized.")
-
-    # 2. Load adapter registry (non-fatal if config.yml is missing)
-    try:
-        from backend.adapters.registry import AdapterRegistry
-        registry = AdapterRegistry.from_config()
-        app.state.adapter_registry = registry
-        logger.info("Adapter registry loaded: %s", registry)
-    except Exception as exc:
-        logger.warning("Adapter registry failed to load: %s", exc)
-        app.state.adapter_registry = None
-
-
-@app.on_event("shutdown")
-async def shutdown() -> None:
-    from backend.db.connection import close_connection
-    close_connection()
-    logger.info("Database connection closed.")
-
-
-# ---------------------------------------------------------------------------
-# Routes
-# ---------------------------------------------------------------------------
-
-app.include_router(health_router)
-app.include_router(inbox_router)
-app.include_router(plan_router)
-app.include_router(execute_router)
-
-
-# ---------------------------------------------------------------------------
-# Dev entrypoint
-# ---------------------------------------------------------------------------
-
-if __name__ == "__main__":
-    import uvicorn
-
-    port = int(os.environ.get("FTM_INBOX_PORT", "8042"))
-    uvicorn.run("backend.main:app", host="0.0.0.0", port=port, reload=True)
+"""
+ftm-inbox FastAPI application entry point.
+
+Default port: 8042 (override via FTM_INBOX_PORT env var).
+
+Startup sequence:
+  1. Open SQLite connection (WAL mode)
+  2. Initialize schema (idempotent CREATE TABLE IF NOT EXISTS)
+  3. Load adapter registry from config.yml (warn if missing, don't crash)
+  4. Register API routes
+
+CORS allows all localhost origins for development.
+"""
+
+import logging
+import os
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from backend.db.connection import get_connection
+from backend.db.schema import initialize_schema
+from backend.routes.health import router as health_router
+from backend.routes.inbox import router as inbox_router
+from backend.routes.plan import router as plan_router
+from backend.routes.execute import router as execute_router
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s  %(levelname)-8s  %(name)s  %(message)s",
+)
+logger = logging.getLogger("ftm-inbox")
+
+app = FastAPI(
+    title="FTM Inbox",
+    description="Operator Cockpit backend — aggregates tasks from all connected sources.",
+    version="0.1.0",
+)
+
+# CORS: allow all localhost origins (frontend dev server + any local tooling)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[
+        "http://localhost:5173",
+        "http://localhost:3000",
+        "http://127.0.0.1:5173",
+        "http://127.0.0.1:3000",
+    ],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# ---------------------------------------------------------------------------
+# Startup
+# ---------------------------------------------------------------------------
+
+@app.on_event("startup")
+async def startup() -> None:
+    logger.info("Starting ftm-inbox backend…")
+
+    # 1. Open DB and initialize schema
+    conn = get_connection()
+    initialize_schema(conn)
+    logger.info("Database initialized.")
+
+    # 2. Load adapter registry (non-fatal if config.yml is missing)
+    try:
+        from backend.adapters.registry import AdapterRegistry
+        registry = AdapterRegistry.from_config()
+        app.state.adapter_registry = registry
+        logger.info("Adapter registry loaded: %s", registry)
+    except Exception as exc:
+        logger.warning("Adapter registry failed to load: %s", exc)
+        app.state.adapter_registry = None
+
+
+@app.on_event("shutdown")
+async def shutdown() -> None:
+    from backend.db.connection import close_connection
+    close_connection()
+    logger.info("Database connection closed.")
+
+
+# ---------------------------------------------------------------------------
+# Routes
+# ---------------------------------------------------------------------------
+
+app.include_router(health_router)
+app.include_router(inbox_router)
+app.include_router(plan_router)
+app.include_router(execute_router)
+
+
+# ---------------------------------------------------------------------------
+# Dev entrypoint
+# ---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    import uvicorn
+
+    port = int(os.environ.get("FTM_INBOX_PORT", "8042"))
+    uvicorn.run("backend.main:app", host="0.0.0.0", port=port, reload=True)

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

@@ -1 +1 @@
-"""ftm-inbox data models."""
+"""ftm-inbox data models."""

package/ftm-inbox/backend/models/unified_task.py

@@ -1,36 +1,36 @@
-"""
-UnifiedTask — canonical Pydantic model for a task regardless of source.
-
-This is the read/API-facing model. The write path uses NormalizedItem (a dataclass)
-for speed; UnifiedTask is the model returned to callers and stored as JSON.
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-from pydantic import BaseModel, Field
-
-
-class UnifiedTask(BaseModel):
-    """Single unified representation of a task from any integrated source."""
-
-    id: int | None = None
-    source: str
-    source_id: str
-    title: str
-    body: str = ""
-    status: str = "open"
-    priority: str = "medium"
-    assignee: str | None = None
-    requester: str | None = None
-    created_at: str | None = None
-    updated_at: str | None = None
-    tags: list[str] = Field(default_factory=list)
-    custom_fields: dict[str, Any] = Field(default_factory=dict)
-    raw_payload: dict[str, Any] = Field(default_factory=dict)
-    source_url: str | None = None
-    content_hash: str | None = None
-    ingested_at: str | None = None
-
-    model_config = {"populate_by_name": True}
+"""
+UnifiedTask — canonical Pydantic model for a task regardless of source.
+
+This is the read/API-facing model. The write path uses NormalizedItem (a dataclass)
+for speed; UnifiedTask is the model returned to callers and stored as JSON.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class UnifiedTask(BaseModel):
+    """Single unified representation of a task from any integrated source."""
+
+    id: int | None = None
+    source: str
+    source_id: str
+    title: str
+    body: str = ""
+    status: str = "open"
+    priority: str = "medium"
+    assignee: str | None = None
+    requester: str | None = None
+    created_at: str | None = None
+    updated_at: str | None = None
+    tags: list[str] = Field(default_factory=list)
+    custom_fields: dict[str, Any] = Field(default_factory=dict)
+    raw_payload: dict[str, Any] = Field(default_factory=dict)
+    source_url: str | None = None
+    content_hash: str | None = None
+    ingested_at: str | None = None
+
+    model_config = {"populate_by_name": True}

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

@@ -1,6 +1,6 @@
-"""
-ftm-inbox planner package.
-
-Generates structured YAML execution plans from task payloads via Claude CLI,
-and persists them to SQLite for per-step approval workflows.
-"""
+"""
+ftm-inbox planner package.
+
+Generates structured YAML execution plans from task payloads via Claude CLI,
+and persists them to SQLite for per-step approval workflows.
+"""