@smartmemory/compose 0.1.0

package/server/stratum-sync.js

@@ -0,0 +1,193 @@
+/**
+ * stratum-sync.js — Stratum flow poller + route registration.
+ *
+ * Polls stratum flow state via stratum-client (not direct file reads) and syncs
+ * into the vision store every 15 seconds.
+ *
+ * Routes: POST /api/stratum/bind, POST /api/stratum/audit/:itemId
+ * (Flow/gate query routes are now in stratum-api.js)
+ */
+
+import { queryFlows } from './stratum-client.js';
+
+// ---------------------------------------------------------------------------
+// StratumSync class
+// ---------------------------------------------------------------------------
+
+export class StratumSync {
+  #store;
+  #scheduleBroadcast;
+  #pollTimer = null;
+
+  /**
+   * @param {object} store — VisionStore instance
+   * @param {function} scheduleBroadcast
+   */
+  constructor(store, scheduleBroadcast) {
+    this.#store = store;
+    this.#scheduleBroadcast = scheduleBroadcast;
+  }
+
+  /** Start the 15s polling interval. */
+  start() {
+    this.#pollTimer = setInterval(() => {
+      this.#syncFlows().catch(err => {
+        console.error('[vision] Stratum poll error:', err.message);
+      });
+    }, 15_000);
+  }
+
+  /** Stop the polling interval. */
+  stop() {
+    if (this.#pollTimer) {
+      clearInterval(this.#pollTimer);
+      this.#pollTimer = null;
+    }
+  }
+
+  /**
+   * Fetch flow summaries via stratum-client (stable contract, not direct file reads).
+   * Maps stratum's query output to the shape the sync logic expects.
+   * @returns {Promise<Array>}
+   */
+  async readFlows() {
+    const raw = await queryFlows();
+    if (!Array.isArray(raw)) return [];
+
+    return raw.map(f => {
+      // Map stratum canonical status → legacy sync status labels
+      const status = f.status === 'running' || f.status === 'awaiting_gate' ? 'running'
+        : f.status === 'complete' ? 'complete'
+        : f.status === 'killed' ? 'blocked'
+        : 'paused';
+
+      // STRAT-PAR-3: completed_steps and active_steps are now string[] in v0.3.
+      // Fall back to [] when stratum returns the old integer format (backward compat).
+      const completedSet = Array.isArray(f.completed_steps) ? f.completed_steps : [];
+      const activeSet    = Array.isArray(f.active_steps)    ? f.active_steps    : [];
+
+      return {
+        flowId:         f.flow_id,
+        flowName:       f.flow_name,
+        status,
+        stepsCompleted: completedSet,    // string[] — set of completed step IDs
+        stepsActive:    activeSet,       // string[] — set of active (in-progress) step IDs
+        stepCount:      f.step_count ?? null,
+        steps:          [],
+        // currentIdx removed — consumers use stepsCompleted.length
+      };
+    });
+  }
+
+  /** Sync stratum flow states → vision item statuses + violation evidence. */
+  async #syncFlows() {
+    const flows = await this.readFlows();
+    if (flows.length === 0) return;
+
+    const flowMap = new Map(flows.map(f => [f.flowId, f]));
+    let changed = false;
+
+    for (const item of this.#store.items.values()) {
+      if (!item.stratumFlowId) continue;
+      const flow = flowMap.get(item.stratumFlowId);
+      if (!flow) continue;
+
+      const targetStatus = flow.status === 'running' ? 'in_progress'
+        : flow.status === 'blocked' ? 'blocked'
+        : null;
+
+      if (targetStatus && targetStatus !== item.status) {
+        try {
+          this.#store.updateItem(item.id, { status: targetStatus });
+          changed = true;
+        } catch { /* ignore */ }
+      }
+
+      const existing = item.evidence || {};
+      if (flow.status === 'blocked') {
+        // Flow was killed via gate reject — record factual evidence, not retry semantics.
+        const killNote = `Flow '${flow.flowName}' was killed via gate reject`;
+        if (existing.stratumKillNote !== killNote) {
+          try {
+            // Also clear any stale retry-exhaustion evidence from old sync format.
+            const { stratumViolations: _v, violatedAt: _va, ...rest } = existing;
+            this.#store.updateItem(item.id, {
+              evidence: { ...rest, stratumKillNote: killNote, killedAt: new Date().toISOString() },
+            });
+            changed = true;
+          } catch { /* ignore */ }
+        }
+      } else if (existing.stratumKillNote || existing.stratumViolations) {
+        // Flow is no longer blocked — clear kill evidence.
+        try {
+          const { stratumKillNote: _k, killedAt: _ka, stratumViolations: _v, violatedAt: _va, ...rest } = existing;
+          this.#store.updateItem(item.id, { evidence: rest });
+          changed = true;
+        } catch { /* ignore */ }
+      }
+    }
+
+    if (changed) this.#scheduleBroadcast();
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Route registration
+// ---------------------------------------------------------------------------
+
+/**
+ * Attach stratum REST routes to an Express app.
+ *
+ * @param {object} app — Express app
+ * @param {{ store: object, scheduleBroadcast: function, broadcastMessage: function, sync: StratumSync }} deps
+ */
+export function attachStratumRoutes(app, { store, scheduleBroadcast, broadcastMessage, sync }) {
+  // POST /api/stratum/bind — link a stratum flow_id to a vision item
+  app.post('/api/stratum/bind', (req, res) => {
+    const { flowId, itemId } = req.body || {};
+    if (!flowId || !itemId) return res.status(400).json({ error: 'flowId and itemId required' });
+    try {
+      const item = store.updateItem(itemId, { stratumFlowId: flowId });
+      scheduleBroadcast();
+      res.json({ ok: true, itemId, flowId, item });
+    } catch (err) {
+      const status = err.message.includes('not found') ? 404 : 400;
+      res.status(status).json({ error: err.message });
+    }
+  });
+
+  // POST /api/stratum/audit/:itemId — store audit trace in item evidence + emit session log event
+  app.post('/api/stratum/audit/:itemId', (req, res) => {
+    const { trace } = req.body || {};
+    if (!trace) return res.status(400).json({ error: 'trace required' });
+    try {
+      const item = store.items.get(req.params.itemId);
+      if (!item) return res.status(404).json({ error: `Item not found: ${req.params.itemId}` });
+      // eslint-disable-next-line no-unused-vars
+      const { stratumViolations: _v, violatedAt: _va, ...existingEvidence } = item.evidence || {};
+      const evidence = { ...existingEvidence, stratumTrace: trace, tracedAt: new Date().toISOString() };
+      const updates = { evidence };
+      if (trace.status === 'complete' && item.status !== 'complete') {
+        updates.status = 'complete';
+      }
+      const updatedItem = store.updateItem(req.params.itemId, updates);
+      scheduleBroadcast();
+
+      const stepsCompleted = Array.isArray(trace.trace) ? trace.trace.length : 0;
+      const totalMs = trace.total_duration_ms || null;
+      broadcastMessage({
+        type: 'agentActivity',
+        tool: 'stratum_audit',
+        category: 'delegating',
+        detail: `${trace.flow_name || trace.flow_id}: ${stepsCompleted} steps${totalMs != null ? `, ${(totalMs / 1000).toFixed(1)}s` : ''}`,
+        error: null,
+        items: [{ id: updatedItem.id, title: updatedItem.title, status: updatedItem.status }],
+        timestamp: new Date().toISOString(),
+      });
+
+      res.json({ ok: true, itemId: req.params.itemId });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+}

package/server/summarizer.js

@@ -0,0 +1,139 @@
+/**
+ * summarizer.js — Spawn a Claude CLI subprocess to summarize batch events as JSON.
+ *
+ * Model-agnostic: defaults to haiku for cost efficiency but accepts any model.
+ * Extracted from SessionManager for independent reuse and testing.
+ */
+
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+
+import { getTargetRoot } from './project-root.js';
+
+const PROJECT_ROOT = getTargetRoot();
+
+const DEFAULT_MODEL = process.env.SUMMARIZER_MODEL || 'haiku';
+
+// ---------------------------------------------------------------------------
+// Prompt builder
+// ---------------------------------------------------------------------------
+
+/**
+ * Format batch events into a prompt asking the model for structured JSON.
+ *
+ * @param {Array} batch — array of buffered tool-use events
+ * @param {string} [projectRoot]
+ * @returns {string}
+ */
+export function buildSummaryPrompt(batch, projectRoot = PROJECT_ROOT) {
+  const eventLines = batch.map(evt => {
+    const itemLabel = evt.itemTitles.length > 0
+      ? ` [${evt.itemTitles.join(', ')}]`
+      : '';
+    const fileLabel = evt.filePath
+      ? ` on ${path.relative(projectRoot, evt.filePath) || evt.filePath}`
+      : ' on (no file)';
+    return `- ${evt.tool}${fileLabel}${itemLabel}: ${evt.input}`;
+  }).join('\n');
+
+  return `Summarize these developer tool actions as a JSON object. Return ONLY valid JSON, no markdown.
+
+Events:
+${eventLines}
+
+JSON schema:
+{
+  "summary": "one sentence describing what these actions accomplish together",
+  "intent": "feature|bugfix|refactor|test|docs|config|debug",
+  "component": "which part of the system (derived from file paths)",
+  "complexity": "trivial|low|medium|high",
+  "signals": ["string tags like new_file, error_handling, api_change, test_added"],
+  "status_hint": "review_ready|needs_test|blocked|null"
+}`;
+}
+
+// ---------------------------------------------------------------------------
+// Summarize caller
+// ---------------------------------------------------------------------------
+
+/**
+ * Spawn `claude -p <prompt> --model <model> --max-turns 1` with CLAUDECODE unset.
+ * Parse JSON from output. Returns parsed object or null on failure.
+ *
+ * @param {string} prompt
+ * @param {object} [opts]
+ * @param {string} [opts.model]       — model to use (default: haiku or SUMMARIZER_MODEL env)
+ * @param {string} [opts.projectRoot]
+ * @returns {Promise<object|null>}
+ */
+export function summarize(prompt, { model = DEFAULT_MODEL, projectRoot = PROJECT_ROOT } = {}) {
+  return new Promise((resolve) => {
+    const cleanEnv = { ...process.env, NO_COLOR: '1' };
+    delete cleanEnv.CLAUDECODE;
+
+    const proc = spawn('claude', [
+      '-p', prompt,
+      '--model', model,
+      '--max-turns', '1',
+    ], {
+      cwd: projectRoot,
+      env: cleanEnv,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    proc.stdout.on('data', (chunk) => { stdout += chunk.toString(); });
+    proc.stderr.on('data', (chunk) => { stderr += chunk.toString(); });
+
+    proc.on('error', (err) => {
+      console.error('[session] Summarizer spawn error:', err.message);
+      resolve(null);
+    });
+
+    proc.on('close', (code) => {
+      if (code !== 0) {
+        console.error(`[session] Summarizer exited with code ${code}:`, stderr.slice(0, 200));
+        resolve(null);
+        return;
+      }
+
+      try {
+        const json = extractJSON(stdout);
+        resolve(json);
+      } catch (err) {
+        console.error('[session] Summarizer JSON parse failed:', err.message, 'raw:', stdout.slice(0, 300));
+        resolve(null);
+      }
+    });
+  });
+}
+
+// ---------------------------------------------------------------------------
+// JSON extractor
+// ---------------------------------------------------------------------------
+
+/**
+ * Extract JSON from model output, handling possible markdown fences.
+ *
+ * @param {string} text — raw stdout
+ * @returns {object}
+ * @throws {Error} if no JSON found
+ */
+export function extractJSON(text) {
+  const trimmed = text.trim();
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    const fenceMatch = trimmed.match(/```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/);
+    if (fenceMatch) {
+      return JSON.parse(fenceMatch[1].trim());
+    }
+    const braceMatch = trimmed.match(/\{[\s\S]*\}/);
+    if (braceMatch) {
+      return JSON.parse(braceMatch[0]);
+    }
+    throw new Error('No JSON found in output');
+  }
+}

package/server/supervisor.js

@@ -0,0 +1,196 @@
+/**
+ * Process supervisor for Compose.
+ * Manages three independent processes:
+ *   1. API server (port 3001) — Express + file-watcher + vision
+ *   2. Agent server (port 3002) — SDK streaming, structured messages (Tier 1, immortal)
+ *   3. Vite dev server (port 5173) — Frontend HMR
+ *
+ * Each process gets independent restart with exponential backoff.
+ * If a process keeps crashing for > 1 minute, the supervisor gives up on it.
+ *
+ * Singleton enforcement: Uses a PID file to ensure only one supervisor runs.
+ * Starting a new supervisor kills the old one and all its children first.
+ */
+
+import { fork, spawn, execFileSync } from 'node:child_process';
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { COMPOSE_HOME, getTargetRoot, ensureDataDir } from './project-root.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+console.log('[supervisor] Target project:', getTargetRoot());
+const PID_FILE = path.join(COMPOSE_HOME, '.compose-supervisor.pid');
+
+const PROCESSES = [
+  {
+    name: 'api-server',
+    path: path.join(__dirname, 'index.js'),
+    port: process.env.PORT || 4001,
+    type: 'fork',
+  },
+  {
+    name: 'agent-server',
+    path: path.join(__dirname, 'agent-server.js'),
+    port: process.env.AGENT_PORT || 4002,
+    type: 'fork',
+  },
+  {
+    name: 'vite',
+    command: path.join(COMPOSE_HOME, 'node_modules', '.bin', 'vite'),
+    port: process.env.VITE_PORT || 5195,
+    type: 'spawn',
+  },
+];
+
+const MIN_BACKOFF = 500;
+const MAX_BACKOFF = 10_000;
+const HEALTHY_THRESHOLD = 5_000;
+const GIVE_UP_AFTER = 60_000; // stop retrying after 1 min of continuous failures
+
+let stopping = false;
+
+function ensureComposeApiToken() {
+  if (!process.env.COMPOSE_API_TOKEN) {
+    process.env.COMPOSE_API_TOKEN = crypto.randomBytes(24).toString('hex');
+    console.log('[supervisor] Generated COMPOSE_API_TOKEN for this session');
+  }
+  // Expose the same token to Vite client code.
+  process.env.VITE_COMPOSE_API_TOKEN = process.env.COMPOSE_API_TOKEN;
+  // Expose AGENT_PORT so AgentStream.jsx can reach the right port
+  process.env.VITE_AGENT_PORT = process.env.AGENT_PORT || '4002';
+}
+
+// --- Singleton enforcement ---
+
+function killExistingSupervisor() {
+  try {
+    const oldPid = parseInt(fs.readFileSync(PID_FILE, 'utf8').trim(), 10);
+    if (oldPid && oldPid !== process.pid) {
+      try {
+        // Check if process exists
+        process.kill(oldPid, 0);
+        console.log(`[supervisor] Killing previous supervisor (PID ${oldPid})...`);
+        process.kill(oldPid, 'SIGTERM');
+        // Give it time to clean up children
+        execFileSync('sleep', ['2']);
+      } catch {
+        // Process doesn't exist — stale PID file
+      }
+    }
+  } catch {
+    // No PID file — first run
+  }
+}
+
+function writePidFile() {
+  fs.writeFileSync(PID_FILE, String(process.pid));
+}
+
+function removePidFile() {
+  try { fs.unlinkSync(PID_FILE); } catch {}
+}
+
+// Kill old supervisor before anything else
+killExistingSupervisor();
+ensureComposeApiToken();
+ensureDataDir();
+
+// Kill anything listening on our ports (stale children from old supervisor)
+function freePort(port, childPid) {
+  try {
+    const output = execFileSync('lsof', ['-ti', `:${port}`, '-sTCP:LISTEN'], {
+      encoding: 'utf8',
+      timeout: 3000,
+    }).trim();
+    if (!output) return;
+
+    const myPid = process.pid;
+    const pids = output.split('\n').map(p => parseInt(p, 10)).filter(Boolean);
+    const stale = pids.filter(pid => pid !== myPid && pid !== childPid);
+
+    if (stale.length > 0) {
+      console.log(`[supervisor] Killing stale listener(s) on port ${port}: ${stale.join(', ')}`);
+      for (const pid of stale) {
+        try { process.kill(pid, 'SIGKILL'); } catch {}
+      }
+      execFileSync('sleep', ['1']);
+    }
+  } catch {
+    // lsof returns non-zero if no matches — port is free
+  }
+}
+
+// Free all ports before starting (clean slate)
+for (const proc of PROCESSES) {
+  if (proc.port) freePort(proc.port, null);
+}
+
+// Write our PID file
+writePidFile();
+
+// --- Process management ---
+
+function startProcess(proc) {
+  if (stopping) return;
+  if (proc.port) freePort(proc.port, proc.child ? proc.child.pid : null);
+
+  const startTime = Date.now();
+  console.log(`[supervisor] Starting ${proc.name}...`);
+
+  if (proc.type === 'fork') {
+    proc.child = fork(proc.path, { stdio: 'inherit' });
+  } else {
+    proc.child = spawn(proc.command, [], {
+      stdio: 'inherit',
+      cwd: COMPOSE_HOME,
+      env: process.env,
+    });
+  }
+
+  proc.child.on('exit', (code, signal) => {
+    if (stopping) return;
+
+    const uptime = Date.now() - startTime;
+    console.error(`[supervisor] ${proc.name} exited (code: ${code}, signal: ${signal}, uptime: ${uptime}ms)`);
+    proc.child = null;
+
+    if (uptime > HEALTHY_THRESHOLD) {
+      proc.backoff = MIN_BACKOFF;
+      proc.firstFailTime = null;
+    } else {
+      proc.backoff = Math.min((proc.backoff || MIN_BACKOFF) * 2, MAX_BACKOFF);
+      if (!proc.firstFailTime) proc.firstFailTime = Date.now();
+
+      if (Date.now() - proc.firstFailTime > GIVE_UP_AFTER) {
+        console.error(`[supervisor] ${proc.name} has been failing for >1 min — giving up`);
+        return;
+      }
+    }
+
+    console.log(`[supervisor] Restarting ${proc.name} in ${proc.backoff}ms...`);
+    setTimeout(() => startProcess(proc), proc.backoff);
+  });
+}
+
+// Start all processes
+for (const proc of PROCESSES) {
+  proc.backoff = MIN_BACKOFF;
+  proc.child = null;
+  proc.firstFailTime = null;
+  startProcess(proc);
+}
+
+// Forward termination signals to all children, then exit cleanly
+for (const sig of ['SIGINT', 'SIGTERM']) {
+  process.on(sig, () => {
+    stopping = true;
+    console.log(`[supervisor] ${sig} received, stopping all processes...`);
+    for (const proc of PROCESSES) {
+      if (proc.child) proc.child.kill(sig);
+    }
+    removePidFile();
+    setTimeout(() => process.exit(0), 2000);
+  });
+}