tlc-claude-code 1.4.8 → 1.4.9

package/server/lib/dashboard/tasks-api.js

@@ -0,0 +1,289 @@
+/**
+ * Tasks API Module
+ * REST API for task CRUD operations
+ */
+import { promises as defaultFs } from 'fs';
+import path from 'path';
+import { createTlcIntrospection } from './tlc-introspection.js';
+
+/**
+ * Parse tasks from PLAN.md content
+ * @param {string} content - Plan file content
+ * @returns {Array} Parsed tasks
+ */
+export function parseTasksFromPlan(content) {
+  const tasks = [];
+  const lines = content.split('\n');
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // Match: ### Task N: Name [status@owner] or ### Task N: Name [status]
+    const taskMatch = line.match(/^###\s+Task\s+(\d+):\s*(.+?)\s*\[(x|>|\s*)(?:@(\w+))?\]/);
+    if (taskMatch) {
+      const number = parseInt(taskMatch[1], 10);
+      const subject = taskMatch[2].trim();
+      const marker = taskMatch[3];
+      const owner = taskMatch[4] || null;
+
+      let status;
+      if (marker === 'x') {
+        status = 'completed';
+      } else if (marker === '>') {
+        status = 'in_progress';
+      } else {
+        status = 'pending';
+      }
+
+      // Look for goal in next lines
+      let goal = null;
+      for (let j = i + 1; j < lines.length && j < i + 5; j++) {
+        const goalMatch = lines[j].match(/^\*\*Goal:\*\*\s*(.+)$/);
+        if (goalMatch) {
+          goal = goalMatch[1].trim();
+          break;
+        }
+        // Stop if we hit another task
+        if (lines[j].match(/^###\s+Task/)) break;
+      }
+
+      tasks.push({
+        number,
+        subject,
+        status,
+        owner,
+        goal
+      });
+    }
+  }
+
+  return tasks;
+}
+
+/**
+ * Format task for API response
+ * @param {Object} task - Raw task object
+ * @param {number} phase - Phase number
+ * @returns {Object} Formatted task
+ */
+export function formatTaskForApi(task, phase) {
+  return {
+    id: `phase-${phase}-task-${task.number}`,
+    phase,
+    number: task.number,
+    subject: task.subject,
+    status: task.status,
+    owner: task.owner,
+    goal: task.goal
+  };
+}
+
+/**
+ * Get tasks from current phase
+ * @param {Object} options - Options
+ * @returns {Promise<Array>} Tasks array
+ */
+export async function getTasks(options = {}) {
+  const { introspection, fs: fileSystem = defaultFs, basePath = process.cwd() } = options;
+
+  const currentPhase = introspection.getCurrentPhase();
+  const phaseNumber = currentPhase?.number || 1;
+
+  // Try to read the phase plan file
+  const planPath = path.join(basePath, '.planning', 'phases', `${phaseNumber}-PLAN.md`);
+
+  let content = '';
+  try {
+    content = await fileSystem.readFile(planPath, 'utf-8');
+  } catch {
+    content = '';
+  }
+
+  const tasks = parseTasksFromPlan(content);
+  return tasks.map(task => formatTaskForApi(task, phaseNumber));
+}
+
+/**
+ * Create a new task
+ * @param {Object} taskData - Task data
+ * @param {Object} options - Options
+ * @returns {Promise<Object>} Created task
+ */
+export async function createTask(taskData, options = {}) {
+  if (!taskData.subject) {
+    throw new Error('Subject is required');
+  }
+
+  const { fs: fileSystem = defaultFs, basePath = process.cwd() } = options;
+  const phase = taskData.phase || 1;
+
+  const planPath = path.join(basePath, '.planning', 'phases', `${phase}-PLAN.md`);
+
+  let content = '';
+  try {
+    content = await fileSystem.readFile(planPath, 'utf-8');
+  } catch {
+    content = '## Tasks\n';
+  }
+
+  // Find highest task number
+  const existingTasks = parseTasksFromPlan(content);
+  const maxNumber = existingTasks.reduce((max, t) => Math.max(max, t.number), 0);
+  const newNumber = maxNumber + 1;
+
+  // Create task markdown
+  const taskMd = `\n### Task ${newNumber}: ${taskData.subject} [ ]\n**Goal:** ${taskData.description || 'TBD'}\n`;
+
+  // Append to content
+  const newContent = content + taskMd;
+  await fileSystem.writeFile(planPath, newContent);
+
+  return {
+    id: `phase-${phase}-task-${newNumber}`,
+    phase,
+    number: newNumber,
+    subject: taskData.subject,
+    status: 'pending',
+    owner: null,
+    goal: taskData.description || 'TBD'
+  };
+}
+
+/**
+ * Update an existing task
+ * @param {string} taskId - Task ID
+ * @param {Object} updates - Updates to apply
+ * @param {Object} options - Options
+ * @returns {Promise<Object>} Updated task
+ */
+export async function updateTask(taskId, updates, options = {}) {
+  const { fs: fileSystem = defaultFs, basePath = process.cwd() } = options;
+
+  // Parse task ID
+  const idMatch = taskId.match(/^(?:phase-(\d+)-)?task-(\d+)$/);
+  const phase = idMatch?.[1] ? parseInt(idMatch[1], 10) : 1;
+  const taskNumber = idMatch?.[2] ? parseInt(idMatch[2], 10) : parseInt(taskId.replace('task-', ''), 10);
+
+  const planPath = path.join(basePath, '.planning', 'phases', `${phase}-PLAN.md`);
+
+  let content = '';
+  try {
+    content = await fileSystem.readFile(planPath, 'utf-8');
+  } catch {
+    throw new Error(`Task ${taskId} not found`);
+  }
+
+  const tasks = parseTasksFromPlan(content);
+  const task = tasks.find(t => t.number === taskNumber);
+
+  if (!task) {
+    throw new Error(`Task ${taskId} not found`);
+  }
+
+  // Apply updates
+  const updatedTask = { ...task };
+  if (updates.subject !== undefined) {
+    updatedTask.subject = updates.subject;
+  }
+  if (updates.status !== undefined) {
+    updatedTask.status = updates.status;
+  }
+  if (updates.owner !== undefined) {
+    updatedTask.owner = updates.owner;
+  }
+
+  // Build new marker
+  let marker = ' ';
+  if (updatedTask.status === 'completed') marker = 'x';
+  else if (updatedTask.status === 'in_progress') marker = '>';
+
+  const ownerPart = updatedTask.owner ? `@${updatedTask.owner}` : '';
+  const newMarker = `[${marker}${ownerPart}]`;
+
+  // Replace in content
+  const oldPattern = new RegExp(
+    `(###\\s+Task\\s+${taskNumber}:\\s*)${task.subject.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(\\s*\\[)[^\\]]*\\]`,
+    'g'
+  );
+  const newContent = content.replace(oldPattern, `$1${updatedTask.subject}$2${marker}${ownerPart}]`);
+
+  await fileSystem.writeFile(planPath, newContent);
+
+  return formatTaskForApi(updatedTask, phase);
+}
+
+/**
+ * Delete a task
+ * @param {string} taskId - Task ID
+ * @param {Object} options - Options
+ * @returns {Promise<void>}
+ */
+export async function deleteTask(taskId, options = {}) {
+  const { fs: fileSystem = defaultFs, basePath = process.cwd() } = options;
+
+  // Parse task ID
+  const idMatch = taskId.match(/^(?:phase-(\d+)-)?task-(\d+)$/);
+  const phase = idMatch?.[1] ? parseInt(idMatch[1], 10) : 1;
+  const taskNumber = idMatch?.[2] ? parseInt(idMatch[2], 10) : parseInt(taskId.replace('task-', ''), 10);
+
+  const planPath = path.join(basePath, '.planning', 'phases', `${phase}-PLAN.md`);
+
+  let content = '';
+  try {
+    content = await fileSystem.readFile(planPath, 'utf-8');
+  } catch {
+    throw new Error(`Task ${taskId} not found`);
+  }
+
+  // Remove the task section (from ### Task N to next ### or end)
+  const lines = content.split('\n');
+  const newLines = [];
+  let skipping = false;
+
+  for (const line of lines) {
+    const taskMatch = line.match(/^###\s+Task\s+(\d+):/);
+    if (taskMatch) {
+      const num = parseInt(taskMatch[1], 10);
+      if (num === taskNumber) {
+        skipping = true;
+        continue;
+      } else {
+        skipping = false;
+      }
+    }
+
+    if (!skipping) {
+      newLines.push(line);
+    }
+  }
+
+  await fileSystem.writeFile(planPath, newLines.join('\n'));
+}
+
+/**
+ * Create Tasks API handlers
+ * @param {Object} options - Options
+ * @returns {Object} API handlers
+ */
+export function createTasksApi(options = {}) {
+  const { basePath = process.cwd(), fs: fileSystem = defaultFs } = options;
+  const introspection = options.introspection || createTlcIntrospection({ basePath, fs: fileSystem });
+
+  return {
+    async get(query = {}) {
+      return getTasks({ introspection, fs: fileSystem, basePath });
+    },
+
+    async post(taskData) {
+      return createTask(taskData, { fs: fileSystem, basePath });
+    },
+
+    async patch(taskId, updates) {
+      return updateTask(taskId, updates, { fs: fileSystem, basePath });
+    },
+
+    async delete(taskId) {
+      return deleteTask(taskId, { fs: fileSystem, basePath });
+    }
+  };
+}

package/server/lib/dashboard/tasks-api.test.js

@@ -0,0 +1,161 @@
+/**
+ * Tasks API Module Tests
+ */
+import { describe, it, expect, vi } from 'vitest';
+import { getTasks, createTask, updateTask, deleteTask, parseTasksFromPlan, formatTaskForApi, createTasksApi } from './tasks-api.js';
+
+describe('tasks-api', () => {
+  describe('getTasks', () => {
+    it('returns tasks from current phase', async () => {
+      const mockIntrospection = {
+        getCurrentPhase: vi.fn().mockReturnValue({ number: 1 })
+      };
+      const mockFs = {
+        readFile: vi.fn().mockResolvedValue(`
+### Task 1: Test task [ ]
+**Goal:** Do something
+### Task 2: Done task [x]
+**Goal:** Did something
+`)
+      };
+      const tasks = await getTasks({ introspection: mockIntrospection, fs: mockFs });
+      expect(tasks.length).toBe(2);
+      expect(tasks[0].subject).toBe('Test task');
+      expect(tasks[0].status).toBe('pending');
+      expect(tasks[1].status).toBe('completed');
+    });
+
+    it('returns flat array format', async () => {
+      const mockIntrospection = {
+        getCurrentPhase: vi.fn().mockReturnValue({ number: 1 })
+      };
+      const mockFs = {
+        readFile: vi.fn().mockResolvedValue('### Task 1: Test [ ]')
+      };
+      const tasks = await getTasks({ introspection: mockIntrospection, fs: mockFs });
+      expect(Array.isArray(tasks)).toBe(true);
+      expect(tasks[0].id).toBeDefined();
+    });
+  });
+
+  describe('createTask', () => {
+    it('creates task with required fields', async () => {
+      const mockFs = {
+        readFile: vi.fn().mockResolvedValue('## Tasks\n'),
+        writeFile: vi.fn().mockResolvedValue(undefined)
+      };
+      const task = await createTask({
+        subject: 'New task',
+        description: 'Task description',
+        phase: 1
+      }, { fs: mockFs });
+      expect(task.id).toBeDefined();
+      expect(task.subject).toBe('New task');
+      expect(task.status).toBe('pending');
+    });
+
+    it('validates required fields', async () => {
+      await expect(createTask({ description: 'No subject' }, {}))
+        .rejects.toThrow(/subject.*required/i);
+    });
+
+    it('appends to PLAN.md', async () => {
+      const mockFs = {
+        readFile: vi.fn().mockResolvedValue('## Tasks\n'),
+        writeFile: vi.fn().mockResolvedValue(undefined)
+      };
+      await createTask({ subject: 'Test', phase: 1 }, { fs: mockFs });
+      expect(mockFs.writeFile).toHaveBeenCalled();
+      const content = mockFs.writeFile.mock.calls[0][1];
+      expect(content).toContain('Test');
+    });
+  });
+
+  describe('updateTask', () => {
+    it('updates task status', async () => {
+      const mockFs = {
+        readFile: vi.fn().mockResolvedValue('### Task 1: Test [ ]'),
+        writeFile: vi.fn().mockResolvedValue(undefined)
+      };
+      const task = await updateTask('task-1', { status: 'completed' }, { fs: mockFs });
+      expect(task.status).toBe('completed');
+    });
+
+    it('updates task subject', async () => {
+      const mockFs = {
+        readFile: vi.fn().mockResolvedValue('### Task 1: Test [ ]'),
+        writeFile: vi.fn().mockResolvedValue(undefined)
+      };
+      const task = await updateTask('task-1', { subject: 'Updated' }, { fs: mockFs });
+      expect(task.subject).toBe('Updated');
+    });
+
+    it('throws for non-existent task', async () => {
+      const mockFs = {
+        readFile: vi.fn().mockResolvedValue('### Task 1: Test [ ]')
+      };
+      await expect(updateTask('task-99', {}, { fs: mockFs }))
+        .rejects.toThrow(/not found/i);
+    });
+  });
+
+  describe('deleteTask', () => {
+    it('removes task from plan', async () => {
+      const mockFs = {
+        readFile: vi.fn().mockResolvedValue('### Task 1: Test [ ]\n### Task 2: Keep [ ]'),
+        writeFile: vi.fn().mockResolvedValue(undefined)
+      };
+      await deleteTask('task-1', { fs: mockFs });
+      const content = mockFs.writeFile.mock.calls[0][1];
+      expect(content).not.toContain('Task 1');
+      expect(content).toContain('Task 2');
+    });
+  });
+
+  describe('parseTasksFromPlan', () => {
+    it('parses task format', () => {
+      const content = `
+### Task 1: First task [ ]
+**Goal:** Do first thing
+### Task 2: Second task [x@alice]
+**Goal:** Do second thing
+`;
+      const tasks = parseTasksFromPlan(content);
+      expect(tasks.length).toBe(2);
+      expect(tasks[0].subject).toBe('First task');
+      expect(tasks[1].owner).toBe('alice');
+    });
+
+    it('handles in-progress marker', () => {
+      const content = '### Task 1: Working [>@bob]';
+      const tasks = parseTasksFromPlan(content);
+      expect(tasks[0].status).toBe('in_progress');
+      expect(tasks[0].owner).toBe('bob');
+    });
+  });
+
+  describe('formatTaskForApi', () => {
+    it('formats task with all fields', () => {
+      const task = {
+        number: 1,
+        subject: 'Test',
+        status: 'pending',
+        goal: 'Do something',
+        owner: null
+      };
+      const formatted = formatTaskForApi(task, 5);
+      expect(formatted.id).toBe('phase-5-task-1');
+      expect(formatted.phase).toBe(5);
+    });
+  });
+
+  describe('createTasksApi', () => {
+    it('creates API handlers', () => {
+      const api = createTasksApi({ basePath: '/test' });
+      expect(api.get).toBeDefined();
+      expect(api.post).toBeDefined();
+      expect(api.patch).toBeDefined();
+      expect(api.delete).toBeDefined();
+    });
+  });
+});

package/server/lib/dashboard/tlc-introspection.js

@@ -0,0 +1,197 @@
+/**
+ * TLC Introspection Module
+ * Reads TLC project state (ROADMAP.md, PROJECT.md, .tlc.json)
+ */
+import { promises as defaultFs } from 'fs';
+import path from 'path';
+
+/**
+ * Parse phases from ROADMAP.md content
+ * @param {string} content - ROADMAP.md content
+ * @returns {Array} Parsed phases
+ */
+export function parseRoadmap(content) {
+  const phases = [];
+  let currentMilestone = null;
+
+  const lines = content.split('\n');
+
+  for (const line of lines) {
+    // Check for milestone
+    const milestoneMatch = line.match(/^##\s+Milestone:\s*(.+)$/);
+    if (milestoneMatch) {
+      currentMilestone = milestoneMatch[1].trim();
+      continue;
+    }
+
+    // Check for phase
+    const phaseMatch = line.match(/^###\s+Phase\s+(\d+):\s*(.+?)\s*\[(x|>|\s*)\]/);
+    if (phaseMatch) {
+      const number = parseInt(phaseMatch[1], 10);
+      const name = phaseMatch[2].trim();
+      const marker = phaseMatch[3];
+
+      let status;
+      if (marker === 'x') {
+        status = 'complete';
+      } else if (marker === '>') {
+        status = 'current';
+      } else {
+        status = 'pending';
+      }
+
+      phases.push({
+        number,
+        name,
+        status,
+        milestone: currentMilestone
+      });
+    }
+  }
+
+  return phases;
+}
+
+/**
+ * Parse PROJECT.md content
+ * @param {string} content - PROJECT.md content
+ * @returns {Object} Parsed project info
+ */
+export function parseProjectMd(content) {
+  if (!content || !content.trim()) {
+    return { name: 'Untitled', description: '' };
+  }
+
+  const lines = content.split('\n');
+  let name = 'Untitled';
+  let description = '';
+
+  // Extract name from first H1
+  const nameMatch = content.match(/^#\s+(.+)$/m);
+  if (nameMatch) {
+    name = nameMatch[1].trim();
+  }
+
+  // Extract description (content between first H1 and next heading)
+  let foundName = false;
+  let descLines = [];
+
+  for (const line of lines) {
+    if (line.match(/^#\s+/)) {
+      if (foundName) break;
+      foundName = true;
+      continue;
+    }
+    if (foundName && line.match(/^##/)) {
+      break;
+    }
+    if (foundName && line.trim()) {
+      descLines.push(line);
+    }
+  }
+
+  description = descLines.join('\n').trim();
+
+  return { name, description };
+}
+
+/**
+ * Parse .tlc.json config
+ * @param {string} content - JSON string
+ * @returns {Object} Parsed config
+ */
+export function parseTlcConfig(content) {
+  try {
+    return JSON.parse(content);
+  } catch {
+    return { project: 'unknown' };
+  }
+}
+
+/**
+ * Get complete project state
+ * @param {Object} options - Options with fs and basePath
+ * @returns {Promise<Object>} Project state
+ */
+export async function getProjectState(options = {}) {
+  const fs = options.fs || defaultFs;
+  const basePath = options.basePath || process.cwd();
+
+  let projectContent = '';
+  let roadmapContent = '';
+  let configContent = '';
+
+  try {
+    projectContent = await fs.readFile(path.join(basePath, 'PROJECT.md'), 'utf-8');
+  } catch {
+    projectContent = '';
+  }
+
+  try {
+    roadmapContent = await fs.readFile(path.join(basePath, '.planning', 'ROADMAP.md'), 'utf-8');
+  } catch {
+    roadmapContent = '';
+  }
+
+  try {
+    configContent = await fs.readFile(path.join(basePath, '.tlc.json'), 'utf-8');
+  } catch {
+    configContent = '';
+  }
+
+  return {
+    project: parseProjectMd(projectContent),
+    phases: parseRoadmap(roadmapContent),
+    config: parseTlcConfig(configContent)
+  };
+}
+
+/**
+ * Get current phase from phases array
+ * @param {Array} phases - Array of phases
+ * @returns {Object|null} Current phase
+ */
+export function getCurrentPhase(phases) {
+  // First look for explicitly current phase
+  const current = phases.find(p => p.status === 'current');
+  if (current) return current;
+
+  // Otherwise return first pending phase
+  const pending = phases.find(p => p.status === 'pending');
+  return pending || null;
+}
+
+/**
+ * Create TLC introspection instance
+ * @param {Object} options - Options
+ * @returns {Object} Introspection API
+ */
+export function createTlcIntrospection(options = {}) {
+  const fs = options.fs || defaultFs;
+  const basePath = options.basePath || process.cwd();
+
+  let cachedState = null;
+
+  return {
+    async getState() {
+      if (!cachedState) {
+        cachedState = await getProjectState({ fs, basePath });
+      }
+      return cachedState;
+    },
+
+    async getPhases() {
+      const state = await this.getState();
+      return state.phases;
+    },
+
+    async getCurrentPhase() {
+      const phases = await this.getPhases();
+      return getCurrentPhase(phases);
+    },
+
+    invalidateCache() {
+      cachedState = null;
+    }
+  };
+}