@agile-vibe-coding/avc 0.1.1 → 0.3.1

package/kanban/server/services/TaskRunnerService.js

@@ -0,0 +1,261 @@
+/**
+ * TaskRunnerService — Manages seed and run-task processes independently from CeremonyService.
+ *
+ * Supports multiple concurrent runs (each tracked by processId).
+ * Uses the same fork → IPC → WebSocket pattern as CeremonyService.
+ */
+
+import { fork } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+let _nextId = 1;
+
+export class TaskRunnerService {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this._runs = new Map(); // processId → { type, itemId, child, status, progress }
+    this.websocket = null;
+    this._reloadCallback = null;
+  }
+
+  setWebSocket(ws) { this.websocket = ws; }
+  setReloadCallback(fn) { this._reloadCallback = fn; }
+
+  /**
+   * Get the status of a specific run.
+   */
+  getRunStatus(processId) {
+    const run = this._runs.get(processId);
+    if (!run) return null;
+    return {
+      processId,
+      type: run.type,
+      itemId: run.itemId,
+      status: run.status,
+      progress: run.progress,
+    };
+  }
+
+  /**
+   * Get all active runs for a given item.
+   */
+  getRunsForItem(itemId) {
+    const runs = [];
+    for (const [processId, run] of this._runs) {
+      if (run.itemId === itemId) {
+        runs.push({ processId, type: run.type, status: run.status });
+      }
+    }
+    return runs;
+  }
+
+  /**
+   * List all active/recent runs.
+   */
+  listRuns() {
+    return [...this._runs.entries()].map(([processId, run]) => ({
+      processId,
+      type: run.type,
+      itemId: run.itemId,
+      status: run.status,
+    }));
+  }
+
+  /**
+   * Check if a specific item has an active run.
+   */
+  isRunning(itemId) {
+    for (const run of this._runs.values()) {
+      if (run.itemId === itemId && run.status === 'running') return true;
+    }
+    return false;
+  }
+
+  /**
+   * Fork a seed worker for a story.
+   * @param {string} storyId
+   * @returns {string} processId
+   */
+  runSeed(storyId) {
+    if (this.isRunning(storyId)) {
+      throw new Error(`Seed already running for ${storyId}`);
+    }
+
+    const processId = `seed-${_nextId++}`;
+    const workerPath = path.join(__dirname, '../workers/seed-worker.js');
+
+    const child = fork(workerPath, [], {
+      stdio: ['ignore', 'pipe', 'pipe', 'ipc'],
+      cwd: this.projectRoot,
+      env: { ...process.env },
+    });
+    child.stdout?.on('data', d => process.stdout.write(d));
+    child.stderr?.on('data', d => process.stderr.write(d));
+
+    const run = {
+      type: 'seed',
+      itemId: storyId,
+      child,
+      status: 'running',
+      progress: [],
+    };
+    this._runs.set(processId, run);
+
+    child.send({ type: 'init', storyId });
+
+    child.on('message', (msg) => this._handleMessage(processId, msg));
+    child.on('exit', (code) => this._handleExit(processId, code));
+
+    return processId;
+  }
+
+  /**
+   * Fork a run-task worker for a task.
+   * @param {string} taskId
+   * @returns {string} processId
+   */
+  runTask(taskId) {
+    if (this.isRunning(taskId)) {
+      throw new Error(`Run already active for ${taskId}`);
+    }
+
+    const processId = `run-${_nextId++}`;
+    const workerPath = path.join(__dirname, '../workers/run-task-worker.js');
+
+    const child = fork(workerPath, [], {
+      stdio: ['ignore', 'pipe', 'pipe', 'ipc'],
+      cwd: this.projectRoot,
+      env: { ...process.env },
+    });
+    child.stdout?.on('data', d => process.stdout.write(d));
+    child.stderr?.on('data', d => process.stderr.write(d));
+
+    const run = {
+      type: 'run-task',
+      itemId: taskId,
+      child,
+      status: 'running',
+      progress: [],
+    };
+    this._runs.set(processId, run);
+
+    child.send({ type: 'init', taskId });
+
+    child.on('message', (msg) => this._handleMessage(processId, msg));
+    child.on('exit', (code) => this._handleExit(processId, code));
+
+    return processId;
+  }
+
+  /**
+   * Cancel a running process.
+   */
+  cancel(processId) {
+    const run = this._runs.get(processId);
+    if (!run || run.status !== 'running') return false;
+
+    try { run.child.send({ type: 'cancel' }); } catch {}
+    run.status = 'cancelling';
+
+    // Safety net: SIGTERM after 10s, SIGKILL after 13s
+    const killTimer = setTimeout(() => {
+      if (run.status === 'cancelling') {
+        try { run.child.kill('SIGTERM'); } catch {}
+        setTimeout(() => {
+          if (run.status === 'cancelling') {
+            try { run.child.kill('SIGKILL'); } catch {}
+          }
+        }, 3000);
+      }
+    }, 10000);
+    run._killTimer = killTimer;
+
+    return true;
+  }
+
+  /**
+   * Handle IPC messages from workers.
+   */
+  _handleMessage(processId, msg) {
+    const run = this._runs.get(processId);
+    if (!run) return;
+
+    switch (msg.type) {
+      case 'progress':
+        run.progress.push(msg.message);
+        this.websocket?.broadcast({
+          type: `${run.type}:progress`,
+          processId,
+          itemId: run.itemId,
+          message: msg.message,
+        });
+        break;
+
+      case 'item-written':
+        this._reloadCallback?.();
+        this.websocket?.broadcastRefresh();
+        break;
+
+      case 'complete':
+        run.status = 'complete';
+        if (run._killTimer) clearTimeout(run._killTimer);
+        this._reloadCallback?.();
+        this.websocket?.broadcastRefresh();
+        this.websocket?.broadcast({
+          type: `${run.type}:complete`,
+          processId,
+          itemId: run.itemId,
+          result: msg.result,
+        });
+        break;
+
+      case 'cancelled':
+        run.status = 'cancelled';
+        if (run._killTimer) clearTimeout(run._killTimer);
+        this.websocket?.broadcast({
+          type: `${run.type}:cancelled`,
+          processId,
+          itemId: run.itemId,
+        });
+        break;
+
+      case 'error':
+        run.status = 'error';
+        if (run._killTimer) clearTimeout(run._killTimer);
+        this.websocket?.broadcast({
+          type: `${run.type}:error`,
+          processId,
+          itemId: run.itemId,
+          error: msg.error?.message || 'Unknown error',
+        });
+        break;
+    }
+  }
+
+  /**
+   * Handle worker exit.
+   */
+  _handleExit(processId, code) {
+    const run = this._runs.get(processId);
+    if (!run) return;
+
+    if (run._killTimer) clearTimeout(run._killTimer);
+
+    if (run.status === 'running' || run.status === 'cancelling') {
+      run.status = 'error';
+      this.websocket?.broadcast({
+        type: `${run.type}:error`,
+        processId,
+        itemId: run.itemId,
+        error: `Worker exited unexpectedly (code ${code})`,
+      });
+    }
+
+    // Clean up old runs after 5 minutes
+    setTimeout(() => this._runs.delete(processId), 5 * 60 * 1000);
+  }
+}

package/kanban/server/services/WorkItemReader.js

@@ -0,0 +1,123 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { extractDescriptionFromDoc } from '../utils/markdown.js';
+
+/**
+ * WorkItemReader
+ * Parses work.json files and builds hierarchical work item structure
+ */
+export class WorkItemReader {
+  /**
+   * @param {string} projectRoot - Absolute path to project root directory
+   */
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.avcProjectPath = path.join(projectRoot, '.avc', 'project');
+  }
+
+  /**
+   * Read and parse a single work.json file
+   * @param {string} filePath - Absolute path to work.json
+   * @returns {Promise<object|null>} Parsed work item or null if invalid
+   */
+  async readWorkItem(filePath) {
+    try {
+      const content = await fs.readFile(filePath, 'utf8');
+      const workItem = JSON.parse(content);
+
+      // Enhance with computed fields
+      workItem._filePath = filePath;
+      workItem._dirPath = path.dirname(filePath);
+
+      return workItem;
+    } catch (error) {
+      console.error(`Error reading work item from ${filePath}:`, error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Read all work items from an array of file paths
+   * @param {Array<string>} filePaths - Array of absolute paths to work.json files
+   * @returns {Promise<Array<object>>} Array of parsed work items
+   */
+  async readAllWorkItems(filePaths) {
+    const promises = filePaths.map((filePath) => this.readWorkItem(filePath));
+    const results = await Promise.all(promises);
+
+    // Filter out null results (failed reads)
+    return results.filter((item) => item !== null);
+  }
+
+  /**
+   * Determine work item type based on ID depth
+   * Example: context-0001 → epic, context-0001-0001 → story, etc.
+   * @param {string} id - Work item ID
+   * @returns {string} Type: 'epic' | 'story' | 'task' | 'subtask'
+   */
+  getWorkItemType(id) {
+    const parts = id.split('-');
+    const depth = parts.length - 1; // Subtract 1 for 'context' prefix
+
+    switch (depth) {
+      case 1:
+        return 'epic';
+      case 2:
+        return 'story';
+      case 3:
+        return 'task';
+      case 4:
+        return 'subtask';
+      default:
+        return 'unknown';
+    }
+  }
+
+  /**
+   * Get parent ID from a work item ID
+   * Example: context-0001-0001-0001 → context-0001-0001
+   * @param {string} id - Work item ID
+   * @returns {string|null} Parent ID or null if root level
+   */
+  getParentId(id) {
+    const parts = id.split('-');
+
+    if (parts.length <= 2) {
+      // Root level (epic), no parent
+      return null;
+    }
+
+    // Remove the last segment
+    return parts.slice(0, -1).join('-');
+  }
+
+  /**
+   * Read doc.md file for a work item
+   * @param {string} workItemPath - Directory path of work item
+   * @returns {Promise<string|null>} Markdown content or null if not found
+   */
+  async readDocumentation(workItemPath) {
+    try {
+      const docPath = path.join(workItemPath, 'doc.md');
+      return await fs.readFile(docPath, 'utf8');
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Get full details for a work item (including doc.md)
+   * @param {object} workItem - Base work item object
+   * @returns {Promise<object>} Enhanced work item with documentation
+   */
+  async getFullDetails(workItem) {
+    const dirPath = workItem._dirPath;
+    const doc = await this.readDocumentation(dirPath);
+    return {
+      ...workItem,
+      // doc.md opening paragraph is canonical; fall back to work.json value if no doc.md
+      description: doc ? extractDescriptionFromDoc(doc) || workItem.description : workItem.description,
+      documentation: doc,
+    };
+  }
+}