@agile-vibe-coding/avc 0.1.1 → 0.3.1

package/kanban/server/routes/ceremony.js

@@ -0,0 +1,454 @@
+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, taskRunnerService = null) {
+  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/refine-field
+  // Body: { fieldKey, fieldLabel, currentValue, refinementRequest, context: { mission, scope }, modelId, provider }
+  router.post('/refine-field', async (req, res) => {
+    const { fieldKey, fieldLabel, currentValue, refinementRequest, context, modelId, provider } = req.body;
+    if (!fieldKey || !currentValue?.trim() || !refinementRequest?.trim() || !context?.mission || !modelId || !provider) {
+      return res.status(400).json({ error: 'fieldKey, currentValue, refinementRequest, context.mission, modelId and provider are required' });
+    }
+    const start = Date.now();
+    try {
+      const result = await ceremonyService.refineField(fieldKey, fieldLabel, currentValue, refinementRequest, context, modelId, provider);
+      console.log(`[ceremony] refine-field completed in ${Date.now() - start}ms`, { fieldKey });
+      res.json(result);
+    } catch (err) {
+      console.error(`[ceremony] refine-field 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 });
+    }
+  });
+
+  // GET /api/ceremony/sprint-planning/resumable — check if previous run can be resumed
+  router.get('/sprint-planning/resumable', async (req, res) => {
+    try {
+      const { CeremonyHistory } = await import('../../../cli/ceremony-history.js');
+      const historyPath = path.join(ceremonyService.projectRoot, '.avc');
+      const history = new CeremonyHistory(historyPath);
+      history.init();
+
+      const resumableStages = ['files-written', 'docs-generated', 'enrichment-complete'];
+      const ceremonies = history.data?.ceremonies?.['sprint-planning'];
+      const executions = ceremonies?.executions || [];
+      const last = executions[executions.length - 1];
+
+      if (!last) return res.json({ resumable: false });
+
+      const isAborted = last.status === 'aborted' || last.outcome === 'abrupt-termination' ||
+                        (last.status === 'in-progress');
+      const hasResumableCheckpoint = resumableStages.includes(last.stage);
+
+      if (!isAborted || !hasResumableCheckpoint) {
+        return res.json({ resumable: false, reason: isAborted ? 'checkpoint-too-early' : 'not-aborted' });
+      }
+
+      // Validate files exist on disk
+      const projectDir = path.join(ceremonyService.projectRoot, '.avc', 'project');
+      const epicDirs = fs.existsSync(projectDir)
+        ? fs.readdirSync(projectDir).filter(d => d.startsWith('context-') && fs.existsSync(path.join(projectDir, d, 'work.json')))
+        : [];
+
+      if (epicDirs.length === 0) {
+        return res.json({ resumable: false, reason: 'no-files-on-disk' });
+      }
+
+      const stageLabels = {
+        'files-written': 'File Writing (doc generation pending)',
+        'docs-generated': 'Doc Generation (enrichment pending)',
+        'enrichment-complete': 'Enrichment (summary pending)',
+      };
+
+      res.json({
+        resumable: true,
+        checkpoint: last.stage,
+        checkpointLabel: stageLabels[last.stage] || last.stage,
+        executionId: last.id,
+        timestamp: last.lastCheckpoint || last.startTime,
+        epics: epicDirs.length,
+      });
+    } catch (err) {
+      res.json({ resumable: false, reason: err.message });
+    }
+  });
+
+  // POST /api/ceremony/sprint-planning/run
+  router.post('/sprint-planning/run', async (req, res) => {
+    try {
+      const { resumeFrom } = req.body || {};
+      const processId = await ceremonyService.runSprintPlanningInProcess(processRegistry, resumeFrom || null);
+      console.log('[ceremony] sprint-planning/run started in process', processId, resumeFrom ? `(resume from ${resumeFrom})` : '');
+      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) => {
+    const keepItems = req.body?.keepItems === true;
+    ceremonyService.cancel({ keepItems });
+    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/quota-continue
+  // Body: { newProvider?: string, newModel?: string }
+  // Omit newProvider to retry with same model (e.g. user added credits).
+  router.post('/quota-continue', (req, res) => {
+    const { newProvider = null, newModel = null } = req.body || {};
+    ceremonyService.continueAfterQuota(newProvider, newModel);
+    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 });
+  });
+
+  // ---- Task Runner: Seed + Run ----
+
+  // POST /api/ceremony/seed/run — seed a story into tasks/subtasks
+  router.post('/seed/run', async (req, res) => {
+    if (!taskRunnerService) {
+      return res.status(503).json({ error: 'TaskRunnerService not available' });
+    }
+
+    const { storyId } = req.body;
+    if (!storyId || !/^context-\d{4}-\d{4}[a-z]?$/.test(storyId)) {
+      return res.status(400).json({ error: 'Valid storyId is required (format: context-XXXX-XXXX)' });
+    }
+
+    if (taskRunnerService.isRunning(storyId)) {
+      return res.status(409).json({ error: `Seed already running for ${storyId}` });
+    }
+
+    try {
+      const processId = taskRunnerService.runSeed(storyId);
+      res.json({ started: true, processId, storyId });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // POST /api/ceremony/run-task/run — run a task in a worktree
+  router.post('/run-task/run', async (req, res) => {
+    if (!taskRunnerService) {
+      return res.status(503).json({ error: 'TaskRunnerService not available' });
+    }
+
+    const { taskId } = req.body;
+    if (!taskId || !/^context-\d{4}-\d{4}[a-z]?-\d{4}$/.test(taskId)) {
+      return res.status(400).json({ error: 'Valid taskId is required (format: context-XXXX-XXXX-XXXX)' });
+    }
+
+    if (taskRunnerService.isRunning(taskId)) {
+      return res.status(409).json({ error: `Run already active for ${taskId}` });
+    }
+
+    try {
+      const processId = taskRunnerService.runTask(taskId);
+      res.json({ started: true, processId, taskId });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  // GET /api/ceremony/task-runner/status — list all active runs
+  router.get('/task-runner/status', (req, res) => {
+    if (!taskRunnerService) {
+      return res.status(503).json({ error: 'TaskRunnerService not available' });
+    }
+    res.json({ runs: taskRunnerService.listRuns() });
+  });
+
+  // POST /api/ceremony/task-runner/cancel — cancel a run
+  router.post('/task-runner/cancel', (req, res) => {
+    if (!taskRunnerService) {
+      return res.status(503).json({ error: 'TaskRunnerService not available' });
+    }
+    const { processId } = req.body;
+    if (!processId) return res.status(400).json({ error: 'processId is required' });
+
+    const cancelled = taskRunnerService.cancel(processId);
+    res.json({ cancelled });
+  });
+
+  return router;
+}

package/kanban/server/routes/costs.js

@@ -0,0 +1,163 @@
+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,
+        saved: data.cost?.saved ?? 0,
+        tokens: data.total ?? 0,
+        cached: data.cached ?? 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, cached: 0, saved: 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, totalCached = 0, totalSaved = 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;
+          totalCached += data.cached       ?? 0;
+          totalSaved  += data.cost?.saved  ?? 0;
+        }
+      }
+
+      if (totalExec === 0 && totalInput === 0 && totalOutput === 0) continue;
+
+      const entry = { name: key, calls: totalExec, tokens: totalInput + totalOutput, cost: totalCost, cached: totalCached, saved: totalSaved };
+      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;
+        parentNodes[parent].cached  += totalCached;
+        parentNodes[parent].saved   += totalSaved;
+      } 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;
+}