feed-the-machine 1.1.0 → 1.3.0

package/ftm-inbox/backend/routes/plan.py

@@ -0,0 +1,271 @@
+"""
+Plan API routes.
+
+Endpoints:
+  POST /api/tasks/{task_id}/generate-plan  — generate a plan via Claude CLI
+  GET  /api/tasks/{task_id}/plan           — fetch the current plan
+  POST /api/tasks/{task_id}/plan/steps/{step_id}/approve  — approve one step
+  POST /api/tasks/{task_id}/plan/approve-all              — approve all low-risk steps
+  GET  /api/tasks/{task_id}/plan-stream    — SSE stream for live generation output
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import sqlite3
+from datetime import datetime, timezone
+from pathlib import Path
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import StreamingResponse
+
+from backend.db.connection import get_connection
+from backend.planner.generator import generate_plan
+from backend.planner.schema import Plan, PlanStep
+
+router = APIRouter(prefix="/api", tags=["plans"])
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+_CAPABILITIES_PATH = Path(__file__).resolve().parent.parent.parent / "config.yml"
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _load_capabilities() -> dict:
+    """Try to load the capabilities section from config.yml.  Non-fatal."""
+    try:
+        import yaml
+        with open(_CAPABILITIES_PATH) as f:
+            cfg = yaml.safe_load(f) or {}
+        return cfg.get("capabilities", {})
+    except Exception:
+        return {}
+
+
+def _fetch_task(conn: sqlite3.Connection, task_id: int) -> dict:
+    row = conn.execute("SELECT * FROM inbox WHERE id = ?", (task_id,)).fetchone()
+    if row is None:
+        raise HTTPException(status_code=404, detail=f"Task {task_id} not found")
+    return dict(row)
+
+
+def _fetch_plan_row(conn: sqlite3.Connection, task_id: int) -> dict | None:
+    row = conn.execute(
+        "SELECT * FROM plans WHERE task_id = ? ORDER BY id DESC LIMIT 1", (task_id,)
+    ).fetchone()
+    return dict(row) if row else None
+
+
+def _row_to_plan(row: dict) -> Plan:
+    """Deserialise a plans table row into a Plan model."""
+    steps_raw = []
+    try:
+        yaml_content = row.get("yaml_content", "")
+        if yaml_content:
+            import yaml as _yaml
+            parsed = _yaml.safe_load(yaml_content) or {}
+            steps_raw = parsed.get("steps", [])
+    except Exception:
+        pass
+
+    steps = [PlanStep(**s) if isinstance(s, dict) else s for s in steps_raw]
+    return Plan(
+        id=row["id"],
+        task_id=row["task_id"],
+        steps=steps,
+        status=row.get("status", "draft"),
+        yaml_content=row.get("yaml_content", ""),
+        created_at=row.get("created_at"),
+        updated_at=row.get("updated_at"),
+    )
+
+
+def _upsert_plan(conn: sqlite3.Connection, task_id: int, yaml_content: str, steps: list[dict]) -> int:
+    """Insert a new plan row (one plan per task, replaced on re-generation)."""
+    # Delete previous plan for this task so we always have a single current plan
+    conn.execute("DELETE FROM plans WHERE task_id = ?", (task_id,))
+    now = _now()
+    cursor = conn.execute(
+        """
+        INSERT INTO plans (task_id, yaml_content, status, created_at, updated_at)
+        VALUES (?, ?, 'draft', ?, ?)
+        """,
+        (task_id, yaml_content, now, now),
+    )
+    conn.commit()
+    return cursor.lastrowid
+
+
+# ---------------------------------------------------------------------------
+# Routes
+# ---------------------------------------------------------------------------
+
+@router.post("/tasks/{task_id}/generate-plan")
+async def generate_plan_for_task(task_id: int):
+    """Generate a plan for a task using Claude CLI and persist it."""
+    conn = get_connection()
+    task = _fetch_task(conn, task_id)
+    capabilities = _load_capabilities()
+
+    # Run in a thread pool so we don't block the event loop during the
+    # potentially long Claude CLI subprocess call.
+    loop = asyncio.get_event_loop()
+    result = await loop.run_in_executor(
+        None, lambda: generate_plan(dict(task), capabilities)
+    )
+
+    if result.get("error") and not result.get("steps"):
+        raise HTTPException(status_code=502, detail=result["error"])
+
+    plan_id = _upsert_plan(conn, task_id, result.get("yaml_content", ""), result.get("steps", []))
+    plan_row = _fetch_plan_row(conn, task_id)
+    plan = _row_to_plan(plan_row)
+
+    return plan.model_dump()
+
+
+@router.get("/tasks/{task_id}/plan")
+async def get_plan(task_id: int):
+    """Fetch the current plan for a task."""
+    conn = get_connection()
+    _fetch_task(conn, task_id)  # 404 if task missing
+    plan_row = _fetch_plan_row(conn, task_id)
+    if plan_row is None:
+        return {"plan": None}
+    return _row_to_plan(plan_row).model_dump()
+
+
+@router.post("/tasks/{task_id}/plan/steps/{step_id}/approve")
+async def approve_step(task_id: int, step_id: int):
+    """Approve a specific plan step."""
+    conn = get_connection()
+    _fetch_task(conn, task_id)
+    plan_row = _fetch_plan_row(conn, task_id)
+    if plan_row is None:
+        raise HTTPException(status_code=404, detail="No plan found for this task")
+
+    import yaml as _yaml
+    yaml_content = plan_row.get("yaml_content", "")
+    plan_data = _yaml.safe_load(yaml_content) or {}
+    steps: list[dict] = plan_data.get("steps", [])
+
+    updated = False
+    for step in steps:
+        if step.get("id") == step_id:
+            step["status"] = "approved"
+            updated = True
+            break
+
+    if not updated:
+        raise HTTPException(status_code=404, detail=f"Step {step_id} not found in plan")
+
+    plan_data["steps"] = steps
+    new_yaml = _yaml.dump(plan_data, default_flow_style=False)
+
+    # Check if all steps are now approved → mark plan approved
+    all_approved = all(s.get("status") == "approved" for s in steps)
+    new_status = "approved" if all_approved else plan_row.get("status", "draft")
+
+    conn.execute(
+        "UPDATE plans SET yaml_content = ?, status = ?, updated_at = ? WHERE id = ?",
+        (new_yaml, new_status, _now(), plan_row["id"]),
+    )
+    conn.commit()
+
+    updated_row = _fetch_plan_row(conn, task_id)
+    return _row_to_plan(updated_row).model_dump()
+
+
+@router.post("/tasks/{task_id}/plan/approve-all")
+async def approve_all_steps(task_id: int):
+    """Approve all low-risk steps at once."""
+    conn = get_connection()
+    _fetch_task(conn, task_id)
+    plan_row = _fetch_plan_row(conn, task_id)
+    if plan_row is None:
+        raise HTTPException(status_code=404, detail="No plan found for this task")
+
+    import yaml as _yaml
+    yaml_content = plan_row.get("yaml_content", "")
+    plan_data = _yaml.safe_load(yaml_content) or {}
+    steps: list[dict] = plan_data.get("steps", [])
+
+    for step in steps:
+        if step.get("risk_level", "low") == "low":
+            step["status"] = "approved"
+
+    plan_data["steps"] = steps
+    new_yaml = _yaml.dump(plan_data, default_flow_style=False)
+
+    all_approved = all(s.get("status") == "approved" for s in steps)
+    new_status = "approved" if all_approved else plan_row.get("status", "draft")
+
+    conn.execute(
+        "UPDATE plans SET yaml_content = ?, status = ?, updated_at = ? WHERE id = ?",
+        (new_yaml, new_status, _now(), plan_row["id"]),
+    )
+    conn.commit()
+
+    updated_row = _fetch_plan_row(conn, task_id)
+    return _row_to_plan(updated_row).model_dump()
+
+
+@router.get("/tasks/{task_id}/plan-stream")
+async def plan_stream(task_id: int):
+    """
+    SSE endpoint that streams plan generation output in real time.
+
+    Emits:
+      - data: {"type": "chunk", "text": "..."}   — incremental output
+      - data: {"type": "done", "plan": {...}}     — final plan after storage
+      - data: {"type": "error", "message": "..."}
+    """
+    conn = get_connection()
+    task = _fetch_task(conn, task_id)
+    capabilities = _load_capabilities()
+
+    async def event_generator():
+        try:
+            yield _sse({"type": "chunk", "text": "Starting plan generation...\n"})
+            yield _sse({"type": "chunk", "text": f"Task: {task['title']}\n"})
+            yield _sse({"type": "chunk", "text": "Invoking Claude CLI...\n"})
+
+            loop = asyncio.get_event_loop()
+            result = await loop.run_in_executor(
+                None, lambda: generate_plan(dict(task), capabilities)
+            )
+
+            if result.get("error") and not result.get("steps"):
+                yield _sse({"type": "error", "message": result["error"]})
+                return
+
+            yield _sse({"type": "chunk", "text": f"Plan generated with {len(result.get('steps', []))} steps.\n"})
+
+            plan_id = _upsert_plan(conn, task_id, result.get("yaml_content", ""), result.get("steps", []))
+            plan_row = _fetch_plan_row(conn, task_id)
+            plan = _row_to_plan(plan_row)
+
+            yield _sse({"type": "done", "plan": plan.model_dump()})
+
+        except Exception as exc:
+            yield _sse({"type": "error", "message": str(exc)})
+
+    return StreamingResponse(
+        event_generator(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "X-Accel-Buffering": "no",
+        },
+    )
+
+
+def _sse(data: dict) -> str:
+    """Format a dict as a Server-Sent Event frame."""
+    return f"data: {json.dumps(data)}\n\n"

package/ftm-inbox/bin/launchagent.mjs

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+
+/**
+ * Generates ~/Library/LaunchAgents/com.ftm.inbox.plist
+ * Runs ftm-inbox on login (macOS only).
+ */
+
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+import { homedir, platform } from "os";
+import { execSync } from "child_process";
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const HOME = homedir();
+const LAUNCH_AGENTS_DIR = join(HOME, "Library", "LaunchAgents");
+const PLIST_PATH = join(LAUNCH_AGENTS_DIR, "com.ftm.inbox.plist");
+const INBOX_CONFIG_DIR = join(HOME, ".claude", "ftm-inbox");
+const START_SCRIPT = join(__dirname, "start.sh");
+
+function ensureDir(dir) {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+
+function buildPlist(startScript, logDir) {
+  return `<?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>com.ftm.inbox</string>
+
+    <key>ProgramArguments</key>
+    <array>
+        <string>/bin/bash</string>
+        <string>${startScript}</string>
+    </array>
+
+    <key>RunAtLoad</key>
+    <true/>
+
+    <key>KeepAlive</key>
+    <false/>
+
+    <key>StandardOutPath</key>
+    <string>${join(logDir, "launchd-stdout.log")}</string>
+
+    <key>StandardErrorPath</key>
+    <string>${join(logDir, "launchd-stderr.log")}</string>
+
+    <key>WorkingDirectory</key>
+    <string>${dirname(dirname(startScript))}</string>
+</dict>
+</plist>
+`;
+}
+
+function main() {
+  if (platform() !== "darwin") {
+    console.error("LaunchAgent setup is macOS-only.");
+    process.exit(1);
+  }
+
+  const logDir = join(INBOX_CONFIG_DIR, "logs");
+
+  ensureDir(LAUNCH_AGENTS_DIR);
+  ensureDir(logDir);
+
+  const plistContent = buildPlist(START_SCRIPT, logDir);
+  writeFileSync(PLIST_PATH, plistContent, "utf8");
+
+  console.log("LaunchAgent written to:", PLIST_PATH);
+  console.log("Logs will be written to:", logDir);
+
+  // Load it immediately
+  try {
+    execSync(`launchctl load "${PLIST_PATH}"`, { stdio: "inherit" });
+    console.log("LaunchAgent loaded. ftm-inbox will start on next login.");
+    console.log("To start it now: launchctl start com.ftm.inbox");
+  } catch (err) {
+    console.warn("Could not load LaunchAgent automatically:", err.message);
+    console.warn("Run manually: launchctl load", PLIST_PATH);
+  }
+}
+
+main();

package/ftm-inbox/bin/setup.mjs

@@ -0,0 +1,188 @@
+#!/usr/bin/env node
+
+/**
+ * ftm-inbox setup wizard
+ * Prompts for credentials and writes ~/.claude/ftm-inbox/config.yml
+ */
+
+import { createInterface } from "readline";
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+const HOME = homedir();
+const INBOX_CONFIG_DIR = join(HOME, ".claude", "ftm-inbox");
+const CONFIG_FILE = join(INBOX_CONFIG_DIR, "config.yml");
+
+const rl = createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+function ask(question, defaultValue = "") {
+  return new Promise((resolve) => {
+    const prompt = defaultValue ? `${question} [${defaultValue}]: ` : `${question}: `;
+    rl.question(prompt, (answer) => {
+      resolve(answer.trim() || defaultValue);
+    });
+  });
+}
+
+function askSecret(question) {
+  return new Promise((resolve) => {
+    process.stdout.write(`${question}: `);
+    // Note: readline doesn't natively hide input; use as-is for terminal environments
+    rl.question("", (answer) => {
+      resolve(answer.trim());
+    });
+  });
+}
+
+function ensureDir(dir) {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+
+function buildConfig(answers) {
+  const lines = ["# ftm-inbox configuration", "# Generated by ftm-inbox setup wizard", ""];
+
+  lines.push("server:");
+  lines.push(`  port: ${answers.port}`);
+  lines.push("");
+
+  if (answers.jiraBaseUrl || answers.jiraEmail || answers.jiraApiToken) {
+    lines.push("adapters:");
+    lines.push("  jira:");
+    lines.push(`    enabled: ${!!(answers.jiraBaseUrl && answers.jiraEmail && answers.jiraApiToken)}`);
+    lines.push(`    base_url: "${answers.jiraBaseUrl}"`);
+    lines.push(`    email: "${answers.jiraEmail}"`);
+    lines.push(`    api_token: "${answers.jiraApiToken}"`);
+    lines.push(`    poll_interval_seconds: 60`);
+    lines.push("");
+  } else {
+    lines.push("adapters:");
+    lines.push("  jira:");
+    lines.push("    enabled: false");
+    lines.push(`    base_url: ""`);
+    lines.push(`    email: ""`);
+    lines.push(`    api_token: ""`);
+    lines.push(`    poll_interval_seconds: 60`);
+    lines.push("");
+  }
+
+  lines.push("  freshservice:");
+  lines.push(`    enabled: ${!!(answers.freshserviceDomain && answers.freshserviceApiKey)}`);
+  lines.push(`    domain: "${answers.freshserviceDomain}"`);
+  lines.push(`    api_key: "${answers.freshserviceApiKey}"`);
+  lines.push(`    poll_interval_seconds: 120`);
+  lines.push("");
+
+  lines.push("  slack:");
+  lines.push(`    enabled: ${!!answers.slackBotToken}`);
+  lines.push(`    bot_token: "${answers.slackBotToken}"`);
+  lines.push(`    poll_interval_seconds: 30`);
+  lines.push("");
+
+  lines.push("  gmail:");
+  lines.push(`    enabled: ${!!answers.gmailCredentialsPath}`);
+  lines.push(`    credentials_path: "${answers.gmailCredentialsPath}"`);
+  lines.push(`    poll_interval_seconds: 120`);
+  lines.push("");
+
+  lines.push("database:");
+  lines.push(`  path: "${join(INBOX_CONFIG_DIR, "inbox.db")}"`);
+  lines.push("");
+
+  lines.push("logging:");
+  lines.push(`  level: "INFO"`);
+  lines.push(`  path: "${join(INBOX_CONFIG_DIR, "logs")}"`);
+
+  return lines.join("\n");
+}
+
+async function main() {
+  console.log("");
+  console.log("ftm-inbox Setup Wizard");
+  console.log("======================");
+  console.log("This will configure your inbox service credentials.");
+  console.log("Credentials are stored in ~/.claude/ftm-inbox/config.yml (gitignored).");
+  console.log("");
+
+  const answers = {};
+
+  // Port
+  answers.port = await ask("Port number", "8042");
+
+  // Jira
+  console.log("");
+  console.log("--- Jira (leave blank to skip) ---");
+  answers.jiraBaseUrl = await ask("Jira base URL (e.g. https://yourorg.atlassian.net)");
+  if (answers.jiraBaseUrl) {
+    answers.jiraEmail = await ask("Jira email");
+    answers.jiraApiToken = await askSecret("Jira API token");
+  } else {
+    answers.jiraEmail = "";
+    answers.jiraApiToken = "";
+  }
+
+  // Freshservice
+  console.log("");
+  console.log("--- Freshservice (leave blank to skip) ---");
+  answers.freshserviceDomain = await ask("Freshservice domain (e.g. yourorg.freshservice.com)");
+  if (answers.freshserviceDomain) {
+    answers.freshserviceApiKey = await askSecret("Freshservice API key");
+  } else {
+    answers.freshserviceApiKey = "";
+  }
+
+  // Slack
+  console.log("");
+  console.log("--- Slack (leave blank to skip) ---");
+  answers.slackBotToken = await askSecret("Slack bot token (xoxb-...)");
+
+  // Gmail
+  console.log("");
+  console.log("--- Gmail (leave blank to skip) ---");
+  answers.gmailCredentialsPath = await ask(
+    "Gmail credentials JSON path (e.g. ~/credentials.json)"
+  );
+
+  rl.close();
+
+  // Validate at least one adapter
+  const hasJira = !!(answers.jiraBaseUrl && answers.jiraEmail && answers.jiraApiToken);
+  const hasFreshservice = !!(answers.freshserviceDomain && answers.freshserviceApiKey);
+  const hasSlack = !!answers.slackBotToken;
+  const hasGmail = !!answers.gmailCredentialsPath;
+
+  if (!hasJira && !hasFreshservice && !hasSlack && !hasGmail) {
+    console.log("");
+    console.error("ERROR: At least one adapter must have credentials configured.");
+    console.error("Re-run setup and provide credentials for at least one service.");
+    process.exit(1);
+  }
+
+  // Write config
+  ensureDir(INBOX_CONFIG_DIR);
+  ensureDir(join(INBOX_CONFIG_DIR, "logs"));
+
+  const configContent = buildConfig(answers);
+  writeFileSync(CONFIG_FILE, configContent, "utf8");
+
+  console.log("");
+  console.log("Configuration written to:", CONFIG_FILE);
+  console.log("");
+  console.log("Enabled adapters:");
+  if (hasJira) console.log("  - Jira");
+  if (hasFreshservice) console.log("  - Freshservice");
+  if (hasSlack) console.log("  - Slack");
+  if (hasGmail) console.log("  - Gmail");
+  console.log("");
+  console.log("Start the service with: ftm-inbox/bin/start.sh");
+}
+
+main().catch((err) => {
+  console.error("Setup failed:", err.message);
+  process.exit(1);
+});

package/ftm-inbox/bin/start.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+# Start ftm-inbox backend + pollers
+cd "$(dirname "$0")/.."
+PORT=${FTM_INBOX_PORT:-8042}
+echo "Starting ftm-inbox on port $PORT..."
+python3 -m uvicorn backend.main:app --host 0.0.0.0 --port $PORT &
+BACKEND_PID=$!
+echo "Backend PID: $BACKEND_PID"
+echo $BACKEND_PID > /tmp/ftm-inbox.pid
+echo "ftm-inbox running. Stop with: ftm-inbox/bin/stop.sh"

package/ftm-inbox/bin/status.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+if [ -f /tmp/ftm-inbox.pid ] && kill -0 $(cat /tmp/ftm-inbox.pid) 2>/dev/null; then
+    echo "ftm-inbox is running (PID: $(cat /tmp/ftm-inbox.pid))"
+    # Show last poll times from DB if available
+    CONFIG_DIR="$HOME/.claude/ftm-inbox"
+    DB_PATH="$CONFIG_DIR/inbox.db"
+    if [ -f "$DB_PATH" ] && command -v sqlite3 &>/dev/null; then
+        echo ""
+        echo "Last poll times:"
+        sqlite3 "$DB_PATH" "SELECT adapter, MAX(fetched_at) FROM inbox_items GROUP BY adapter;" 2>/dev/null | \
+            while IFS='|' read -r adapter ts; do
+                echo "  $adapter: $ts"
+            done
+    fi
+else
+    echo "ftm-inbox is not running."
+fi

package/ftm-inbox/bin/stop.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+if [ -f /tmp/ftm-inbox.pid ]; then
+    kill $(cat /tmp/ftm-inbox.pid) 2>/dev/null
+    rm /tmp/ftm-inbox.pid
+    echo "ftm-inbox stopped."
+else
+    echo "No running ftm-inbox found."
+fi

package/ftm-inbox/config.example.yml

@@ -0,0 +1,55 @@
+# ftm-inbox configuration
+#
+# Copy this file to config.yml and fill in your credentials.
+# The adapter registry loads this on startup. Missing config.yml is
+# non-fatal — the backend starts with no adapters registered.
+#
+# Each adapter entry:
+#   name              : unique identifier, used as inbox.source value
+#   class             : dotted Python path to the adapter class
+#   interval_seconds  : how often the poller runs (scheduler not yet wired — reserved)
+#   credentials       : secrets (API tokens, passwords) — keep out of version control
+#   config            : non-secret settings (URLs, project keys, etc.)
+
+adapters:
+  - name: jira
+    class: ftm_inbox.adapters.jira.JiraAdapter
+    interval_seconds: 60
+    credentials:
+      api_token: "your-jira-api-token-here"
+      email: "you@yourorg.com"
+    config:
+      base_url: "https://yourorg.atlassian.net"
+      project_key: "OPS"
+      max_results: 100
+      jql: "project = OPS AND statusCategory != Done ORDER BY updated DESC"
+
+  - name: freshservice
+    class: ftm_inbox.adapters.freshservice.FreshserviceAdapter
+    interval_seconds: 90
+    credentials:
+      api_key: "your-freshservice-api-key-here"
+    config:
+      domain: "yourorg.freshservice.com"
+      per_page: 100
+
+  - name: slack
+    class: ftm_inbox.adapters.slack.SlackAdapter
+    interval_seconds: 30
+    credentials:
+      bot_token: "xoxb-your-slack-bot-token"
+    config:
+      channels:
+        - "C0123456789"   # ops-alerts
+        - "C0987654321"   # triage
+      lookback_hours: 24
+
+  - name: gmail
+    class: ftm_inbox.adapters.gmail.GmailAdapter
+    interval_seconds: 120
+    credentials:
+      credentials_json_path: "~/.config/ftm-inbox/gmail-credentials.json"
+      token_path: "~/.config/ftm-inbox/gmail-token.json"
+    config:
+      label_filter: "ftm-inbox"
+      max_results: 50