tlc-claude-code 1.2.27 → 1.2.29

package/server/lib/memory-writer.test.js

@@ -0,0 +1,231 @@
+import { describe, it, beforeEach, afterEach, expect } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import {
+  writeTeamDecision,
+  writeTeamGotcha,
+  writePersonalPreference,
+  appendSessionLog,
+} from './memory-writer.js';
+import { initMemoryStructure, MEMORY_PATHS } from './memory-storage.js';
+
+describe('memory-writer', () => {
+  let testDir;
+
+  beforeEach(async () => {
+    testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tlc-memory-writer-test-'));
+    await initMemoryStructure(testDir);
+  });
+
+  afterEach(() => {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  });
+
+  describe('writeTeamDecision', () => {
+    it('creates decision file with auto-increment ID', async () => {
+      await writeTeamDecision(testDir, {
+        title: 'Use Postgres over MySQL',
+        reasoning: 'JSONB support for flexible schemas',
+        context: 'database selection',
+      });
+
+      const decisionsDir = path.join(testDir, MEMORY_PATHS.DECISIONS);
+      const files = fs.readdirSync(decisionsDir);
+
+      expect(files).toHaveLength(1);
+      expect(files[0]).toMatch(/^001-use-postgres-over-mysql\.md$/);
+    });
+
+    it('increments ID for multiple decisions', async () => {
+      await writeTeamDecision(testDir, { title: 'First Decision', reasoning: 'test' });
+      await writeTeamDecision(testDir, { title: 'Second Decision', reasoning: 'test' });
+      await writeTeamDecision(testDir, { title: 'Third Decision', reasoning: 'test' });
+
+      const decisionsDir = path.join(testDir, MEMORY_PATHS.DECISIONS);
+      const files = fs.readdirSync(decisionsDir).sort();
+
+      expect(files).toHaveLength(3);
+      expect(files[0]).toMatch(/^001-/);
+      expect(files[1]).toMatch(/^002-/);
+      expect(files[2]).toMatch(/^003-/);
+    });
+
+    it('includes decision content in markdown format', async () => {
+      await writeTeamDecision(testDir, {
+        title: 'Use Postgres',
+        reasoning: 'JSONB support',
+        context: 'database selection',
+        alternatives: ['MySQL', 'MongoDB'],
+      });
+
+      const decisionsDir = path.join(testDir, MEMORY_PATHS.DECISIONS);
+      const files = fs.readdirSync(decisionsDir);
+      const content = fs.readFileSync(path.join(decisionsDir, files[0]), 'utf8');
+
+      expect(content).toContain('# Decision: Use Postgres');
+      expect(content).toContain('JSONB support');
+      expect(content).toContain('database selection');
+      expect(content).toContain('MySQL');
+    });
+
+    it('includes date in decision file', async () => {
+      await writeTeamDecision(testDir, { title: 'Test', reasoning: 'test' });
+
+      const decisionsDir = path.join(testDir, MEMORY_PATHS.DECISIONS);
+      const files = fs.readdirSync(decisionsDir);
+      const content = fs.readFileSync(path.join(decisionsDir, files[0]), 'utf8');
+
+      const today = new Date().toISOString().split('T')[0];
+      expect(content).toContain(`**Date:** ${today}`);
+    });
+
+    it('slugifies title for filename', async () => {
+      await writeTeamDecision(testDir, {
+        title: 'Use REST API instead of GraphQL!',
+        reasoning: 'simpler',
+      });
+
+      const decisionsDir = path.join(testDir, MEMORY_PATHS.DECISIONS);
+      const files = fs.readdirSync(decisionsDir);
+
+      expect(files[0]).toBe('001-use-rest-api-instead-of-graphql.md');
+    });
+  });
+
+  describe('writeTeamGotcha', () => {
+    it('creates gotcha file in gotchas directory', async () => {
+      await writeTeamGotcha(testDir, {
+        title: 'Auth Service Warmup',
+        issue: 'Auth service needs 2 seconds to warm up',
+        workaround: 'Add delay in test setup',
+        severity: 'medium',
+      });
+
+      const gotchasDir = path.join(testDir, MEMORY_PATHS.GOTCHAS);
+      const files = fs.readdirSync(gotchasDir);
+
+      expect(files).toHaveLength(1);
+      expect(files[0]).toContain('auth-service-warmup');
+    });
+
+    it('includes gotcha content in markdown format', async () => {
+      await writeTeamGotcha(testDir, {
+        title: 'Auth Service Warmup',
+        issue: 'Needs 2 seconds to warm up',
+        workaround: 'Add delay',
+        severity: 'high',
+        affected: ['src/auth/*'],
+      });
+
+      const gotchasDir = path.join(testDir, MEMORY_PATHS.GOTCHAS);
+      const files = fs.readdirSync(gotchasDir);
+      const content = fs.readFileSync(path.join(gotchasDir, files[0]), 'utf8');
+
+      expect(content).toContain('# Gotcha: Auth Service Warmup');
+      expect(content).toContain('Needs 2 seconds');
+      expect(content).toContain('Add delay');
+      expect(content).toContain('**Severity:** high');
+    });
+  });
+
+  describe('writePersonalPreference', () => {
+    it('writes preference to preferences.json', async () => {
+      await writePersonalPreference(testDir, 'codeStyle', 'functional');
+
+      const prefsPath = path.join(testDir, MEMORY_PATHS.LOCAL, 'preferences.json');
+      const prefs = JSON.parse(fs.readFileSync(prefsPath, 'utf8'));
+
+      expect(prefs.codeStyle).toBe('functional');
+    });
+
+    it('merges with existing preferences', async () => {
+      await writePersonalPreference(testDir, 'codeStyle', 'functional');
+      await writePersonalPreference(testDir, 'exports', 'named');
+
+      const prefsPath = path.join(testDir, MEMORY_PATHS.LOCAL, 'preferences.json');
+      const prefs = JSON.parse(fs.readFileSync(prefsPath, 'utf8'));
+
+      expect(prefs.codeStyle).toBe('functional');
+      expect(prefs.exports).toBe('named');
+    });
+
+    it('overwrites existing preference value', async () => {
+      await writePersonalPreference(testDir, 'codeStyle', 'functional');
+      await writePersonalPreference(testDir, 'codeStyle', 'object-oriented');
+
+      const prefsPath = path.join(testDir, MEMORY_PATHS.LOCAL, 'preferences.json');
+      const prefs = JSON.parse(fs.readFileSync(prefsPath, 'utf8'));
+
+      expect(prefs.codeStyle).toBe('object-oriented');
+    });
+
+    it('supports nested preference objects', async () => {
+      await writePersonalPreference(testDir, 'testing', {
+        framework: 'vitest',
+        style: 'describe-it',
+      });
+
+      const prefsPath = path.join(testDir, MEMORY_PATHS.LOCAL, 'preferences.json');
+      const prefs = JSON.parse(fs.readFileSync(prefsPath, 'utf8'));
+
+      expect(prefs.testing.framework).toBe('vitest');
+      expect(prefs.testing.style).toBe('describe-it');
+    });
+  });
+
+  describe('appendSessionLog', () => {
+    it('appends entry to daily session log', async () => {
+      await appendSessionLog(testDir, {
+        type: 'decision',
+        content: 'use JWT for auth',
+        classification: 'team',
+      });
+
+      const today = new Date().toISOString().split('T')[0];
+      const logPath = path.join(testDir, MEMORY_PATHS.SESSIONS, `${today}.jsonl`);
+
+      expect(fs.existsSync(logPath)).toBe(true);
+
+      const lines = fs.readFileSync(logPath, 'utf8').trim().split('\n');
+      const entry = JSON.parse(lines[0]);
+
+      expect(entry.type).toBe('decision');
+      expect(entry.content).toBe('use JWT for auth');
+    });
+
+    it('adds timestamp to each entry', async () => {
+      await appendSessionLog(testDir, { type: 'test', content: 'hello' });
+
+      const today = new Date().toISOString().split('T')[0];
+      const logPath = path.join(testDir, MEMORY_PATHS.SESSIONS, `${today}.jsonl`);
+      const lines = fs.readFileSync(logPath, 'utf8').trim().split('\n');
+      const entry = JSON.parse(lines[0]);
+
+      expect(entry).toHaveProperty('ts');
+      expect(entry.ts).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+    });
+
+    it('appends multiple entries to same file', async () => {
+      await appendSessionLog(testDir, { type: 'first', content: 'one' });
+      await appendSessionLog(testDir, { type: 'second', content: 'two' });
+      await appendSessionLog(testDir, { type: 'third', content: 'three' });
+
+      const today = new Date().toISOString().split('T')[0];
+      const logPath = path.join(testDir, MEMORY_PATHS.SESSIONS, `${today}.jsonl`);
+      const lines = fs.readFileSync(logPath, 'utf8').trim().split('\n');
+
+      expect(lines).toHaveLength(3);
+    });
+
+    it('creates session directory if missing', async () => {
+      // Remove sessions directory
+      const sessionsDir = path.join(testDir, MEMORY_PATHS.SESSIONS);
+      fs.rmSync(sessionsDir, { recursive: true });
+
+      await appendSessionLog(testDir, { type: 'test', content: 'hello' });
+
+      expect(fs.existsSync(sessionsDir)).toBe(true);
+    });
+  });
+});

package/server/lib/overdrive-command.js

@@ -3,7 +3,11 @@
  * Automatic parallel execution when tasks are independent
  *
  * This is NOT a command - it's integrated into /tlc:build
- * When a plan has independent tasks, they run in parallel automatically
+ * When a plan has independent tasks, they run in parallel automatically.
+ *
+ * Default behavior: Auto-parallelize up to 10 agents based on task dependencies
+ * Use --sequential to force one-at-a-time execution
+ * Use --agents N to limit parallelism to specific number
  */
 
 const fs = require('fs');
@@ -17,7 +21,7 @@ const path = require('path');
 function parseOverdriveArgs(args = '') {
   const options = {
     phase: null,
-    agents: 3, // Default parallel agents
+    agents: 'auto', // Auto-detect based on independent tasks (up to 10)
     mode: 'build', // build, test, fix
     dryRun: false,
     sequential: false,
@@ -36,8 +40,9 @@ function parseOverdriveArgs(args = '') {
       options.mode = parts[++i];
     } else if (part === '--dry-run') {
       options.dryRun = true;
-    } else if (part === '--sequential') {
+    } else if (part === '--sequential' || part === '-s') {
       options.sequential = true;
+      options.agents = 1;
     } else if (['build', 'test', 'fix'].includes(part)) {
       options.mode = part;
     }
@@ -265,8 +270,27 @@ async function executeOverdriveCommand(args = '', context = {}) {
     };
   }
 
-  // Distribute tasks
-  const agentCount = Math.min(options.agents, availableTasks.length);
+  // Determine agent count: auto = max parallelism based on independent tasks
+  let agentCount;
+  if (options.sequential) {
+    agentCount = 1;
+  } else if (options.agents === 'auto') {
+    // Auto-detect: use as many agents as there are independent tasks (up to 10)
+    let planContent = '';
+    try {
+      planContent = fs.readFileSync(phaseInfo.planPath, 'utf-8');
+    } catch {
+      // Fall back to task count
+    }
+    const depAnalysis = analyzeDependencies(planContent);
+    const parallelAnalysis = canParallelize(availableTasks, depAnalysis);
+    agentCount = parallelAnalysis.canParallelize
+      ? Math.min(parallelAnalysis.independentTasks.length, 10)
+      : 1;
+  } else {
+    agentCount = Math.min(options.agents, availableTasks.length);
+  }
+
   const taskGroups = distributeTasks(availableTasks, agentCount);
 
   // Generate prompts
@@ -434,7 +458,7 @@ function canParallelize(tasks, depAnalysis) {
     canParallelize: true,
     independentTasks,
     dependentTasks: tasks.filter(t => dependentTasks.has(t.id)),
-    recommendedAgents: Math.min(independentTasks.length, 3),
+    recommendedAgents: Math.min(independentTasks.length, 10), // Max 10 parallel agents
   };
 }
 

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

@@ -17,7 +17,7 @@ describe('overdrive-command', () => {
       const options = parseOverdriveArgs('');
 
       expect(options.phase).toBeNull();
-      expect(options.agents).toBe(3);
+      expect(options.agents).toBe('auto'); // Auto-parallelize by default
       expect(options.mode).toBe('build');
       expect(options.dryRun).toBe(false);
       expect(options.sequential).toBe(false);
@@ -56,6 +56,13 @@ describe('overdrive-command', () => {
     it('parses --sequential flag', () => {
       const options = parseOverdriveArgs('--sequential');
       expect(options.sequential).toBe(true);
+      expect(options.agents).toBe(1); // Sequential forces single agent
+    });
+
+    it('parses -s shorthand for sequential', () => {
+      const options = parseOverdriveArgs('-s');
+      expect(options.sequential).toBe(true);
+      expect(options.agents).toBe(1);
     });
 
     it('parses multiple flags', () => {

package/server/lib/pattern-detector.js

@@ -0,0 +1,216 @@
+/**
+ * Pattern Detector - Detect memorable patterns from conversation exchanges
+ */
+
+const PATTERN_TYPES = {
+  DECISION: 'decision',
+  PREFERENCE: 'preference',
+  GOTCHA: 'gotcha',
+  REASONING: 'reasoning',
+};
+
+/**
+ * Decision pattern matchers
+ */
+const DECISION_PATTERNS = [
+  {
+    // "let's use X instead of Y"
+    regex: /let'?s\s+use\s+(.+?)\s+instead\s+of\s+(.+?)(?:\s+because\s+(.+?))?(?:\.|,|$)/i,
+    extract: (match) => ({
+      choice: match[1].trim(),
+      over: match[2].trim(),
+      reasoning: match[3]?.trim() || null,
+    }),
+  },
+  {
+    // "we decided to use X"
+    regex: /we\s+decided\s+to\s+(?:use\s+)?(.+?)(?:\s+because\s+(.+?))?(?:\.|,|$)/i,
+    extract: (match) => ({
+      choice: match[1].trim(),
+      reasoning: match[2]?.trim() || null,
+    }),
+  },
+  {
+    // "going with X instead of Y"
+    regex: /going\s+with\s+(.+?)\s+instead\s+of\s+(.+?)(?:\.|,|$)/i,
+    extract: (match) => ({
+      choice: match[1].trim(),
+      over: match[2].trim(),
+    }),
+  },
+  {
+    // "let's use X because Y"
+    regex: /let'?s\s+use\s+(.+?)\s+because\s+(.+?)(?:\.|,|$)/i,
+    extract: (match) => ({
+      choice: match[1].trim(),
+      reasoning: match[2].trim(),
+    }),
+  },
+];
+
+/**
+ * Preference pattern matchers
+ */
+const PREFERENCE_PATTERNS = [
+  {
+    // "I prefer X"
+    regex: /i\s+prefer\s+(.+?)(?:\s+over\s+(.+?))?(?:\.|,|$)/i,
+    extract: (match) => ({
+      preference: match[1].trim(),
+      antiPreference: match[2]?.trim() || null,
+    }),
+  },
+  {
+    // "no, use X not Y" or "use X not Y"
+    regex: /(?:no,?\s+)?use\s+(.+?)\s+not\s+(.+?)(?:\.|,|$)/i,
+    extract: (match) => ({
+      preference: match[1].trim(),
+      antiPreference: match[2].trim(),
+    }),
+  },
+  {
+    // "always use X"
+    regex: /always\s+use\s+(.+?)(?:\s+for\s+(.+?))?(?:\.|,|$)/i,
+    extract: (match) => ({
+      preference: match[1].trim(),
+      context: match[2]?.trim() || null,
+    }),
+  },
+  {
+    // "don't use X, use Y"
+    regex: /don'?t\s+use\s+(.+?),?\s+use\s+(.+?)(?:\.|,|$)/i,
+    extract: (match) => ({
+      antiPreference: match[1].trim(),
+      preference: match[2].trim(),
+    }),
+  },
+  {
+    // "don't use X"
+    regex: /don'?t\s+use\s+(.+?)(?:\.|,|$)/i,
+    extract: (match) => ({
+      antiPreference: match[1].trim(),
+    }),
+  },
+];
+
+/**
+ * Gotcha pattern matchers
+ */
+const GOTCHA_PATTERNS = [
+  {
+    // "X needs to warm up" or "X needs time to Y"
+    regex: /(?:ah\s+)?(?:the\s+)?(.+?)\s+needs\s+(?:time\s+to\s+)?(.+?)(?:\.|,|$)/i,
+    extract: (match) => ({
+      subject: match[1].trim(),
+      issue: `needs ${match[2].trim()}`,
+    }),
+  },
+  {
+    // "watch out for X"
+    regex: /watch\s+out\s+for\s+(.+?)(?:\s+in\s+(.+?))?(?:\.|,|$)/i,
+    extract: (match) => ({
+      subject: match[2]?.trim() || 'general',
+      issue: match[1].trim(),
+    }),
+  },
+  {
+    // "X doesn't work because Y"
+    regex: /(.+?)\s+doesn'?t\s+work\s+because\s+(?:of\s+)?(.+?)(?:\.|,|$)/i,
+    extract: (match) => ({
+      subject: match[1].trim(),
+      issue: match[2].trim(),
+    }),
+  },
+  {
+    // "remember that X"
+    regex: /remember\s+that\s+(.+?)(?:\.|,|$)/i,
+    extract: (match) => ({
+      subject: 'reminder',
+      issue: match[1].trim(),
+    }),
+  },
+];
+
+/**
+ * Reasoning pattern matchers
+ */
+const REASONING_PATTERNS = [
+  {
+    // "because X"
+    regex: /^because\s+(.+?)(?:\.|,|$)/i,
+    extract: (match) => ({
+      content: match[1].trim(),
+    }),
+  },
+  {
+    // "the reason is X"
+    regex: /the\s+reason\s+is\s+(.+?)(?:\.|,|$)/i,
+    extract: (match) => ({
+      content: match[1].trim(),
+    }),
+  },
+  {
+    // "since we need X"
+    regex: /since\s+we\s+need\s+(.+?)(?:\.|,|$)/i,
+    extract: (match) => ({
+      content: `need ${match[1].trim()}`,
+    }),
+  },
+];
+
+/**
+ * Apply pattern matchers to text
+ * @param {string} text - Text to search
+ * @param {Array} patterns - Array of pattern objects
+ * @param {string} type - Pattern type
+ * @returns {Array} Matched patterns
+ */
+function applyPatterns(text, patterns, type) {
+  if (!text) return [];
+
+  const results = [];
+
+  for (const pattern of patterns) {
+    const match = text.match(pattern.regex);
+    if (match) {
+      results.push({
+        type,
+        ...pattern.extract(match),
+        raw: match[0],
+      });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Detect memorable patterns from a conversation exchange
+ * @param {Object} exchange - The conversation exchange
+ * @param {string} exchange.user - User message
+ * @param {string} exchange.assistant - Assistant response
+ * @returns {Object} Detected patterns by type
+ */
+function detectPatterns(exchange) {
+  const userMessage = exchange?.user || '';
+  const assistantMessage = exchange?.assistant || '';
+
+  // Combine for context but primarily analyze user message
+  const text = userMessage;
+
+  return {
+    decisions: applyPatterns(text, DECISION_PATTERNS, PATTERN_TYPES.DECISION),
+    preferences: applyPatterns(text, PREFERENCE_PATTERNS, PATTERN_TYPES.PREFERENCE),
+    gotchas: applyPatterns(text, GOTCHA_PATTERNS, PATTERN_TYPES.GOTCHA),
+    reasoning: applyPatterns(text, REASONING_PATTERNS, PATTERN_TYPES.REASONING),
+  };
+}
+
+module.exports = {
+  detectPatterns,
+  PATTERN_TYPES,
+  DECISION_PATTERNS,
+  PREFERENCE_PATTERNS,
+  GOTCHA_PATTERNS,
+  REASONING_PATTERNS,
+};