tlc-claude-code 2.0.1 → 2.2.0

package/server/lib/project-scanner.test.js

@@ -386,4 +386,156 @@ describe('ProjectScanner', () => {
     // The last reported count should match total found
     expect(progressCounts[progressCounts.length - 1]).toBe(2);
   });
+
+  // =========================================================================
+  // Phase 79 — Task 1: Stop recursion at project boundaries
+  // =========================================================================
+
+  // Test 20: Does NOT recurse into subdirectories of a detected project
+  it('does not recurse into subdirectories of a detected project', () => {
+    // Create a TLC project with a nested sub-package that also looks like a project
+    const projectDir = createTlcProject(tempDir, 'monorepo-project');
+    const subPkgDir = path.join(projectDir, 'packages', 'sub-package');
+    fs.mkdirSync(subPkgDir, { recursive: true });
+    fs.writeFileSync(path.join(subPkgDir, 'package.json'), JSON.stringify({ name: 'sub-package' }));
+    fs.mkdirSync(path.join(subPkgDir, '.git'), { recursive: true });
+
+    const results = scanner.scan([tempDir]);
+
+    // Should only find the parent project, not the sub-package
+    expect(results).toHaveLength(1);
+    expect(results[0].name).toBe('monorepo-project');
+  });
+
+  // Test 21: TLC project's server/ subdirectory not listed separately
+  it('does not list subdirectories of a TLC project as separate projects', () => {
+    const projectDir = createTlcProject(tempDir, 'tlc-project');
+    // Create a server/ subdirectory with its own package.json + .git
+    const serverDir = path.join(projectDir, 'server');
+    fs.mkdirSync(serverDir, { recursive: true });
+    fs.writeFileSync(path.join(serverDir, 'package.json'), JSON.stringify({ name: 'tlc-server' }));
+    fs.mkdirSync(path.join(serverDir, '.git'), { recursive: true });
+
+    const results = scanner.scan([tempDir]);
+
+    expect(results).toHaveLength(1);
+    expect(results[0].name).toBe('tlc-project');
+  });
+
+  // Test 22: Top-level non-project directories are still traversed
+  it('still traverses non-project directories to find nested projects', () => {
+    // Create a plain directory (not a project) with a project nested inside
+    const groupDir = path.join(tempDir, 'my-workspace');
+    fs.mkdirSync(groupDir, { recursive: true });
+    // No .tlc.json, no .planning, no package.json+.git — just a folder
+    createTlcProject(groupDir, 'nested-real-project');
+
+    const results = scanner.scan([tempDir]);
+
+    expect(results).toHaveLength(1);
+    expect(results[0].name).toBe('nested-real-project');
+  });
+
+  // Test 23: Multiple projects at same level, none recurse into children
+  it('finds sibling projects but does not recurse into either', () => {
+    const projA = createTlcProject(tempDir, 'project-a');
+    const projB = createTlcProject(tempDir, 'project-b');
+
+    // Add nested sub-projects inside each
+    const nestedA = path.join(projA, 'nested');
+    fs.mkdirSync(nestedA, { recursive: true });
+    fs.writeFileSync(path.join(nestedA, '.tlc.json'), '{}');
+
+    const nestedB = path.join(projB, 'apps', 'frontend');
+    fs.mkdirSync(nestedB, { recursive: true });
+    fs.writeFileSync(path.join(nestedB, 'package.json'), JSON.stringify({ name: 'frontend' }));
+    fs.mkdirSync(path.join(nestedB, '.git'), { recursive: true });
+
+    const results = scanner.scan([tempDir]);
+
+    expect(results).toHaveLength(2);
+    const names = results.map(r => r.name);
+    expect(names).toContain('project-a');
+    expect(names).toContain('project-b');
+  });
+
+  // =========================================================================
+  // Phase 79 — Task 2: Monorepo sub-package metadata
+  // =========================================================================
+
+  // Test 24: Detects npm workspaces array format
+  it('detects npm workspaces and returns isMonorepo: true', () => {
+    createTlcProject(tempDir, 'npm-monorepo', {
+      packageJson: {
+        name: 'npm-monorepo',
+        version: '1.0.0',
+        workspaces: ['packages/*'],
+      },
+    });
+
+    // Create a matching sub-package directory
+    const pkgDir = path.join(tempDir, 'npm-monorepo', 'packages', 'core');
+    fs.mkdirSync(pkgDir, { recursive: true });
+    fs.writeFileSync(path.join(pkgDir, 'package.json'), JSON.stringify({ name: '@mono/core' }));
+
+    const results = scanner.scan([tempDir]);
+
+    expect(results).toHaveLength(1);
+    expect(results[0].isMonorepo).toBe(true);
+    expect(results[0].workspaces).toBeInstanceOf(Array);
+    expect(results[0].workspaces.length).toBeGreaterThanOrEqual(1);
+  });
+
+  // Test 25: Detects yarn workspaces object format
+  it('detects yarn workspaces object format', () => {
+    createTlcProject(tempDir, 'yarn-monorepo', {
+      packageJson: {
+        name: 'yarn-monorepo',
+        version: '1.0.0',
+        workspaces: { packages: ['packages/*'] },
+      },
+    });
+
+    const pkgDir = path.join(tempDir, 'yarn-monorepo', 'packages', 'utils');
+    fs.mkdirSync(pkgDir, { recursive: true });
+    fs.writeFileSync(path.join(pkgDir, 'package.json'), JSON.stringify({ name: '@mono/utils' }));
+
+    const results = scanner.scan([tempDir]);
+
+    expect(results).toHaveLength(1);
+    expect(results[0].isMonorepo).toBe(true);
+    expect(results[0].workspaces).toBeInstanceOf(Array);
+    expect(results[0].workspaces.length).toBeGreaterThanOrEqual(1);
+  });
+
+  // Test 26: Non-monorepo returns isMonorepo: false and empty workspaces
+  it('returns isMonorepo false and empty workspaces for regular project', () => {
+    createTlcProject(tempDir, 'regular-project', {
+      packageJson: { name: 'regular-project', version: '1.0.0' },
+    });
+
+    const results = scanner.scan([tempDir]);
+
+    expect(results).toHaveLength(1);
+    expect(results[0].isMonorepo).toBe(false);
+    expect(results[0].workspaces).toEqual([]);
+  });
+
+  // Test 27: Monorepo with no matching workspace directories
+  it('returns empty workspaces when glob pattern matches nothing', () => {
+    createTlcProject(tempDir, 'empty-mono', {
+      packageJson: {
+        name: 'empty-mono',
+        version: '1.0.0',
+        workspaces: ['packages/*'],
+      },
+    });
+    // Don't create the packages/ directory at all
+
+    const results = scanner.scan([tempDir]);
+
+    expect(results).toHaveLength(1);
+    expect(results[0].isMonorepo).toBe(true);
+    expect(results[0].workspaces).toEqual([]);
+  });
 });

package/server/lib/remember-command.js

@@ -55,6 +55,7 @@ export function createRememberCommand({ richCapture, vectorIndexer, embeddingCli
       chunk.title = `[PERMANENT] ${text}`;
       chunk.topic = text;
       chunk.content = text;
+      chunk.text = text;
     } else if (exchanges && exchanges.length > 0) {
       // Exchange capture mode
       const summary = exchanges
@@ -64,6 +65,7 @@ export function createRememberCommand({ richCapture, vectorIndexer, embeddingCli
       chunk.title = `[PERMANENT] ${summary}`;
       chunk.topic = summary;
       chunk.exchanges = exchanges;
+      chunk.text = summary;
     } else {
       return {
         success: false,

package/server/lib/remember-command.test.js

@@ -262,4 +262,27 @@ describe('remember-command', () => {
     // Should provide guidance about what to provide
     expect(result.message.length).toBeGreaterThan(0);
   });
+
+  // -------------------------------------------------------------------------
+  // 10. Phase 81: chunk.text must be set for vector indexing
+  // -------------------------------------------------------------------------
+  it('explicit text remember sets chunk.text on indexChunk call', async () => {
+    await remember.execute(testDir, { text: 'Always use UTC timestamps' });
+
+    expect(mockVectorIndexer.indexChunk).toHaveBeenCalledTimes(1);
+    const indexedChunk = mockVectorIndexer.indexChunk.mock.calls[0][1];
+    // chunk.text MUST be set — vectorIndexer.indexChunk only reads chunk.text
+    expect(indexedChunk.text).toBe('Always use UTC timestamps');
+  });
+
+  it('exchange capture sets chunk.text to exchange summary', async () => {
+    await remember.execute(testDir, { exchanges: sampleExchanges });
+
+    expect(mockVectorIndexer.indexChunk).toHaveBeenCalledTimes(1);
+    const indexedChunk = mockVectorIndexer.indexChunk.mock.calls[0][1];
+    // chunk.text MUST be non-empty for vector indexing to work
+    expect(indexedChunk.text).toBeDefined();
+    expect(typeof indexedChunk.text).toBe('string');
+    expect(indexedChunk.text.length).toBeGreaterThan(0);
+  });
 });

package/server/lib/review/plan-reviewer.js

@@ -0,0 +1,260 @@
+/**
+ * Plan Reviewer
+ * Validates .planning/phases/{N}-PLAN.md files for structure, scope, and completeness.
+ */
+
+/**
+ * Parse a TLC plan markdown file into a structured object.
+ *
+ * @param {string} content - Raw markdown content of the plan file.
+ * @returns {{ tasks: Array, prerequisites: string[], dependencies: string, rawContent: string }}
+ */
+export function parsePlan(content) {
+  const rawContent = content;
+  const tasks = [];
+  const prerequisites = [];
+  let dependencies = '';
+
+  // --- Prerequisites section (also accept "Context" with "Depends on" lines) ---
+  const prereqMatch = content.match(/^##\s+(?:Prerequisites|Context)\s*\n([\s\S]*?)(?=^##\s|\Z)/m);
+  if (prereqMatch) {
+    const block = prereqMatch[1];
+    const lines = block.split('\n');
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith('-') || trimmed.startsWith('*')) {
+        const item = trimmed.replace(/^[-*]\s*/, '').trim();
+        if (item) prerequisites.push(item);
+      }
+    }
+  }
+
+  // --- Dependencies section ---
+  const depsMatch = content.match(/^##\s+Dependencies\s*\n([\s\S]*?)(?=^##\s|$)/m);
+  if (depsMatch) {
+    dependencies = depsMatch[1].trim();
+  }
+
+  // --- Tasks section ---
+  // Split on ### Task N: headings
+  const taskHeadingRegex = /^###\s+Task\s+\d+:\s+(.+?)(?:\s+\[.*?\])?\s*$/m;
+  // Use a global split to get all task blocks
+  const taskBlocks = [];
+  const taskHeadingGlobal = /^###\s+Task\s+[\d.]+:\s+(.*?)(?:\s+\[.*?\])?\s*$/gm;
+  let match;
+  const headingPositions = [];
+
+  while ((match = taskHeadingGlobal.exec(content)) !== null) {
+    headingPositions.push({ index: match.index, title: match[1].trim(), end: match.index + match[0].length });
+  }
+
+  for (let i = 0; i < headingPositions.length; i++) {
+    const start = headingPositions[i].end;
+    const end = i + 1 < headingPositions.length ? headingPositions[i + 1].index : content.length;
+    taskBlocks.push({ title: headingPositions[i].title, body: content.slice(start, end) });
+  }
+
+  for (const { title, body } of taskBlocks) {
+    // Goal
+    const goalMatch = body.match(/^\*\*Goal:\*\*\s*(.+)$/m);
+    const goal = goalMatch ? goalMatch[1].trim() : '';
+
+    // Helper: extract a named section from the task body.
+    // Stops at the next **SectionName:** heading or end of body.
+    const extractSection = (sectionName) => {
+      const pattern = new RegExp(`\\*\\*${sectionName}:\\*\\*\\s*\\n([\\s\\S]*?)(?=\\*\\*[A-Za-z]|$)`);
+      const m = body.match(pattern);
+      return m ? m[1] : null;
+    };
+
+    // Files
+    const files = [];
+    const filesBlock = extractSection('Files');
+    if (filesBlock) {
+      for (const line of filesBlock.split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('-') || trimmed.startsWith('*')) {
+          const file = trimmed.replace(/^[-*]\s*/, '').trim();
+          if (file) files.push(file);
+        }
+      }
+    }
+
+    // Acceptance Criteria
+    const criteria = [];
+    const criteriaBlock = extractSection('Acceptance Criteria');
+    if (criteriaBlock) {
+      for (const line of criteriaBlock.split('\n')) {
+        const trimmed = line.trim();
+        // Match "- [ ] text" or "- [x] text" checkboxes
+        const cbMatch = trimmed.match(/^[-*]\s+\[[ xX]\]\s+(.+)$/);
+        if (cbMatch) {
+          criteria.push(cbMatch[1].trim());
+        }
+      }
+    }
+
+    // Test Cases
+    const testCases = [];
+    const testCasesBlock = extractSection('Test Cases');
+    if (testCasesBlock) {
+      for (const line of testCasesBlock.split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('-') || trimmed.startsWith('*')) {
+          const tc = trimmed.replace(/^[-*]\s*/, '').trim();
+          if (tc) testCases.push(tc);
+        }
+      }
+    }
+
+    tasks.push({ title, goal, files, criteria, testCases });
+  }
+
+  return { tasks, prerequisites, dependencies, rawContent };
+}
+
+/**
+ * Validate the structural completeness of a parsed plan.
+ * Flags tasks missing acceptance criteria or test cases.
+ *
+ * @param {{ tasks: Array }} plan
+ * @returns {Array<{ task: string, message: string }>}
+ */
+export function validateStructure(plan) {
+  const issues = [];
+  for (const task of plan.tasks) {
+    if (!task.criteria || task.criteria.length === 0) {
+      issues.push({ task: task.title, message: `Task "${task.title}" is missing acceptance criteria` });
+    }
+    if (!task.testCases || task.testCases.length === 0) {
+      issues.push({ task: task.title, message: `Task "${task.title}" is missing test cases` });
+    }
+  }
+  return issues;
+}
+
+// Words that indicate a vague/broad task title
+const VAGUE_WORDS = ['system', 'entire', 'all', 'everything', 'complete', 'whole', 'full'];
+
+/**
+ * Validate the scope of tasks in a parsed plan.
+ * Flags vague task titles and tasks with no files listed.
+ *
+ * @param {{ tasks: Array }} plan
+ * @returns {Array<{ task: string, message: string }>}
+ */
+export function validateScope(plan) {
+  const issues = [];
+  for (const task of plan.tasks) {
+    // Check for vague/overly-broad titles
+    const titleLower = task.title.toLowerCase();
+    const vagueFound = VAGUE_WORDS.some(w => titleLower.includes(w));
+    if (vagueFound) {
+      issues.push({
+        task: task.title,
+        message: `Task "${task.title}" title is too vague or broad — consider narrowing the scope`,
+      });
+    }
+
+    // Check for missing files
+    if (!task.files || task.files.length === 0) {
+      issues.push({
+        task: task.title,
+        message: `Task "${task.title}" has no files listed`,
+      });
+    }
+  }
+  return issues;
+}
+
+/**
+ * Validate the architecture of a parsed plan.
+ * Flags files with line-count estimates exceeding 1000 lines.
+ *
+ * @param {{ tasks: Array }} plan
+ * @returns {Array<{ task: string, message: string }>}
+ */
+export function validateArchitecture(plan) {
+  const issues = [];
+  // Match patterns like "(estimated: 1500 lines)" or "(estimated ~1500 lines)"
+  const overSizedPattern = /estimated[^)]*?(\d{4,})\s*lines/i;
+
+  for (const task of plan.tasks) {
+    for (const file of task.files) {
+      const match = file.match(overSizedPattern);
+      if (match) {
+        const lineCount = parseInt(match[1], 10);
+        if (lineCount > 1000) {
+          issues.push({
+            task: task.title,
+            message: `Task "${task.title}" plans a file larger than 1000 lines (${lineCount} lines estimated): ${file}`,
+          });
+        }
+      }
+    }
+    // Also check task goal for large estimates
+    if (task.goal) {
+      const goalMatch = task.goal.match(overSizedPattern);
+      if (goalMatch) {
+        const lineCount = parseInt(goalMatch[1], 10);
+        if (lineCount > 1000) {
+          issues.push({
+            task: task.title,
+            message: `Task "${task.title}" goal describes a file larger than 1000 lines (${lineCount} lines estimated)`,
+          });
+        }
+      }
+    }
+  }
+  return issues;
+}
+
+/**
+ * Validate the completeness of a parsed plan.
+ * Flags plans with no prerequisites section.
+ *
+ * @param {{ prerequisites: string[] }} plan
+ * @returns {Array<{ task: string, message: string }>}
+ */
+export function validateCompleteness(plan) {
+  const issues = [];
+  if (!plan.prerequisites || plan.prerequisites.length === 0) {
+    issues.push({
+      task: null,
+      message: 'Plan is missing a prerequisites section — add a ## Prerequisites block listing prior phases',
+    });
+  }
+  return issues;
+}
+
+/**
+ * Generate a review prompt string for LLM-based plan review.
+ *
+ * @param {{ tasks: Array, rawContent: string }} plan
+ * @param {{ projectName?: string, techStack?: string }} context
+ * @param {{ maxLines?: number }} [options]
+ * @returns {string}
+ */
+export function generateReviewPrompt(plan, context = {}, options = {}) {
+  const projectName = context.projectName || 'Unknown Project';
+  const techStack = context.techStack ? `\nTech stack: ${context.techStack}` : '';
+
+  const taskList = plan.tasks.map((t, i) => `  ${i + 1}. ${t.title}`).join('\n');
+
+  let planContent = plan.rawContent || '';
+  if (options.maxLines && typeof options.maxLines === 'number') {
+    const lines = planContent.split('\n');
+    if (lines.length > options.maxLines) {
+      planContent = lines.slice(0, options.maxLines).join('\n') + '\n[... truncated ...]';
+    }
+  }
+
+  return `You are reviewing a TLC phase plan for the project: ${projectName}.${techStack}
+
+Tasks in this plan:
+${taskList}
+
+Please review the following plan for structure, scope, architecture, and completeness:
+
+${planContent}`;
+}