@agile-vibe-coding/avc 0.1.1 → 0.3.1

package/kanban/server/utils/markdown.js

@@ -0,0 +1,91 @@
+import { marked } from 'marked';
+
+/**
+ * Configure marked with safe defaults
+ */
+marked.setOptions({
+  gfm: true, // GitHub Flavored Markdown
+  breaks: true, // Line breaks as <br>
+  headerIds: true, // Add IDs to headers
+  mangle: false, // Don't mangle email addresses
+});
+
+/**
+ * Render markdown to HTML
+ * @param {string} markdown - Markdown content
+ * @returns {string} HTML content
+ */
+export function renderMarkdown(markdown) {
+  if (!markdown || typeof markdown !== 'string') {
+    return '';
+  }
+
+  try {
+    return marked.parse(markdown);
+  } catch (error) {
+    console.error('Error rendering markdown:', error);
+    return `<p>Error rendering markdown: ${error.message}</p>`;
+  }
+}
+
+/**
+ * Sanitize markdown content (remove potentially dangerous content)
+ * Note: For MVP, we're assuming trusted content from .avc/project/
+ * In production, consider using DOMPurify or similar
+ * @param {string} html - HTML content
+ * @returns {string} Sanitized HTML
+ */
+export function sanitizeHtml(html) {
+  // For now, just return as-is since content is from trusted source
+  // TODO: Add proper sanitization if exposing to untrusted users
+  return html;
+}
+
+/**
+ * Extract the description (first paragraph after H1) from a doc.md string.
+ * @param {string} markdown
+ * @returns {string}
+ */
+export function extractDescriptionFromDoc(markdown) {
+  if (!markdown) return '';
+  const lines = markdown.split('\n');
+  let pastH1 = false;
+  const descLines = [];
+  for (const line of lines) {
+    if (!pastH1) {
+      if (line.startsWith('# ')) pastH1 = true;
+      continue;
+    }
+    if (line.startsWith('#') || line.startsWith('---')) break;
+    if (line.trim() === '' && descLines.length > 0) break;
+    if (line.trim()) descLines.push(line.trim());
+  }
+  return descLines.join(' ');
+}
+
+/**
+ * Replace the first paragraph after H1 with newDescription.
+ * Preserves all content below the first paragraph unchanged.
+ * @param {string} markdown
+ * @param {string} newDescription
+ * @returns {string}
+ */
+export function updateDescriptionInDoc(markdown, newDescription) {
+  if (!markdown) return `\n\n${newDescription}\n`;
+  const lines = markdown.split('\n');
+  let h1Idx = -1, paraStart = -1, paraEnd = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (h1Idx === -1 && lines[i].startsWith('# ')) { h1Idx = i; continue; }
+    if (h1Idx !== -1 && paraStart === -1 && lines[i].trim()) { paraStart = i; continue; }
+    if (paraStart !== -1 && (!lines[i].trim() || lines[i].startsWith('#') || lines[i] === '---')) {
+      paraEnd = i; break;
+    }
+  }
+  if (paraStart === -1) {
+    lines.splice(h1Idx + 1, 0, '', newDescription);
+    return lines.join('\n');
+  }
+  if (paraEnd === -1) paraEnd = lines.length;
+  lines.splice(paraStart, paraEnd - paraStart, newDescription);
+  return lines.join('\n');
+}

package/kanban/server/utils/status-grouping.js

@@ -0,0 +1,107 @@
+/**
+ * Status Column Grouping Logic
+ * Maps AVC work item statuses to logical kanban columns
+ */
+
+/**
+ * Maps status values to their display column
+ * Key: Column name
+ * Value: Array of status values that belong in that column
+ */
+export const STATUS_COLUMN_MAPPING = {
+  Backlog: ['planned', 'pending'],
+  Ready: ['ready'],
+  'In Progress': ['implementing', 'feedback'],
+  Review: ['implemented', 'testing'],
+  Done: ['completed'],
+};
+
+/**
+ * Metadata for each status value
+ * Used for badges, colors, icons within grouped columns
+ */
+export const STATUS_METADATA = {
+  planned: { color: 'gray', icon: '📋', label: 'Planned' },
+  pending: { color: 'slate', icon: '⏸️', label: 'Pending' },
+  ready: { color: 'blue', icon: '🚀', label: 'Ready' },
+  implementing: { color: 'yellow', icon: '⚙️', label: 'Implementing' },
+  feedback: { color: 'amber', icon: '💬', label: 'Feedback' },
+  implemented: { color: 'purple', icon: '✅', label: 'Implemented' },
+  testing: { color: 'violet', icon: '🧪', label: 'Testing' },
+  completed: { color: 'green', icon: '🎉', label: 'Completed' },
+  blocked: { color: 'red', icon: '🚫', label: 'Blocked' },
+};
+
+/**
+ * Canonical order for columns on the board
+ */
+export const COLUMN_ORDER = ['Backlog', 'Ready', 'In Progress', 'Review', 'Done'];
+
+/**
+ * Get the column name for a given status
+ * @param {string} status - Work item status
+ * @returns {string|null} Column name or null if not found
+ */
+export function getColumnForStatus(status) {
+  for (const [column, statuses] of Object.entries(STATUS_COLUMN_MAPPING)) {
+    if (statuses.includes(status)) {
+      return column;
+    }
+  }
+  return null;
+}
+
+/**
+ * Get metadata for a status
+ * @param {string} status - Work item status
+ * @returns {object|null} Status metadata or null if not found
+ */
+export function getStatusMetadata(status) {
+  return STATUS_METADATA[status] || null;
+}
+
+/**
+ * Group work items by column
+ * @param {Array} workItems - Array of work items
+ * @returns {object} Object with column names as keys, arrays of work items as values
+ */
+export function groupItemsByColumn(workItems) {
+  const grouped = {};
+
+  // Initialize all columns as empty arrays
+  COLUMN_ORDER.forEach((column) => {
+    grouped[column] = [];
+  });
+
+  // Group items by their column
+  workItems.forEach((item) => {
+    const column = getColumnForStatus(item.status);
+    if (column && grouped[column]) {
+      grouped[column].push(item);
+    }
+  });
+
+  return grouped;
+}
+
+/**
+ * Get statistics for a column
+ * @param {Array} workItems - Work items in the column
+ * @returns {object} Statistics object with total count and breakdown by status
+ */
+export function getColumnStats(workItems) {
+  const stats = {
+    total: workItems.length,
+    byStatus: {},
+  };
+
+  workItems.forEach((item) => {
+    const status = item.status;
+    if (!stats.byStatus[status]) {
+      stats.byStatus[status] = 0;
+    }
+    stats.byStatus[status]++;
+  });
+
+  return stats;
+}

package/kanban/server/workers/run-task-worker.js

@@ -0,0 +1,121 @@
+/**
+ * Run Task Worker
+ * Forked by TaskRunnerService.runTask().
+ * Creates a git worktree, implements code via LLM, runs tests, commits, merges.
+ *
+ * Parent → Worker:
+ *   { type: 'init', taskId }
+ *   { type: 'cancel' }
+ *
+ * Worker → Parent:
+ *   { type: 'progress', message }
+ *   { type: 'complete', result: { success, taskId } }
+ *   { type: 'cancelled' }
+ *   { type: 'error', error }
+ */
+
+import { CommandLogger } from '../../../cli/command-logger.js';
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+let _cancelled = false;
+
+process.on('disconnect', () => {
+  _cancelled = true;
+  setTimeout(() => process.exit(1), 5000).unref();
+});
+
+process.on('message', async (msg) => {
+  if (msg.type === 'init') {
+    run(msg.taskId);
+  } else if (msg.type === 'cancel') {
+    _cancelled = true;
+  }
+});
+
+/**
+ * Update work.json status on disk.
+ */
+function updateStatus(taskId, status) {
+  const projectRoot = process.cwd();
+  // Find the work.json by walking the hierarchy
+  // Task ID: context-0001-0001-0001 → path: .avc/project/context-0001/context-0001-0001/context-0001-0001-0001/work.json
+  const idParts = taskId.replace('context-', '').split('-');
+  let dir = join(projectRoot, '.avc', 'project');
+  let current = 'context';
+  for (const part of idParts) {
+    current += `-${part}`;
+    dir = join(dir, current);
+  }
+  const workJsonPath = join(dir, 'work.json');
+
+  if (existsSync(workJsonPath)) {
+    try {
+      const workJson = JSON.parse(readFileSync(workJsonPath, 'utf8'));
+      workJson.status = status;
+      workJson.updated = new Date().toISOString();
+      writeFileSync(workJsonPath, JSON.stringify(workJson, null, 2), 'utf8');
+    } catch {}
+  }
+}
+
+async function run(taskId) {
+  const logger = new CommandLogger('run-task', process.cwd());
+  logger.start();
+
+  try {
+    const { WorktreeRunner } = await import('../../../cli/worktree-runner.js');
+
+    // Set status to implementing
+    updateStatus(taskId, 'implementing');
+    try { process.send({ type: 'progress', message: `Starting implementation of ${taskId}` }); } catch {}
+
+    const runner = new WorktreeRunner(taskId, process.cwd());
+
+    const progressCallback = (message) => {
+      if (_cancelled) return;
+      try { process.send({ type: 'progress', message }); } catch {}
+    };
+
+    const cancelledCheck = () => _cancelled;
+
+    const result = await runner.execute(progressCallback, cancelledCheck);
+
+    if (_cancelled) {
+      updateStatus(taskId, 'planned'); // Reset on cancel
+      try { process.send({ type: 'cancelled' }); } catch {}
+    } else if (result.success) {
+      updateStatus(taskId, 'completed');
+      try {
+        process.send({
+          type: 'complete',
+          result: { success: true, taskId },
+        });
+      } catch {}
+    } else {
+      updateStatus(taskId, 'failed');
+      try {
+        process.send({
+          type: 'error',
+          error: { message: result.error || 'Implementation failed' },
+        });
+      } catch {}
+    }
+  } catch (error) {
+    if (error.message === 'CANCELLED') {
+      updateStatus(taskId, 'planned');
+      try { process.send({ type: 'cancelled' }); } catch {}
+    } else {
+      updateStatus(taskId, 'failed');
+      try {
+        process.send({
+          type: 'error',
+          error: { message: error.message, stack: error.stack },
+        });
+      } catch {}
+    }
+  } finally {
+    logger.stop();
+    setTimeout(() => process.exit(0), 500).unref();
+  }
+}

package/kanban/server/workers/seed-worker.js

@@ -0,0 +1,94 @@
+/**
+ * Seed Worker
+ * Forked by TaskRunnerService.runSeed().
+ * Communicates with parent via IPC (process.send / process.on('message')).
+ *
+ * Parent → Worker:
+ *   { type: 'init', storyId }
+ *   { type: 'cancel' }
+ *
+ * Worker → Parent:
+ *   { type: 'progress', message }
+ *   { type: 'item-written', itemId, itemType }
+ *   { type: 'complete', result: { taskCount, subtaskCount, taskIds } }
+ *   { type: 'cancelled' }
+ *   { type: 'error', error }
+ */
+
+import { CommandLogger } from '../../../cli/command-logger.js';
+
+let _cancelled = false;
+
+process.on('disconnect', () => {
+  _cancelled = true;
+  setTimeout(() => process.exit(1), 5000).unref();
+});
+
+process.on('message', async (msg) => {
+  if (msg.type === 'init') {
+    run(msg.storyId);
+  } else if (msg.type === 'cancel') {
+    _cancelled = true;
+  }
+});
+
+async function run(storyId) {
+  const logger = new CommandLogger('seed', process.cwd());
+  logger.start();
+
+  try {
+    // Dynamic import to avoid loading CLI modules at fork time
+    const { SeedProcessor } = await import('../../../cli/seed-processor.js');
+
+    const processor = new SeedProcessor(storyId);
+
+    const progressCallback = (message) => {
+      if (_cancelled) return;
+      try { process.send({ type: 'progress', message }); } catch {}
+    };
+
+    const itemWrittenCallback = ({ itemId, itemType }) => {
+      if (_cancelled) return;
+      try { process.send({ type: 'item-written', itemId, itemType }); } catch {}
+    };
+
+    const cancelledCheck = () => _cancelled;
+
+    const result = await processor.executeWithCallback(
+      progressCallback,
+      itemWrittenCallback,
+      cancelledCheck
+    );
+
+    if (_cancelled) {
+      try { process.send({ type: 'cancelled' }); } catch {}
+    } else {
+      try {
+        process.send({
+          type: 'complete',
+          result: {
+            storyId,
+            taskCount: result.taskCount,
+            subtaskCount: result.subtaskCount,
+            taskIds: result.taskIds,
+          },
+        });
+      } catch {}
+    }
+  } catch (error) {
+    if (error.message === 'CEREMONY_CANCELLED') {
+      try { process.send({ type: 'cancelled' }); } catch {}
+    } else {
+      try {
+        process.send({
+          type: 'error',
+          error: { message: error.message, stack: error.stack },
+        });
+      } catch {}
+    }
+  } finally {
+    logger.stop();
+    // Give parent time to receive the final message
+    setTimeout(() => process.exit(0), 500).unref();
+  }
+}

package/kanban/server/workers/sponsor-call-worker.js

@@ -0,0 +1,92 @@
+/**
+ * Sponsor Call Worker
+ * Forked by CeremonyService.runSponsorCallInProcess().
+ * Same IPC protocol as sprint-planning-worker.js.
+ * Receives `requirements` in the init message.
+ */
+
+import { ProjectInitiator } from '../../../cli/init.js';
+import { CommandLogger } from '../../../cli/command-logger.js';
+
+let _paused = false;
+let _cancelled = false;
+let _requirements = null;
+let _costThreshold = null;
+let _waitingCostLimit = false;
+
+// Parent server stopped — exit rather than running as an orphan.
+process.on('disconnect', () => {
+  _cancelled = true;
+  // Give the current LLM call up to 5s to finish, then hard-exit.
+  setTimeout(() => process.exit(1), 5000).unref();
+});
+
+process.on('message', async (msg) => {
+  if (msg.type === 'init') {
+    _requirements = msg.requirements;
+    _costThreshold = msg.costThreshold ?? null;
+    run();
+  } else if (msg.type === 'pause') {
+    _paused = true;
+    process.send({ type: 'paused' });
+  } else if (msg.type === 'resume') {
+    _paused = false;
+    process.send({ type: 'resumed' });
+  } else if (msg.type === 'cancel') {
+    _cancelled = true;
+  } else if (msg.type === 'cost-limit-continue') {
+    _waitingCostLimit = false;
+  }
+});
+
+async function run() {
+  const logger = new CommandLogger('sponsor-call', process.cwd());
+  logger.start();
+  try {
+    const initiator = new ProjectInitiator();
+
+    const progressCallback = async (msg, substep, meta) => {
+      if (_cancelled) throw new Error('CEREMONY_CANCELLED');
+      while (_paused) {
+        await new Promise(r => setTimeout(r, 200));
+        if (_cancelled) throw new Error('CEREMONY_CANCELLED');
+      }
+      if (msg)          process.send({ type: 'progress', message: msg });
+      if (substep)      process.send({ type: 'substep',  substep, meta: meta || {} });
+      if (meta?.detail) process.send({ type: 'detail',   detail: meta.detail });
+    };
+
+    const costLimitReachedCallback = async (cost) => {
+      _waitingCostLimit = true;
+      process.send({ type: 'cost-limit', cost, threshold: _costThreshold });
+      while (_waitingCostLimit) {
+        await new Promise(r => setTimeout(r, 200));
+        if (_cancelled) throw new Error('CEREMONY_CANCELLED');
+      }
+    };
+
+    const result = await initiator.sponsorCallWithAnswers(_requirements, progressCallback, {
+      costThreshold: _costThreshold,
+      costLimitReachedCallback,
+    });
+    logger.stop();
+    // sponsorCallWithAnswers returns { error: true, message } on validation failure instead of throwing
+    if (result?.error === true) {
+      process.send({ type: 'error', error: result.message || 'Ceremony failed' });
+    } else {
+      process.send({ type: 'complete', result });
+    }
+    process.exit(0);
+  } catch (err) {
+    logger.stop();
+    const msg = err.message === 'CEREMONY_CANCELLED'
+      ? { type: 'cancelled' }
+      : { type: 'error', error: err.message };
+    // Guard against ERR_IPC_CHANNEL_CLOSED if the parent already disconnected.
+    try {
+      process.send(msg, () => process.exit(0));
+    } catch (_) {
+      process.exit(0);
+    }
+  }
+}