@agile-vibe-coding/avc 0.1.0 → 0.2.3

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/sponsor-call-worker.js

@@ -0,0 +1,84 @@
+/**
+ * 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();
+    process.send({ type: 'complete', result });
+    process.exit(0);
+  } catch (err) {
+    logger.stop();
+    if (err.message === 'CEREMONY_CANCELLED') {
+      process.send({ type: 'cancelled' });
+    } else {
+      process.send({ type: 'error', error: err.message });
+    }
+    process.exit(0);
+  }
+}

package/kanban/server/workers/sprint-planning-worker.js

@@ -0,0 +1,130 @@
+/**
+ * Sprint Planning Worker
+ * Forked by CeremonyService.runSprintPlanningInProcess().
+ * Communicates with the parent via IPC (process.send / process.on('message')).
+ *
+ * Parent → Worker:
+ *   { type: 'init' }
+ *   { type: 'pause' }
+ *   { type: 'resume' }
+ *   { type: 'cancel' }
+ *   { type: 'selection-confirmed', selectedEpicIds, selectedStoryIds }
+ *
+ * Worker → Parent:
+ *   { type: 'progress', message }
+ *   { type: 'substep', substep, meta }
+ *   { type: 'detail', detail }
+ *   { type: 'paused' }
+ *   { type: 'resumed' }
+ *   { type: 'decomposition-complete', hierarchy }
+ *   { type: 'complete', result }
+ *   { type: 'cancelled' }
+ *   { type: 'error', error }
+ */
+
+import { ProjectInitiator } from '../../../cli/init.js';
+import { CommandLogger } from '../../../cli/command-logger.js';
+
+let _paused = false;
+let _cancelled = false;
+let _costThreshold = null;
+let _waitingCostLimit = false;
+let _waitingSelection = false;
+let _selectionResult = null;
+
+// 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') {
+    _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;
+  } else if (msg.type === 'selection-confirmed') {
+    _selectionResult = { selectedEpicIds: msg.selectedEpicIds, selectedStoryIds: msg.selectedStoryIds };
+    _waitingSelection = false;
+  }
+});
+
+async function run() {
+  const logger = new CommandLogger('sprint-planning', 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 selectionCallback = async (hierarchy) => {
+      _waitingSelection = true;
+      _selectionResult = null;
+      process.send({ type: 'decomposition-complete', hierarchy });
+      while (_waitingSelection) {
+        await new Promise(r => setTimeout(r, 200));
+        if (_cancelled) throw new Error('CEREMONY_CANCELLED');
+      }
+      return _selectionResult;
+    };
+
+    const result = await initiator.sprintPlanningWithCallback(progressCallback, {
+      costThreshold: _costThreshold,
+      costLimitReachedCallback,
+      selectionCallback,
+    });
+    logger.stop();
+    process.send({ type: 'complete', result });
+
+    // Non-fatal docs sync after ceremony completes
+    try {
+      const { DocsSyncProcessor } = await import('../../../cli/docs-sync.js');
+      const syncer = new DocsSyncProcessor(process.cwd());
+      const { existsSync } = await import('fs');
+      if (existsSync(syncer.docsDir)) {
+        await syncer.sync();
+        process.send({ type: 'docs-synced' });
+      }
+    } catch (e) {
+      process.send({ type: 'docs-sync-failed', error: e.message });
+    }
+
+    process.exit(0);
+  } catch (err) {
+    logger.stop();
+    if (err.message === 'CEREMONY_CANCELLED') {
+      process.send({ type: 'cancelled' });
+    } else {
+      process.send({ type: 'error', error: err.message });
+    }
+    process.exit(0);
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agile-vibe-coding/avc",
-  "version": "0.1.0",
+  "version": "0.2.3",
   "description": "Agile Vibe Coding (AVC) - Framework for managing AI agent-based software development projects",
   "type": "module",
   "main": "cli/index.js",
@@ -9,6 +9,7 @@
   },
   "files": [
     "cli/",
+    "kanban/",
     "README.md",
     "LICENSE"
   ],
@@ -16,7 +17,15 @@
     "access": "public"
   },
   "scripts": {
-    "test": "echo \"No tests specified yet\" && exit 0",
+    "test": "vitest run",
+    "test:unit": "vitest run tests/unit",
+    "test:integration": "vitest run tests/integration",
+    "test:watch": "vitest watch",
+    "test:coverage": "vitest run --coverage",
+    "test:ui": "vitest --ui",
+    "models:evaluate": "node cli/model-selector.js",
+    "models:tables": "node cli/generate-summary-table.js",
+    "test:e2e": "node tests/e2e/cli-e2e.js",
     "prepublishOnly": "echo \"Running pre-publish checks...\" && npm test"
   },
   "keywords": [
@@ -34,7 +43,7 @@
     "workflow"
   ],
   "author": "Nacho Coll",
-  "license": "MIT",
+  "license": "PolyForm-Noncommercial-1.0.0",
   "homepage": "https://agilevibecoding.org",
   "repository": {
     "type": "git",
@@ -45,14 +54,32 @@
     "url": "https://github.com/NachoColl/agilevibecoding/issues"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20.0.0"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.20.0",
+    "@google/genai": "^1.37.0",
+    "chokidar": "^4.0.3",
+    "cors": "^2.8.5",
     "dotenv": "^16.4.0",
-    "ink": "^5.0.1",
+    "express": "^4.21.2",
+    "ink": "^6.7.0",
     "ink-select-input": "^6.0.0",
     "ink-spinner": "^5.0.0",
-    "react": "^18.3.1"
+    "jsonrepair": "^3.13.2",
+    "marked": "^15.0.6",
+    "openai": "^6.19.0",
+    "react": "^19.0.0",
+    "vitepress": "^1.6.4",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@sinonjs/fake-timers": "^12.0.0",
+    "@vitest/coverage-v8": "^2.1.9",
+    "@vitest/ui": "^2.1.9",
+    "memfs": "^4.56.10",
+    "node-pty": "^1.1.0",
+    "sinon": "^19.0.5",
+    "vitest": "^2.1.9"
   }
-}
+}