@smartmemory/compose 0.1.0

package/server/ideabox-cache.js

@@ -0,0 +1,77 @@
+/**
+ * server/ideabox-cache.js — JSON cache for ideabox data.
+ *
+ * Cache lives at .compose/data/ideabox-cache.json.
+ * Invalidated when the source file's mtime changes.
+ */
+
+import fs from 'node:fs'
+import path from 'node:path'
+import { parseIdeabox } from '../lib/ideabox.js'
+
+export class IdeaboxCache {
+  /**
+   * @param {string} dataDir   — absolute path to .compose/data/
+   * @param {string} sourceFile — absolute path to ideabox.md
+   */
+  constructor(dataDir, sourceFile) {
+    this._dataDir = dataDir
+    this._sourceFile = sourceFile
+    this._cachePath = path.join(dataDir, 'ideabox-cache.json')
+    this._cachedMtime = null
+    this._cachedData = null
+  }
+
+  /**
+   * Return parsed ideabox data, using cache when source file is unchanged.
+   * @returns {{ ideas, killed, nextId, _mtime: number }}
+   */
+  get() {
+    let sourceMtime = null
+    try {
+      const stat = fs.statSync(this._sourceFile)
+      sourceMtime = stat.mtimeMs
+    } catch {
+      // Source file missing — return empty
+      return { ideas: [], killed: [], nextId: 1, _mtime: null }
+    }
+
+    // Cache hit
+    if (this._cachedData && this._cachedMtime === sourceMtime) {
+      return this._cachedData
+    }
+
+    // Load from disk cache if mtime matches
+    if (fs.existsSync(this._cachePath)) {
+      try {
+        const disk = JSON.parse(fs.readFileSync(this._cachePath, 'utf-8'))
+        if (disk._mtime === sourceMtime) {
+          this._cachedMtime = sourceMtime
+          this._cachedData = disk
+          return disk
+        }
+      } catch { /* stale or corrupt — reparse */ }
+    }
+
+    // Parse fresh
+    const markdown = fs.readFileSync(this._sourceFile, 'utf-8')
+    const parsed = parseIdeabox(markdown)
+    const entry = { ...parsed, _mtime: sourceMtime }
+
+    // Write to disk cache
+    try {
+      fs.mkdirSync(this._dataDir, { recursive: true })
+      fs.writeFileSync(this._cachePath, JSON.stringify(entry, null, 2))
+    } catch { /* non-fatal */ }
+
+    this._cachedMtime = sourceMtime
+    this._cachedData = entry
+    return entry
+  }
+
+  /** Invalidate in-memory cache (e.g., after a write). */
+  invalidate() {
+    this._cachedMtime = null
+    this._cachedData = null
+  }
+}

package/server/ideabox-routes.js

@@ -0,0 +1,294 @@
+/**
+ * server/ideabox-routes.js — REST API for the ideabox feature.
+ *
+ * Routes:
+ *   GET    /api/ideabox                  — return parsed ideabox JSON (cached)
+ *   POST   /api/ideabox/ideas            — add new idea
+ *   PATCH  /api/ideabox/ideas/:id        — update priority/status/etc.
+ *   POST   /api/ideabox/ideas/:id/promote — promote to feature
+ *   POST   /api/ideabox/ideas/:id/kill   — kill with reason
+ *   DELETE /api/ideabox/ideas/:id        — not allowed (use kill)
+ */
+
+import fs from 'node:fs'
+import path from 'node:path'
+import {
+  readIdeabox,
+  writeIdeabox,
+  addIdea,
+  promoteIdea,
+  killIdea,
+  resurrectIdea,
+  setPriority,
+  updateIdea,
+  addDiscussion,
+} from '../lib/ideabox.js'
+import { IdeaboxCache } from './ideabox-cache.js'
+
+/**
+ * @param {object} app              — Express app
+ * @param {{ getProjectRoot, getDataDir, broadcastMessage }} deps
+ */
+export function attachIdeaboxRoutes(app, { getProjectRoot, getDataDir, broadcastMessage }) {
+  // Lazily created per project root — we need to handle project switches
+  let _cache = null
+  let _lastProjectRoot = null
+  let _lastDataDir = null
+
+  function getCache() {
+    const projectRoot = getProjectRoot()
+    const dataDir = getDataDir()
+    if (!_cache || _lastProjectRoot !== projectRoot || _lastDataDir !== dataDir) {
+      const config = loadConfig(projectRoot)
+      const ideaboxRel = config?.paths?.ideabox || 'docs/product/ideabox.md'
+      const sourceFile = path.join(projectRoot, ideaboxRel)
+      _cache = new IdeaboxCache(dataDir, sourceFile)
+      _lastProjectRoot = projectRoot
+      _lastDataDir = dataDir
+    }
+    return _cache
+  }
+
+  function getIdeaboxPath(projectRoot) {
+    const config = loadConfig(projectRoot)
+    return config?.paths?.ideabox || 'docs/product/ideabox.md'
+  }
+
+  function broadcastUpdate() {
+    if (broadcastMessage) {
+      broadcastMessage({ type: 'ideaboxUpdated', timestamp: new Date().toISOString() })
+    }
+  }
+
+  // GET /api/ideabox
+  app.get('/api/ideabox', (_req, res) => {
+    try {
+      const cache = getCache()
+      const data = cache.get()
+      res.json(data)
+    } catch (err) {
+      res.status(500).json({ error: err.message })
+    }
+  })
+
+  // POST /api/ideabox/ideas
+  app.post('/api/ideabox/ideas', (req, res) => {
+    try {
+      const { title, description, source, tags, cluster } = req.body || {}
+      if (!title) return res.status(400).json({ error: 'title is required' })
+
+      const projectRoot = getProjectRoot()
+      const ideaboxPath = getIdeaboxPath(projectRoot)
+      const parsed = readIdeabox(projectRoot, ideaboxPath)
+      addIdea(parsed, { title, description, source, tags, cluster })
+      writeIdeabox(projectRoot, ideaboxPath, parsed)
+      getCache().invalidate()
+      broadcastUpdate()
+      // Return the newly created idea
+      const newIdea = parsed.ideas[parsed.ideas.length - 1]
+      res.status(201).json(newIdea)
+    } catch (err) {
+      res.status(500).json({ error: err.message })
+    }
+  })
+
+  // PATCH /api/ideabox/ideas/:id
+  app.patch('/api/ideabox/ideas/:id', (req, res) => {
+    try {
+      const { id } = req.params
+      const fields = req.body || {}
+
+      const projectRoot = getProjectRoot()
+      const ideaboxPath = getIdeaboxPath(projectRoot)
+      const parsed = readIdeabox(projectRoot, ideaboxPath)
+
+      // Handle priority shortcut
+      if (fields.priority) {
+        setPriority(parsed, id, fields.priority)
+        delete fields.priority
+      }
+
+      // Reject status changes via PATCH — must use /promote or /kill endpoints
+      // to ensure proper transition logic (move to killed section, set fields, etc.)
+      if (fields.status !== undefined) {
+        return res.status(400).json({
+          error: 'Status changes must go through /promote or /kill endpoints, not PATCH'
+        })
+      }
+
+      // Handle remaining fields (no status)
+      const allowed = ['title', 'description', 'source', 'tags', 'cluster', 'mapsTo', 'effort', 'impact']
+      const safeFields = {}
+      for (const k of allowed) {
+        if (fields[k] !== undefined) safeFields[k] = fields[k]
+      }
+      // Validate enum fields
+      if (safeFields.effort !== undefined && safeFields.effort !== null && !['S', 'M', 'L'].includes(safeFields.effort)) {
+        return res.status(400).json({ error: 'effort must be S, M, L, or null' })
+      }
+      if (safeFields.impact !== undefined && safeFields.impact !== null && !['low', 'medium', 'high'].includes(safeFields.impact)) {
+        return res.status(400).json({ error: 'impact must be low, medium, high, or null' })
+      }
+      if (Object.keys(safeFields).length > 0) {
+        updateIdea(parsed, id, safeFields)
+      }
+
+      writeIdeabox(projectRoot, ideaboxPath, parsed)
+      getCache().invalidate()
+      broadcastUpdate()
+
+      // Find and return the updated idea
+      const upper = id.toUpperCase()
+      const updated = [...parsed.ideas, ...parsed.killed].find(i => i.id.toUpperCase() === upper)
+      res.json(updated || { id })
+    } catch (err) {
+      const status = err.message.includes('not found') ? 404 : 500
+      res.status(status).json({ error: err.message })
+    }
+  })
+
+  // POST /api/ideabox/ideas/:id/promote
+  app.post('/api/ideabox/ideas/:id/promote', (req, res) => {
+    try {
+      const { id } = req.params
+      const { featureCode } = req.body || {}
+
+      const projectRoot = getProjectRoot()
+      const ideaboxPath = getIdeaboxPath(projectRoot)
+      const parsed = readIdeabox(projectRoot, ideaboxPath)
+
+      // Find the idea before promoting (need title for feature folder seed)
+      const upper = id.toUpperCase()
+      const sourceIdea = parsed.ideas.find(i => i.id.toUpperCase() === upper)
+      if (!sourceIdea) {
+        return res.status(404).json({ error: `Idea not found: ${id}` })
+      }
+
+      // Resolve feature code: explicit, or derived from idea
+      let resolvedCode = featureCode
+      if (!resolvedCode) {
+        const slug = sourceIdea.title.toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 20).replace(/-+$/, '')
+        resolvedCode = `IDEA-${sourceIdea.num}-${slug}`.toUpperCase()
+      }
+
+      // Create feature folder + feature.json (same logic as CLI promote)
+      const composeJsonPath = path.join(projectRoot, '.compose', 'compose.json')
+      let featuresRel = 'docs/features'
+      if (fs.existsSync(composeJsonPath)) {
+        try {
+          const cfg = JSON.parse(fs.readFileSync(composeJsonPath, 'utf-8'))
+          featuresRel = cfg?.paths?.features || 'docs/features'
+        } catch {}
+      }
+      const featuresDir = path.join(projectRoot, featuresRel, resolvedCode)
+      if (!fs.existsSync(featuresDir)) {
+        fs.mkdirSync(featuresDir, { recursive: true })
+        fs.writeFileSync(path.join(featuresDir, 'feature.json'), JSON.stringify({
+          code: resolvedCode,
+          description: sourceIdea.title,
+          status: 'PLANNED',
+          promotedFrom: sourceIdea.id,
+          createdAt: new Date().toISOString(),
+        }, null, 2))
+      }
+
+      promoteIdea(parsed, id, resolvedCode)
+      writeIdeabox(projectRoot, ideaboxPath, parsed)
+      getCache().invalidate()
+      broadcastUpdate()
+
+      const updated = parsed.ideas.find(i => i.id.toUpperCase() === upper)
+      res.json({ ...(updated || { id }), featureCode: resolvedCode, featurePath: `${featuresRel}/${resolvedCode}` })
+    } catch (err) {
+      const status = err.message.includes('not found') ? 404 : 500
+      res.status(status).json({ error: err.message })
+    }
+  })
+
+  // POST /api/ideabox/ideas/:id/kill
+  app.post('/api/ideabox/ideas/:id/kill', (req, res) => {
+    try {
+      const { id } = req.params
+      const { reason } = req.body || {}
+
+      const projectRoot = getProjectRoot()
+      const ideaboxPath = getIdeaboxPath(projectRoot)
+      const parsed = readIdeabox(projectRoot, ideaboxPath)
+      killIdea(parsed, id, reason || '')
+      writeIdeabox(projectRoot, ideaboxPath, parsed)
+      getCache().invalidate()
+      broadcastUpdate()
+
+      const upper = id.toUpperCase()
+      const killed = parsed.killed.find(i => i.id.toUpperCase() === upper)
+      res.json(killed || { id })
+    } catch (err) {
+      const status = err.message.includes('not found') ? 404 : 500
+      res.status(status).json({ error: err.message })
+    }
+  })
+
+  // POST /api/ideabox/ideas/:id/resurrect
+  app.post('/api/ideabox/ideas/:id/resurrect', (req, res) => {
+    try {
+      const { id } = req.params
+      const projectRoot = getProjectRoot()
+      const ideaboxPath = getIdeaboxPath(projectRoot)
+      const parsed = readIdeabox(projectRoot, ideaboxPath)
+      resurrectIdea(parsed, id)
+      writeIdeabox(projectRoot, ideaboxPath, parsed)
+      getCache().invalidate()
+      broadcastUpdate()
+
+      const upper = id.toUpperCase()
+      const restored = parsed.ideas.find(i => i.id.toUpperCase() === upper)
+      res.json(restored || { id })
+    } catch (err) {
+      const status = err.message.includes('not found') ? 404 : 500
+      res.status(status).json({ error: err.message })
+    }
+  })
+
+  // POST /api/ideabox/ideas/:id/discuss
+  app.post('/api/ideabox/ideas/:id/discuss', (req, res) => {
+    try {
+      const { id } = req.params
+      const { author, text } = req.body || {}
+      if (!author) return res.status(400).json({ error: 'author is required' })
+      if (!text) return res.status(400).json({ error: 'text is required' })
+
+      const projectRoot = getProjectRoot()
+      const ideaboxPath = getIdeaboxPath(projectRoot)
+      const parsed = readIdeabox(projectRoot, ideaboxPath)
+      addDiscussion(parsed, id, author, text)
+      writeIdeabox(projectRoot, ideaboxPath, parsed)
+      getCache().invalidate()
+      broadcastUpdate()
+
+      const upper = id.toUpperCase()
+      const updated = [...parsed.ideas, ...parsed.killed].find(i => i.id.toUpperCase() === upper)
+      res.status(201).json(updated || { id })
+    } catch (err) {
+      const status = err.message.includes('not found') ? 404 : 500
+      res.status(status).json({ error: err.message })
+    }
+  })
+
+  // DELETE /api/ideabox/ideas/:id — not allowed
+  app.delete('/api/ideabox/ideas/:id', (_req, res) => {
+    res.status(405).json({ error: 'Deletion not allowed. Use POST /api/ideabox/ideas/:id/kill instead.' })
+  })
+}
+
+// ---------------------------------------------------------------------------
+// Internal: load compose.json config
+// ---------------------------------------------------------------------------
+
+function loadConfig(projectRoot) {
+  const configPath = path.join(projectRoot, '.compose', 'compose.json')
+  try {
+    return JSON.parse(fs.readFileSync(configPath, 'utf-8'))
+  } catch {
+    return null
+  }
+}

package/server/index.js

@@ -0,0 +1,156 @@
+import express from 'express';
+import cors from 'cors';
+import http from 'node:http';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { FileWatcherServer } from './file-watcher.js';
+import { VisionStore } from './vision-store.js';
+import { VisionServer } from './vision-server.js';
+import { SessionManager } from './session-manager.js';
+import { scanFeatures, seedFeatures, scanSubPackages, seedSubPackages, seedFromRoadmapGraph } from './feature-scan.js';
+import { attachGraphExportRoutes } from './graph-export.js';
+import { getTargetRoot, getDataDir, ensureDataDir, loadProjectConfig, resolveProjectPath, switchProject } from './project-root.js';
+
+// Load project config and verify stratum capability matches reality
+const projectConfig = loadProjectConfig();
+if (projectConfig.capabilities.stratum) {
+  try {
+    execFileSync('which', ['stratum-mcp'], { stdio: 'ignore' });
+  } catch {
+    console.error('[compose] stratum-mcp not found but capabilities.stratum=true');
+    console.error('[compose] Run: compose init (will auto-install) or compose init --no-stratum');
+    projectConfig.capabilities.stratum = false;
+  }
+}
+
+// Handle unexpected errors — fatal startup errors exit (supervisor retries),
+// runtime errors keep the process alive to preserve PTY sessions
+let serverListening = false;
+process.on('uncaughtException', (err) => {
+  if (!serverListening && err.code === 'EADDRINUSE') {
+    console.error(`[compose] Port in use, exiting for supervisor retry: ${err.message}`);
+    process.exit(1);
+  }
+  console.error('[compose] Uncaught exception (process kept alive):', err.message);
+  console.error(err.stack);
+});
+process.on('unhandledRejection', (reason) => {
+  console.error('[compose] Unhandled rejection (process kept alive):', reason);
+});
+process.on('SIGTERM', () => {
+  console.log('[compose] SIGTERM received, shutting down gracefully');
+  process.exit(0);
+});
+
+const PORT = process.env.PORT || 4001;
+const app = express();
+app.use(cors({ origin: /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/ }));
+app.use(express.json());
+
+app.get('/api/health', (_req, res) => res.json({ ok: true }));
+app.get('/api/status', (_req, res) => res.json({ session: 2, phase: '0.4-brainstorm', upSince: new Date().toISOString() }));
+
+// Project info + switching
+app.get('/api/project', (_req, res) => {
+  const root = getTargetRoot();
+  res.json({
+    targetRoot: root,
+    name: path.basename(root),
+    dataDir: getDataDir(),
+  });
+});
+
+app.post('/api/project/switch', (req, res) => {
+  const { path: projectPath } = req.body || {};
+  if (!projectPath) return res.status(400).json({ error: 'path is required' });
+  try {
+    const result = switchProject(projectPath);
+    ensureDataDir();
+    // Reload store from new data directory
+    visionStore.reloadFrom(result.dataDir);
+    // Re-scan features, sub-packages, and roadmap graph from new project
+    try {
+      const features = scanFeatures();
+      if (features.length > 0) seedFeatures(features, visionStore);
+      const packages = scanSubPackages();
+      if (packages.length > 0) seedSubPackages(packages, visionStore);
+      seedFromRoadmapGraph(visionStore);
+    } catch (err) {
+      console.error('[compose] Feature scan after switch:', err.message);
+    }
+    // Broadcast new state to all connected clients
+    visionServer.scheduleBroadcast();
+    res.json({ ok: true, targetRoot: result.targetRoot, name: path.basename(result.targetRoot) });
+  } catch (err) {
+    res.status(400).json({ error: err.message });
+  }
+});
+
+const server = http.createServer(app);
+const fileWatcher = new FileWatcherServer();
+fileWatcher.attach(server, app);
+ensureDataDir();
+const visionStore = new VisionStore(getDataDir());
+const sessionManager = new SessionManager({
+  getFeaturePhase: (featureCode) => {
+    const item = visionStore.getItemByFeatureCode(featureCode);
+    return item?.lifecycle?.currentPhase || null;
+  },
+  featureRoot: resolveProjectPath('features'),
+});
+const visionServer = new VisionServer(visionStore, sessionManager, { config: projectConfig });
+visionServer.attach(server, app);
+
+// Seed feature folders, sub-packages, and roadmap graph into vision store on startup
+try {
+  const features = scanFeatures();
+  if (features.length > 0) seedFeatures(features, visionStore);
+  const packages = scanSubPackages();
+  if (packages.length > 0) seedSubPackages(packages, visionStore);
+  seedFromRoadmapGraph(visionStore);
+} catch (err) {
+  console.error('[compose] Feature scan startup error:', err.message);
+}
+
+// Wire feature folder changes → auto-reseed vision store
+fileWatcher.onFeatureChanged = (_relativePath) => {
+  try {
+    const features = scanFeatures();
+    seedFeatures(features, visionStore);
+    visionServer.scheduleBroadcast();
+  } catch (err) {
+    console.error('[compose] Feature reseed error:', err.message);
+  }
+};
+
+// Wire build state changes → broadcast over /ws/vision
+fileWatcher.onBuildStateChanged = (state) => {
+  if (state) {
+    // Broadcast flat payload per STRAT-COMP-4 contract
+    visionServer.broadcastMessage({ type: 'buildState', ...state });
+  }
+};
+
+// Manual WebSocket upgrade routing — avoids the ws library bug where multiple
+// WebSocketServers on the same HTTP server write 400 on each other's connections
+server.on('upgrade', (req, socket, head) => {
+  const { pathname } = new URL(req.url, 'http://localhost');
+  if (pathname === '/ws/files' && fileWatcher.wss) {
+    fileWatcher.wss.handleUpgrade(req, socket, head, (ws) => {
+      fileWatcher.wss.emit('connection', ws, req);
+    });
+  } else if (pathname === '/ws/vision' && visionServer.wss) {
+    visionServer.wss.handleUpgrade(req, socket, head, (ws) => {
+      visionServer.wss.emit('connection', ws, req);
+    });
+  } else {
+    socket.destroy();
+  }
+});
+
+server.listen(PORT, '127.0.0.1', () => {
+  serverListening = true;
+  console.log(`Compose server running on http://127.0.0.1:${PORT}`);
+  console.log(`File watcher WebSocket: ws://localhost:${PORT}/ws/files`);
+  console.log(`Vision WebSocket: ws://localhost:${PORT}/ws/vision`);
+});

package/server/model-tiers.js

@@ -0,0 +1,49 @@
+/**
+ * model-tiers.js — Model tier routing for STRAT-TIER.
+ *
+ * Maps symbolic tier names to concrete Anthropic model IDs.
+ * Tiers let pipeline specs declare intent (critical / standard / fast)
+ * without hard-coding model strings — the map here is the single source of truth.
+ */
+
+/** @type {Record<string, string>} */
+export const MODEL_TIERS = {
+  critical: 'claude-opus-4-7',
+  standard: 'claude-sonnet-4-6',
+  fast: 'claude-haiku-4-5-20251001',
+};
+
+/**
+ * Default thinking config per tier.
+ * - Opus 4.7 / Sonnet 4.6 support adaptive thinking and the effort parameter.
+ * - Haiku 4.5 doesn't accept the effort parameter (400 error), so fast tier stays off.
+ *
+ * @type {Record<string, { mode: 'adaptive'|'off', effort: 'low'|'medium'|'high'|'xhigh'|'max'|null }>}
+ */
+export const TIER_THINKING = {
+  critical: { mode: 'adaptive', effort: 'xhigh' },
+  standard: { mode: 'adaptive', effort: 'high' },
+  fast:     { mode: 'off',      effort: null   },
+};
+
+/**
+ * Resolve a tier name to a concrete model ID.
+ *
+ * @param {string|null|undefined} tier
+ * @returns {string|null}  Model ID, or null if tier is unknown / not provided.
+ */
+export function resolveTierModel(tier) {
+  if (!tier) return null;
+  return MODEL_TIERS[tier] ?? null;
+}
+
+/**
+ * Resolve a tier name to its default thinking config.
+ *
+ * @param {string|null|undefined} tier
+ * @returns {{ mode: string, effort: string|null }|null}
+ */
+export function resolveTierThinking(tier) {
+  if (!tier) return null;
+  return TIER_THINKING[tier] ?? null;
+}