@smartmemory/compose 0.1.0

package/scripts/agent-activity-hook.sh

@@ -0,0 +1,31 @@
+#!/bin/bash
+# agent-activity-hook.sh — PostToolUse hook that forwards tool activity to Compose server.
+#
+# Receives JSON on stdin from Claude Code with tool_name, tool_input, tool_response.
+# POSTs a compact summary to the Compose server which broadcasts it via WebSocket
+# to the Vision Tracker's agent activity feed.
+#
+# Runs quickly — curl with 1s timeout, backgrounded, non-blocking.
+
+INPUT=$(cat)
+
+TOOL=$(echo "$INPUT" | jq -r '.tool_name // empty')
+[ -z "$TOOL" ] && exit 0
+
+# Extract tool_input as compact JSON
+TOOL_INPUT=$(echo "$INPUT" | jq -c '.tool_input // {}')
+
+# Extract first 500 chars of tool_response (for error detection server-side)
+RESPONSE=$(echo "$INPUT" | jq -c '.tool_response // null' | head -c 500)
+
+# Build POST body safely with jq to avoid JSON injection
+BODY=$(jq -n --arg tool "$TOOL" --argjson input "$TOOL_INPUT" --argjson response "$RESPONSE" \
+  '{tool: $tool, input: $input, response: $response}')
+
+# Fire and forget — don't block the agent
+curl -s -m 1 -X POST http://localhost:3001/api/agent/activity \
+  -H 'Content-Type: application/json' \
+  -d "$BODY" \
+  > /dev/null 2>&1 &
+
+exit 0

package/scripts/agent-error-hook.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+# agent-error-hook.sh — PostToolUseFailure hook that forwards tool errors to Compose server.
+#
+# Receives JSON on stdin from Claude Code with tool_name, tool_input, error.
+# POSTs to the Compose error endpoint for classification and UI display.
+#
+# Fire-and-forget, non-blocking.
+
+INPUT=$(cat)
+
+TOOL=$(echo "$INPUT" | jq -r '.tool_name // empty')
+[ -z "$TOOL" ] && exit 0
+
+# Extract fields
+TOOL_INPUT=$(echo "$INPUT" | jq -c '.tool_input // {}')
+ERROR=$(echo "$INPUT" | jq -r '.error // empty' | head -c 500)
+
+# Build POST body safely with jq
+BODY=$(jq -n --arg tool "$TOOL" --argjson input "$TOOL_INPUT" --arg error "$ERROR" \
+  '{tool: $tool, input: $input, error: $error}')
+
+# Fire and forget
+curl -s -m 1 -X POST http://localhost:3001/api/agent/error \
+  -H 'Content-Type: application/json' \
+  -d "$BODY" \
+  > /dev/null 2>&1 &
+
+exit 0

package/scripts/analyze-orphans.mjs

@@ -0,0 +1,50 @@
+import fs from 'node:fs';
+const d = JSON.parse(fs.readFileSync('data/vision-state.json', 'utf8'));
+
+const features = d.items.filter(i => i.type === 'feature');
+const reachable = new Set(features.map(f => f.id));
+
+let changed = true;
+while (changed) {
+  changed = false;
+  for (const conn of d.connections) {
+    if (conn.type === 'implements' && reachable.has(conn.toId)) {
+      if (!reachable.has(conn.fromId)) {
+        reachable.add(conn.fromId);
+        changed = true;
+      }
+    }
+  }
+  for (const item of d.items) {
+    if (item.parentId && reachable.has(item.parentId)) {
+      if (!reachable.has(item.id)) {
+        reachable.add(item.id);
+        changed = true;
+      }
+    }
+  }
+}
+
+const orphans = d.items.filter(i => !reachable.has(i.id));
+console.log(`Reachable: ${reachable.size} | Orphaned: ${orphans.length}`);
+console.log('');
+
+const tracks = d.items.filter(i => i.type === 'track');
+console.log('=== TRACKS ===');
+tracks.forEach(t => console.log(`  ${t.semanticId}  ${t.title}`));
+console.log('');
+
+console.log('=== ORPHANS ===');
+for (const o of orphans) {
+  const conns = d.connections.filter(c => c.fromId === o.id || c.toId === o.id);
+  const targets = conns.map(c => {
+    const otherId = c.fromId === o.id ? c.toId : c.fromId;
+    const other = d.items.find(i => i.id === otherId);
+    const dir = c.fromId === o.id ? '>' : '<';
+    return `${dir}${c.type}:${other?.semanticId || other?.title?.slice(0, 25) || otherId.slice(0, 8)}`;
+  }).join(' | ');
+  const sid = (o.semanticId || o.id.slice(0, 8)).padEnd(15);
+  const typ = o.type.padEnd(10);
+  const tit = o.title.slice(0, 45).padEnd(47);
+  console.log(`  ${sid} ${typ} ${tit} ${targets}`);
+}

package/scripts/find-orphans.mjs

@@ -0,0 +1,26 @@
+import { readFileSync } from 'fs';
+const d = JSON.parse(readFileSync('./data/vision-state.json', 'utf8'));
+const items = d.items, conns = d.connections;
+
+const childIds = new Set();
+for (const c of conns) {
+  if (c.type === 'implements' || c.type === 'supports') childIds.add(c.fromId);
+}
+for (const i of items) {
+  if (i.parentId) childIds.add(i.id);
+}
+
+const containers = items.filter(i => i.type === 'feature' || i.type === 'track');
+const cids = new Set(containers.map(c => c.id));
+const orphans = items.filter(i => !cids.has(i.id) && !childIds.has(i.id));
+
+console.log('=== CONTAINERS ===');
+for (const c of containers) {
+  const kids = conns.filter(cn => cn.toId === c.id && (cn.type === 'implements' || cn.type === 'supports')).length;
+  console.log(`${c.id.slice(0,8)}  ${c.type.padEnd(8)}  ${c.title}  (${kids} children)`);
+}
+console.log('');
+console.log(`=== ORPHANS (${orphans.length}) ===`);
+for (const o of orphans) {
+  console.log(`${o.id.slice(0,8)}  ${o.type.padEnd(10)}  ${o.phase.padEnd(15)}  ${o.title}`);
+}

package/scripts/fix-phases.mjs

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+import { execFileSync } from 'child_process';
+
+// Reclassify all ideas, questions, and threads to vision phase
+const reclassify = [
+  // Ideas
+  '2662567c-deac-4eec-9084-19d9756c093d',  // Dynamic decision chips
+  'bdbdd363-894d-48ad-be45-1680d1095c37',  // Specialized agents per phase
+  'd45f80f0-43d5-48a2-bc80-83231f205c0c',  // Background sub-agent for proactive AI
+  '83bdd6a9-c0aa-4c42-bc74-f65d2e320d0d',  // General backbone + domain constraints
+  '26779dbe-6a5b-4dbb-ac30-aacc97f044bf',  // Base44 insight: iteration is the value
+  '1e555432-ce1c-4279-820c-0ba4fad53b2b',  // Knobs as control surface
+  'orphan-persistence-model',                // Event-sourced persistence model
+  'orphan-voice-input',                      // Voice input for rapid capture
+  'orphan-mobile-view',                      // Mobile companion view
+  'idea-testing-strategy',                   // Verification phase: AI tests its own output
+  'e3091928-0b0d-4656-984b-8a2764eda72a',  // Drill-down views for Vision Tracker
+
+  // Questions
+  '37a333aa-1f0a-4f0d-8cab-c349f06a08cd',  // How do jigsaw pieces interface?
+  '5a836beb-afd4-4d21-b36d-1fe7c8a21eb8',  // How to prove the thesis?
+  '417e5c2c-992a-40e1-8ba1-3bc7e25564b0',  // What triggers decision chips?
+  'c38aa3ae-febb-4370-81ca-b22163825d10',  // How does the item map scale?
+  'question-release-strategy',               // What's the release packaging?
+
+  // Threads
+  'c3e13f70-2740-4558-997e-7f1dcb7a39c8',  // Design the first permanent piece
+  '86878969-e6cf-4002-8f50-b90122acf9ab',  // Fill remaining matrix rows
+  '19f05faa-d50d-4697-87d2-c77b5d710a26',  // Pipeline requirements
+  'd28e17d8-b9e7-4484-84ec-27f83568371d',  // Knobs design
+  'thread-impl-bootstrap',                   // Implementation bootstrap sequence
+
+  // Vision decision
+  '5632a099-62f6-4f38-9d20-992a3072f369',  // Vision: Build me X, Forge takes it from there
+];
+
+let success = 0, fail = 0;
+for (const id of reclassify) {
+  try {
+    execFileSync('node', ['scripts/vision-track.mjs', 'update', id, '--phase', 'vision'], { stdio: 'pipe' });
+    success++;
+    process.stdout.write('.');
+  } catch (e) {
+    fail++;
+    process.stdout.write('x');
+    console.error(`\n  FAIL: ${id}: ${e.stderr?.toString().trim()}`);
+  }
+}
+console.log(`\n\nDone: ${success} reclassified to vision, ${fail} failed`);

package/scripts/generate-stratum-spec.mjs

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+/**
+ * generate-stratum-spec.mjs — Generates pipelines/compose_feature.stratum.yaml
+ * from contracts/lifecycle.json.
+ *
+ * Usage: node scripts/generate-stratum-spec.mjs
+ *
+ * Design constraint: the generated spec has exactly one function and one step
+ * per contract phase, with step id and function id equal to the phase id.
+ * Revision edges (back-edges in the transition graph) are documented as
+ * comments — they are handled at runtime, not modeled in the DAG.
+ */
+
+import { readFileSync, writeFileSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(__dirname, '..');
+const contract = JSON.parse(readFileSync(resolve(ROOT, 'contracts', 'lifecycle.json'), 'utf8'));
+const OUTPUT = resolve(ROOT, 'pipelines', 'compose_feature.stratum.yaml');
+
+const lines = [];
+const w = (s = '') => lines.push(s);
+
+w('version: "0.1"');
+w();
+w('# compose_feature pipeline');
+w(`# Generated from contracts/lifecycle.json v${contract.version}`);
+w('# Do not edit manually — regenerate with: node scripts/generate-stratum-spec.mjs');
+w();
+
+// ---------------------------------------------------------------------------
+// Detect revision edges for documentation purposes.
+// A revision edge is A → B where B comes before A in phase order.
+// These are handled at runtime, not in the Stratum DAG.
+// ---------------------------------------------------------------------------
+
+const phaseIndex = Object.fromEntries(contract.phases.map((p, i) => [p.id, i]));
+
+const revisionEdges = []; // [{ from, to }]
+for (const [from, targets] of Object.entries(contract.transitions)) {
+  for (const target of targets) {
+    if (phaseIndex[from] > phaseIndex[target]) {
+      revisionEdges.push({ from, to: target });
+    }
+  }
+}
+
+// Contracts
+w('contracts:');
+w('  PhaseResult:');
+w('    phase:     {type: string}');
+w('    artifact:  {type: string}');
+w('    outcome:   {type: string}');
+w();
+
+// Functions — exactly one per phase
+w('functions:');
+for (const phase of contract.phases) {
+  w(`  ${phase.id}:`);
+  w('    mode: compute');
+  w(`    intent: "${phase.description}"`);
+  w('    input:');
+  w('      featureCode: {type: string}');
+  w('      description: {type: string}');
+  w('    output: PhaseResult');
+  if (phase.artifact) {
+    w('    ensure:');
+    w(`      - "file_exists('docs/features/' + input.featureCode + '/${phase.artifact}')"`);
+  }
+  // Phases that are revision targets get extra retries for the loop
+  const isRevisionTarget = revisionEdges.some(e => e.to === phase.id);
+  w(`    retries: ${isRevisionTarget ? 3 : 2}`);
+  w();
+}
+
+// Flow — exactly one step per phase, depends_on from forward transitions
+w('flows:');
+w('  compose_feature:');
+w('    input:');
+w('      featureCode: {type: string}');
+w('      description: {type: string}');
+w('    output: PhaseResult');
+
+if (revisionEdges.length > 0) {
+  w('    # Revision edges (handled at runtime, not in DAG):');
+  for (const edge of revisionEdges) {
+    w(`    #   ${edge.from} → ${edge.to}`);
+  }
+}
+
+w('    steps:');
+
+for (let i = 0; i < contract.phases.length; i++) {
+  const phase = contract.phases[i];
+
+  // Find forward predecessors: phases that transition TO this phase
+  // and appear earlier in phase order (forward edges only)
+  const forwardPreds = [];
+  for (const [from, targets] of Object.entries(contract.transitions)) {
+    if (targets.includes(phase.id) && phaseIndex[from] < i) {
+      forwardPreds.push(from);
+    }
+  }
+  // Sort by phase index — use latest predecessor for correct scheduling order.
+  // Skip paths are handled at runtime by the lifecycle manager, not in the DAG.
+  forwardPreds.sort((a, b) => phaseIndex[a] - phaseIndex[b]);
+
+  w(`      - id: ${phase.id}`);
+  w(`        function: ${phase.id}`);
+  w('        inputs:');
+  w('          featureCode: "$.input.featureCode"');
+  w('          description: "$.input.description"');
+
+  if (forwardPreds.length > 0) {
+    w(`        depends_on: [${forwardPreds[forwardPreds.length - 1]}]`);
+  }
+
+  // Annotate revision edges involving this step
+  const revFrom = revisionEdges.filter(e => e.from === phase.id);
+  const revTo = revisionEdges.filter(e => e.to === phase.id);
+  if (revFrom.length > 0) {
+    for (const edge of revFrom) {
+      w(`        # Revision: may loop back to ${edge.to}`);
+    }
+  }
+  if (revTo.length > 0) {
+    for (const edge of revTo) {
+      w(`        # Revision target: ${edge.from} may loop back here`);
+    }
+  }
+  w();
+}
+
+writeFileSync(OUTPUT, lines.join('\n'));
+console.log(`Generated ${OUTPUT}`);

package/scripts/import-roadmap.mjs

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+/**
+ * import-roadmap.mjs — Parse ROADMAP.md and import entries into the vision store.
+ *
+ * Usage: node scripts/import-roadmap.mjs [path-to-roadmap]
+ * Defaults to ../ROADMAP.md (project root).
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parseRoadmap } from '../lib/roadmap-parser.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const API_BASE = process.env.API_BASE || 'http://localhost:3001';
+
+const roadmapPath = process.argv[2] || path.resolve(__dirname, '../../ROADMAP.md');
+const text = fs.readFileSync(roadmapPath, 'utf-8');
+const entries = parseRoadmap(text);
+
+console.log(`Parsed ${entries.length} entries from ${roadmapPath}`);
+
+// Map roadmap statuses to vision store statuses
+function mapStatus(s) {
+  const upper = s.toUpperCase();
+  if (upper === 'COMPLETE') return 'complete';
+  if (upper === 'IN_PROGRESS') return 'in_progress';
+  if (upper === 'PARTIAL') return 'in_progress';
+  if (upper === 'SUPERSEDED') return 'killed';
+  if (upper === 'PARKED') return 'blocked';
+  if (upper === 'MANUAL GATE') return 'blocked';
+  return 'planned';
+}
+
+// Valid phases: vision, specification, planning, implementation, verification, release
+function mapPhase(phaseId) {
+  const lower = phaseId.toLowerCase();
+  if (lower.includes('bootstrap')) return 'vision';
+  if (lower.includes('vision surface')) return 'vision';
+  if (lower.includes('agent awareness')) return 'specification';
+  if (lower.includes('session tracking')) return 'specification';
+  if (lower.includes('agent connector')) return 'implementation';
+  if (lower.includes('stratum sync')) return 'implementation';
+  if (lower.includes('standalone')) return 'planning';
+  if (lower.includes('lifecycle')) return 'implementation';
+  if (lower.includes('project bootstrap') || lower.includes('init-1')) return 'implementation';
+  if (lower.includes('strat-1')) return 'implementation';
+  if (lower.includes('comp-ui')) return 'implementation';
+  if (lower.includes('comp-rt')) return 'planning';
+  if (lower.includes('strat-par')) return 'implementation';
+  if (lower.includes('comp-bench')) return 'planning';
+  if (lower.includes('dogfood')) return 'verification';
+  return 'planning';
+}
+
+// Determine item type
+function mapType(entry) {
+  if (entry.code.startsWith('_anon_')) return 'task';
+  if (entry.code.startsWith('STRAT-')) return 'feature';
+  if (entry.code.startsWith('COMP-')) return 'feature';
+  if (entry.code.startsWith('INIT-')) return 'feature';
+  return 'task';
+}
+
+// First, get existing items to avoid duplicates
+const existing = await fetch(`${API_BASE}/api/vision/items`).then(r => r.json());
+const existingTitles = new Set((existing.items || []).map(i => i.title));
+
+let created = 0;
+let skipped = 0;
+
+for (const entry of entries) {
+  // Build a clean title
+  const title = entry.code.startsWith('_anon_')
+    ? entry.description.substring(0, 80)
+    : `${entry.code}: ${entry.description.substring(0, 80)}`;
+
+  if (existingTitles.has(title)) {
+    skipped++;
+    continue;
+  }
+
+  const item = {
+    type: mapType(entry),
+    title,
+    description: `${entry.description}\n\nPhase: ${entry.phaseId}\nRoadmap status: ${entry.status}`,
+    status: mapStatus(entry.status),
+    phase: mapPhase(entry.phaseId),
+    confidence: entry.status === 'COMPLETE' ? 3 : entry.status === 'PARTIAL' || entry.status === 'IN_PROGRESS' ? 2 : 0,
+  };
+
+  // Add featureCode for named features
+  if (!entry.code.startsWith('_anon_')) {
+    item.featureCode = entry.code;
+  }
+
+  try {
+    const res = await fetch(`${API_BASE}/api/vision/items`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(item),
+    });
+
+    if (res.ok) {
+      created++;
+      process.stdout.write('.');
+    } else {
+      const err = await res.text();
+      console.error(`\nFailed to create "${title}": ${res.status} ${err}`);
+    }
+  } catch (err) {
+    console.error(`\nFetch error for "${title}": ${err.message}`);
+  }
+}
+
+console.log(`\n\nDone: ${created} created, ${skipped} skipped (already exist)`);

package/scripts/phase-audit.mjs

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import { readFileSync } from 'fs';
+const d = JSON.parse(readFileSync('data/vision-state.json', 'utf8'));
+
+// Show type x phase distribution
+const dist = {};
+for (const i of d.items) {
+  if (!dist[i.type]) dist[i.type] = {};
+  dist[i.type][i.phase] = (dist[i.type][i.phase] || 0) + 1;
+}
+console.log('=== TYPE x PHASE ===');
+for (const [type, phases] of Object.entries(dist).sort()) {
+  console.log(type + ':');
+  for (const [p, c] of Object.entries(phases).sort()) {
+    console.log('  ' + p.padEnd(18) + c);
+  }
+}
+
+// Items that are likely vision-phase
+console.log('\n=== LIKELY VISION PHASE ===');
+const visionTypes = new Set(['idea', 'thread', 'question']);
+for (const i of d.items) {
+  if (i.phase === 'vision') continue;
+  const t = i.title.toLowerCase();
+  let reason = '';
+  if (visionTypes.has(i.type)) reason = `type=${i.type}`;
+  else if (t.includes('vision') && i.type !== 'track' && i.type !== 'task') reason = 'title:vision';
+  else if (t.includes('discovery') && i.type !== 'track') reason = 'title:discovery';
+  else if (t.includes('brainstorm')) reason = 'title:brainstorm';
+  if (reason) {
+    console.log(`${i.id.slice(0,8)}  ${i.phase.padEnd(16)} ${i.type.padEnd(12)} ${reason.padEnd(16)} ${i.title}`);
+  }
+}