@agile-vibe-coding/avc 0.1.0 → 0.2.3

package/kanban/server/routes/ceremony.js

@@ -0,0 +1,305 @@
+import express from 'express';
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Ceremony Router
+ * Handles all /api/ceremony/* endpoints for the sponsor-call wizard.
+ * @param {CeremonyService} ceremonyService
+ */
+export function createCeremonyRouter(ceremonyService, processRegistry) {
+  const router = express.Router();
+
+  // GET /api/ceremony/status — current ceremony state
+  router.get('/status', (req, res) => {
+    res.json(ceremonyService.getStatus());
+  });
+
+  // GET /api/ceremony/models — available LLM models with API key status
+  router.get('/models', async (req, res) => {
+    try {
+      const models = await ceremonyService.getAvailableModels();
+      res.json(models);
+    } catch (err) {
+      console.error('getAvailableModels error:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // POST /api/ceremony/generate-mission
+  // Body: { description, modelId, provider, validatorModelId, validatorProvider }
+  router.post('/generate-mission', async (req, res) => {
+    const { description, modelId, provider, validatorModelId, validatorProvider } = req.body;
+    console.log('[ceremony] POST /generate-mission', {
+      descriptionLength: description?.length,
+      modelId,
+      provider,
+      validatorModelId,
+      validatorProvider,
+    });
+
+    if (!description?.trim() || !modelId || !provider || !validatorModelId || !validatorProvider) {
+      console.warn('[ceremony] generate-mission: missing required fields');
+      return res.status(400).json({
+        error: 'description, modelId, provider, validatorModelId and validatorProvider are required',
+      });
+    }
+
+    const start = Date.now();
+    try {
+      const result = await ceremonyService.generateMissionScope(
+        description, modelId, provider, validatorModelId, validatorProvider
+      );
+      console.log(`[ceremony] generate-mission completed in ${Date.now() - start}ms`, {
+        validationScore: result.validationScore,
+        iterations: result.iterations,
+        issueCount: result.issues?.length,
+      });
+      res.json(result);
+    } catch (err) {
+      console.error(`[ceremony] generate-mission failed in ${Date.now() - start}ms:`, err.message);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // POST /api/ceremony/refine-mission
+  // Body: { missionStatement, initialScope, refinementRequest, modelId, provider, validatorModelId, validatorProvider }
+  router.post('/refine-mission', async (req, res) => {
+    const { missionStatement, initialScope, refinementRequest, modelId, provider, validatorModelId, validatorProvider } = req.body;
+    if (!missionStatement?.trim() || !initialScope?.trim() || !refinementRequest?.trim() || !modelId || !provider || !validatorModelId || !validatorProvider) {
+      return res.status(400).json({ error: 'missionStatement, initialScope, refinementRequest, modelId, provider, validatorModelId and validatorProvider are required' });
+    }
+    const start = Date.now();
+    try {
+      const result = await ceremonyService.refineMissionScope(
+        missionStatement, initialScope, refinementRequest, modelId, provider, validatorModelId, validatorProvider
+      );
+      console.log(`[ceremony] refine-mission completed in ${Date.now() - start}ms`, { validationScore: result.validationScore, iterations: result.iterations });
+      res.json(result);
+    } catch (err) {
+      console.error('[ceremony] refine-mission failed:', err.message);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // POST /api/ceremony/generate-architecture
+  // Body: { description, modelId, provider }
+  router.post('/generate-architecture', async (req, res) => {
+    const { description, modelId, provider } = req.body;
+    if (!description?.trim() || !modelId || !provider) {
+      return res.status(400).json({ error: 'description, modelId and provider are required' });
+    }
+    try {
+      const arch = await ceremonyService.generateCustomArchitecture(description, modelId, provider);
+      res.json(arch);
+    } catch (err) {
+      console.error('[ceremony] generate-architecture failed:', err.message);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // POST /api/ceremony/refine-architecture
+  // Body: { currentArch, refinementRequest, modelId, provider }
+  router.post('/refine-architecture', async (req, res) => {
+    const { currentArch, refinementRequest, modelId, provider } = req.body;
+    if (!currentArch || !refinementRequest?.trim() || !modelId || !provider) {
+      return res.status(400).json({ error: 'currentArch, refinementRequest, modelId and provider are required' });
+    }
+    try {
+      const arch = await ceremonyService.refineCustomArchitecture(currentArch, refinementRequest, modelId, provider);
+      res.json(arch);
+    } catch (err) {
+      console.error('[ceremony] refine-architecture failed:', err.message);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // POST /api/ceremony/analyze/database
+  // Body: { mission, scope, strategy }
+  router.post('/analyze/database', async (req, res) => {
+    const { mission, scope, strategy } = req.body;
+    console.log('[ceremony] POST /analyze/database', {
+      missionLength: mission?.length,
+      scopeLines: scope?.split('\n').length,
+      strategy,
+    });
+    if (!mission || !scope) {
+      return res.status(400).json({ error: 'mission and scope are required' });
+    }
+    const start = Date.now();
+    try {
+      const result = await ceremonyService.analyzeDatabase(mission, scope, strategy || null);
+      console.log(`[ceremony] analyze/database completed in ${Date.now() - start}ms`);
+      res.json(result);
+    } catch (err) {
+      console.error(`[ceremony] analyze/database failed in ${Date.now() - start}ms:`, err.message);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // POST /api/ceremony/analyze/architecture
+  // Body: { mission, scope, dbContext, strategy }
+  router.post('/analyze/architecture', async (req, res) => {
+    const { mission, scope, dbContext, strategy } = req.body;
+    console.log('[ceremony] POST /analyze/architecture', {
+      missionLength: mission?.length,
+      dbContext: dbContext ? 'provided' : 'null',
+      strategy,
+    });
+    if (!mission || !scope) {
+      return res.status(400).json({ error: 'mission and scope are required' });
+    }
+    const start = Date.now();
+    try {
+      const result = await ceremonyService.analyzeArchitecture(
+        mission,
+        scope,
+        dbContext || null,
+        strategy || null
+      );
+      console.log(`[ceremony] analyze/architecture completed in ${Date.now() - start}ms`);
+      res.json(result);
+    } catch (err) {
+      console.error(`[ceremony] analyze/architecture failed in ${Date.now() - start}ms:`, err.message);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // POST /api/ceremony/analyze/prefill
+  // Body: { mission, scope, arch, dbContext, strategy }
+  router.post('/analyze/prefill', async (req, res) => {
+    const { mission, scope, arch, dbContext, strategy } = req.body;
+    console.log('[ceremony] POST /analyze/prefill', {
+      missionLength: mission?.length,
+      arch: arch ? 'provided' : 'null',
+      strategy,
+    });
+    if (!mission || !scope || !arch) {
+      return res.status(400).json({ error: 'mission, scope, and arch are required' });
+    }
+    const start = Date.now();
+    try {
+      const result = await ceremonyService.prefillAnswers(
+        mission,
+        scope,
+        arch,
+        dbContext || null,
+        strategy || null
+      );
+      console.log(`[ceremony] analyze/prefill completed in ${Date.now() - start}ms`);
+      res.json(result);
+    } catch (err) {
+      console.error(`[ceremony] analyze/prefill failed in ${Date.now() - start}ms:`, err.message);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // POST /api/ceremony/run
+  // Body: { requirements } — all 7 template variables
+  router.post('/run', async (req, res) => {
+    const { requirements } = req.body;
+    console.log('[ceremony] POST /run', {
+      requirementKeys: Object.keys(requirements || {}),
+      missionLength: requirements?.MISSION_STATEMENT?.length,
+    });
+    if (!requirements || !requirements.MISSION_STATEMENT) {
+      return res.status(400).json({ error: 'requirements.MISSION_STATEMENT is required' });
+    }
+    try {
+      const processId = await ceremonyService.runSponsorCallInProcess(processRegistry, requirements);
+      console.log('[ceremony] run started in process', processId);
+      res.json({ started: true, processId });
+    } catch (err) {
+      console.error('[ceremony] run error:', err.message);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // POST /api/ceremony/sprint-planning/run
+  router.post('/sprint-planning/run', async (req, res) => {
+    try {
+      const processId = await ceremonyService.runSprintPlanningInProcess(processRegistry);
+      console.log('[ceremony] sprint-planning/run started in process', processId);
+      res.json({ started: true, processId });
+    } catch (err) {
+      console.error('[ceremony] sprint-planning/run error:', err.message);
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  // POST /api/ceremony/sprint-planning/confirm-selection
+  // Body: { selectedEpicIds: string[], selectedStoryIds: string[] }
+  router.post('/sprint-planning/confirm-selection', (req, res) => {
+    const { selectedEpicIds, selectedStoryIds } = req.body;
+    if (!Array.isArray(selectedEpicIds) || !Array.isArray(selectedStoryIds)) {
+      return res.status(400).json({ error: 'selectedEpicIds and selectedStoryIds must be arrays' });
+    }
+    ceremonyService.confirmSprintPlanningSelection(selectedEpicIds, selectedStoryIds);
+    res.json({ ok: true });
+  });
+
+  // POST /api/ceremony/pause
+  router.post('/pause', (req, res) => {
+    ceremonyService.pause();
+    res.json({ ok: true });
+  });
+
+  // POST /api/ceremony/resume
+  router.post('/resume', (req, res) => {
+    ceremonyService.resume();
+    res.json({ ok: true });
+  });
+
+  // POST /api/ceremony/cancel
+  router.post('/cancel', (req, res) => {
+    ceremonyService.cancel();
+    res.json({ ok: true });
+  });
+
+  // POST /api/ceremony/cost-limit-continue
+  router.post('/cost-limit-continue', (req, res) => {
+    ceremonyService.continuePastCostLimit();
+    res.json({ ok: true });
+  });
+
+  // POST /api/ceremony/reset — force-stop any running ceremony and reset state immediately
+  router.post('/reset', (req, res) => {
+    ceremonyService.forceReset();
+    res.json({ ok: true });
+  });
+
+  // ── Sponsor-call draft (resume support) ────────────────────────────────────
+
+  const draftFilePath = () =>
+    path.join(ceremonyService.projectRoot, '.avc', 'sponsor-call-draft.json');
+
+  // GET /api/ceremony/sponsor-call/draft
+  router.get('/sponsor-call/draft', (req, res) => {
+    try {
+      const content = fs.readFileSync(draftFilePath(), 'utf8');
+      res.json(JSON.parse(content));
+    } catch (_) {
+      res.status(404).json({ draft: null });
+    }
+  });
+
+  // PUT /api/ceremony/sponsor-call/draft
+  router.put('/sponsor-call/draft', (req, res) => {
+    try {
+      const data = { ...req.body, savedAt: new Date().toISOString() };
+      fs.writeFileSync(draftFilePath(), JSON.stringify(data, null, 2));
+      res.json({ ok: true });
+    } catch (err) {
+      console.error('[ceremony] draft save error:', err.message);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // DELETE /api/ceremony/sponsor-call/draft
+  router.delete('/sponsor-call/draft', (req, res) => {
+    try { fs.unlinkSync(draftFilePath()); } catch (_) {}
+    res.json({ ok: true });
+  });
+
+  return router;
+}

package/kanban/server/routes/costs.js

@@ -0,0 +1,157 @@
+import express from 'express';
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Costs Router
+ * Handles GET /api/costs/summary and /api/costs/history
+ * Reads token-history.json written by TokenTracker.
+ * @param {string} projectRoot - Absolute path to project root
+ */
+export function createCostsRouter(projectRoot) {
+  const router = express.Router();
+  const historyPath = path.join(projectRoot, '.avc', 'token-history.json');
+
+  // Top-level ceremony names — each becomes a parent node in the hierarchy
+  const PARENT_CEREMONIES = ['sponsor-call', 'sprint-planning', 'seed'];
+
+  // Explicit stage → parent mapping for stages whose names don't carry a prefix
+  const STAGE_PARENT_MAP = {
+    'mission-scope':                   'sponsor-call',
+    'mission-refine':                  'sponsor-call',
+    'analyze-database':                'sponsor-call',
+    'analyze-architecture':            'sponsor-call',
+    'prefill-answers':                 'sponsor-call',
+    'sprint-planning-decomposition':   'sprint-planning',
+    'sprint-planning-validation':      'sprint-planning',
+    'sprint-planning-solver':          'sprint-planning',
+    'sprint-planning-doc-distribution':'sprint-planning',
+    'sprint-planning-enrichment':      'sprint-planning',
+  };
+
+  function getParentCeremony(key) {
+    if (STAGE_PARENT_MAP[key]) return STAGE_PARENT_MAP[key];
+    for (const parent of PARENT_CEREMONIES) {
+      if (key !== parent && key.startsWith(`${parent}-`)) return parent;
+    }
+    if (PARENT_CEREMONIES.includes(key)) return key; // self
+    return null;
+  }
+
+  function readHistory() {
+    if (!fs.existsSync(historyPath)) return null;
+    try {
+      return JSON.parse(fs.readFileSync(historyPath, 'utf8'));
+    } catch {
+      return null;
+    }
+  }
+
+  function getCurrentMonthKey() {
+    return new Date().toISOString().substring(0, 7); // YYYY-MM
+  }
+
+  // GET /api/costs/summary — current month totals for header chip
+  router.get('/summary', (req, res) => {
+    const history = readHistory();
+    if (!history) return res.json({ totalCost: 0, totalTokens: 0, apiCalls: 0 });
+
+    const monthKey = getCurrentMonthKey();
+    const monthly = history.totals?.monthly?.[monthKey] ?? {};
+
+    res.json({
+      totalCost: monthly.cost?.total ?? 0,
+      totalTokens: (monthly.input ?? 0) + (monthly.output ?? 0),
+      apiCalls: monthly.executions ?? 0,
+    });
+  });
+
+  // GET /api/costs/history?days=30 (or ?from=YYYY-MM-DD&to=YYYY-MM-DD)
+  router.get('/history', (req, res) => {
+    const history = readHistory();
+    if (!history) return res.json({ daily: [], ceremonies: [] });
+
+    // Determine date range
+    let cutoff, endDate;
+    if (req.query.from && req.query.to) {
+      cutoff = new Date(req.query.from);
+      endDate = new Date(req.query.to);
+      endDate.setDate(endDate.getDate() + 1); // inclusive end
+    } else {
+      const days = Math.max(1, Math.min(365, parseInt(req.query.days ?? '30', 10)));
+      cutoff = new Date();
+      cutoff.setDate(cutoff.getDate() - days);
+      endDate = new Date();
+      endDate.setDate(endDate.getDate() + 1);
+    }
+
+    // Filter daily totals
+    const dailyData = history.totals?.daily ?? {};
+    const daily = Object.entries(dailyData)
+      .filter(([date]) => {
+        const d = new Date(date);
+        return d >= cutoff && d < endDate;
+      })
+      .sort(([a], [b]) => a.localeCompare(b))
+      .map(([date, data]) => ({
+        date,
+        cost: data.cost?.total ?? 0,
+        tokens: data.total ?? 0,
+        executions: data.executions ?? 0,
+      }));
+
+    // Build parent node skeletons
+    const SKIP_KEYS = new Set(['version', 'lastUpdated', 'totals']);
+    const parentNodes = {};
+    for (const p of PARENT_CEREMONIES) {
+      parentNodes[p] = { name: p, calls: 0, tokens: 0, cost: 0, stages: [] };
+    }
+    const orphans = []; // keys that don't map to a known parent
+
+    for (const [key, value] of Object.entries(history)) {
+      if (SKIP_KEYS.has(key)) continue;
+      if (!value || typeof value !== 'object') continue;
+
+      let totalInput = 0, totalOutput = 0, totalCost = 0, totalExec = 0;
+      const dailyForKey = value.daily ?? {};
+      for (const [date, data] of Object.entries(dailyForKey)) {
+        const d = new Date(date);
+        if (d >= cutoff && d < endDate) {
+          totalInput  += data.input        ?? 0;
+          totalOutput += data.output       ?? 0;
+          totalCost   += data.cost?.total  ?? 0;
+          totalExec   += data.executions   ?? 0;
+        }
+      }
+
+      if (totalExec === 0 && totalInput === 0 && totalOutput === 0) continue;
+
+      const entry = { name: key, calls: totalExec, tokens: totalInput + totalOutput, cost: totalCost };
+      const parent = getParentCeremony(key);
+
+      if (parent && parentNodes[parent]) {
+        // Don't add a ceremony as a stage of itself — only add sub-stages
+        if (key !== parent) {
+          parentNodes[parent].stages.push(entry);
+        }
+        parentNodes[parent].calls   += totalExec;
+        parentNodes[parent].tokens  += totalInput + totalOutput;
+        parentNodes[parent].cost    += totalCost;
+      } else {
+        orphans.push({ ...entry, stages: [] });
+      }
+    }
+
+    // Sort stages within each parent by cost desc
+    const ceremonies = [
+      ...Object.values(parentNodes).filter(c => c.cost > 0 || c.tokens > 0),
+      ...orphans,
+    ]
+      .map(c => ({ ...c, stages: (c.stages || []).sort((a, b) => b.cost - a.cost) }))
+      .sort((a, b) => b.cost - a.cost);
+
+    res.json({ daily, ceremonies });
+  });
+
+  return router;
+}

package/kanban/server/routes/processes.js

@@ -0,0 +1,50 @@
+import express from 'express';
+
+/**
+ * Processes Router
+ * REST endpoints for monitoring and controlling forked ceremony/CLI processes.
+ * @param {ProcessRegistry} registry
+ */
+export function createProcessesRouter(registry) {
+  const router = express.Router();
+
+  // GET /api/processes — list all process DTOs (no logs)
+  router.get('/', (req, res) => {
+    res.json(registry.list());
+  });
+
+  // GET /api/processes/:id — single process DTO
+  router.get('/:id', (req, res) => {
+    const dto = registry.getDTO(req.params.id);
+    if (!dto) return res.status(404).json({ error: 'Process not found' });
+    res.json(dto);
+  });
+
+  // DELETE /api/processes — clear all completed/error/cancelled records
+  router.delete('/', (req, res) => {
+    registry.clearCompleted();
+    res.json({ ok: true });
+  });
+
+  // DELETE /api/processes/:id — kill running process or clear finished record
+  router.delete('/:id', (req, res) => {
+    const record = registry.get(req.params.id);
+    if (!record) return res.status(404).json({ error: 'Process not found' });
+    registry.kill(req.params.id);
+    res.json({ ok: true });
+  });
+
+  // POST /api/processes/:id/pause
+  router.post('/:id/pause', (req, res) => {
+    const ok = registry.pause(req.params.id);
+    res.json({ ok });
+  });
+
+  // POST /api/processes/:id/resume
+  router.post('/:id/resume', (req, res) => {
+    const ok = registry.resume(req.params.id);
+    res.json({ ok });
+  });
+
+  return router;
+}