tlc-claude-code 1.2.27 → 1.2.29

package/server/lib/file-collector.test.js

@@ -0,0 +1,307 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import {
+  collectFiles,
+  collectFromDirectory,
+  loadIgnorePatterns,
+  parseIgnoreFile,
+  shouldIgnore,
+  matchesPattern,
+  isBinaryFile,
+  matchesExtension,
+  readFileContent,
+  DEFAULT_IGNORES,
+} from './file-collector.js';
+
+describe('File Collector', () => {
+  let testDir;
+
+  beforeEach(() => {
+    testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tlc-collect-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  });
+
+  describe('parseIgnoreFile', () => {
+    it('parses patterns from content', () => {
+      const content = `
+node_modules
+dist
+*.log
+# This is a comment
+build/
+      `;
+      const patterns = parseIgnoreFile(content);
+      expect(patterns).toEqual(['node_modules', 'dist', '*.log', 'build/']);
+    });
+
+    it('ignores comments and empty lines', () => {
+      const content = `
+# Comment
+pattern1
+
+# Another comment
+pattern2
+      `;
+      const patterns = parseIgnoreFile(content);
+      expect(patterns).toEqual(['pattern1', 'pattern2']);
+    });
+  });
+
+  describe('matchesPattern', () => {
+    it('matches exact paths', () => {
+      expect(matchesPattern('node_modules', 'node_modules')).toBe(true);
+      expect(matchesPattern('src/index.js', 'src/index.js')).toBe(true);
+    });
+
+    it('matches directory patterns', () => {
+      expect(matchesPattern('node_modules/package', 'node_modules/')).toBe(true);
+      expect(matchesPattern('node_modules', 'node_modules/')).toBe(true); // Directory itself matches
+      expect(matchesPattern('src/node_modules/pkg', 'node_modules/')).toBe(true);
+    });
+
+    it('matches glob patterns', () => {
+      expect(matchesPattern('test.log', '*.log')).toBe(true);
+      expect(matchesPattern('debug.log', '*.log')).toBe(true);
+      expect(matchesPattern('test.txt', '*.log')).toBe(false);
+    });
+
+    it('matches nested paths', () => {
+      expect(matchesPattern('src/node_modules/pkg', 'node_modules')).toBe(true);
+      expect(matchesPattern('deep/nested/node_modules/pkg', 'node_modules')).toBe(true);
+    });
+
+    it('matches basename', () => {
+      expect(matchesPattern('path/to/package.json', 'package.json')).toBe(true);
+    });
+  });
+
+  describe('shouldIgnore', () => {
+    it('returns true for matching patterns', () => {
+      const patterns = ['node_modules', '*.log', 'dist/'];
+      expect(shouldIgnore('node_modules/package', patterns)).toBe(true);
+      expect(shouldIgnore('app.log', patterns)).toBe(true);
+      expect(shouldIgnore('dist/bundle.js', patterns)).toBe(true);
+    });
+
+    it('returns false for non-matching paths', () => {
+      const patterns = ['node_modules', '*.log'];
+      expect(shouldIgnore('src/index.js', patterns)).toBe(false);
+      expect(shouldIgnore('README.md', patterns)).toBe(false);
+    });
+  });
+
+  describe('isBinaryFile', () => {
+    it('identifies binary files by extension', () => {
+      expect(isBinaryFile('image.png')).toBe(true);
+      expect(isBinaryFile('photo.jpg')).toBe(true);
+      expect(isBinaryFile('archive.zip')).toBe(true);
+      expect(isBinaryFile('file.pdf')).toBe(true);
+      expect(isBinaryFile('module.pyc')).toBe(true);
+    });
+
+    it('identifies text files', () => {
+      expect(isBinaryFile('script.js')).toBe(false);
+      expect(isBinaryFile('style.css')).toBe(false);
+      expect(isBinaryFile('doc.md')).toBe(false);
+      expect(isBinaryFile('config.json')).toBe(false);
+    });
+
+    it('is case insensitive', () => {
+      expect(isBinaryFile('image.PNG')).toBe(true);
+      expect(isBinaryFile('image.Png')).toBe(true);
+    });
+  });
+
+  describe('matchesExtension', () => {
+    it('matches extensions with dot', () => {
+      expect(matchesExtension('file.js', ['.js'])).toBe(true);
+      expect(matchesExtension('file.ts', ['.js', '.ts'])).toBe(true);
+    });
+
+    it('matches extensions without dot', () => {
+      expect(matchesExtension('file.js', ['js'])).toBe(true);
+      expect(matchesExtension('file.ts', ['js', 'ts'])).toBe(true);
+    });
+
+    it('returns true for empty extensions array', () => {
+      expect(matchesExtension('file.js', [])).toBe(true);
+      expect(matchesExtension('file.ts', null)).toBe(true);
+    });
+
+    it('returns false for non-matching', () => {
+      expect(matchesExtension('file.js', ['.ts'])).toBe(false);
+    });
+  });
+
+  describe('collectFromDirectory', () => {
+    it('collects all files from directory', () => {
+      fs.writeFileSync(path.join(testDir, 'file1.js'), 'code');
+      fs.writeFileSync(path.join(testDir, 'file2.js'), 'code');
+
+      const files = collectFromDirectory(testDir);
+      expect(files).toHaveLength(2);
+    });
+
+    it('collects files recursively', () => {
+      fs.mkdirSync(path.join(testDir, 'sub'));
+      fs.writeFileSync(path.join(testDir, 'file1.js'), 'code');
+      fs.writeFileSync(path.join(testDir, 'sub', 'file2.js'), 'code');
+
+      const files = collectFromDirectory(testDir);
+      expect(files).toHaveLength(2);
+    });
+
+    it('skips node_modules by default', () => {
+      fs.mkdirSync(path.join(testDir, 'node_modules', 'pkg'), { recursive: true });
+      fs.writeFileSync(path.join(testDir, 'file1.js'), 'code');
+      fs.writeFileSync(path.join(testDir, 'node_modules', 'pkg', 'index.js'), 'code');
+
+      const files = collectFromDirectory(testDir);
+      expect(files).toHaveLength(1);
+    });
+
+    it('respects extension filter', () => {
+      fs.writeFileSync(path.join(testDir, 'file.js'), 'code');
+      fs.writeFileSync(path.join(testDir, 'file.ts'), 'code');
+      fs.writeFileSync(path.join(testDir, 'file.css'), 'code');
+
+      const files = collectFromDirectory(testDir, { extensions: ['.js', '.ts'] });
+      expect(files).toHaveLength(2);
+    });
+
+    it('skips binary files', () => {
+      fs.writeFileSync(path.join(testDir, 'file.js'), 'code');
+      fs.writeFileSync(path.join(testDir, 'image.png'), 'binary');
+
+      const files = collectFromDirectory(testDir);
+      expect(files).toHaveLength(1);
+    });
+
+    it('skips hidden files by default', () => {
+      fs.writeFileSync(path.join(testDir, 'file.js'), 'code');
+      fs.writeFileSync(path.join(testDir, '.hidden.js'), 'code');
+
+      const files = collectFromDirectory(testDir);
+      expect(files).toHaveLength(1);
+    });
+
+    it('includes hidden files when option set', () => {
+      fs.writeFileSync(path.join(testDir, 'file.js'), 'code');
+      fs.writeFileSync(path.join(testDir, '.hidden.js'), 'code');
+
+      const files = collectFromDirectory(testDir, { includeHidden: true });
+      expect(files).toHaveLength(2);
+    });
+
+    it('respects maxDepth option', () => {
+      fs.mkdirSync(path.join(testDir, 'a', 'b', 'c'), { recursive: true });
+      fs.writeFileSync(path.join(testDir, 'root.js'), 'code');
+      fs.writeFileSync(path.join(testDir, 'a', 'level1.js'), 'code');
+      fs.writeFileSync(path.join(testDir, 'a', 'b', 'level2.js'), 'code');
+      fs.writeFileSync(path.join(testDir, 'a', 'b', 'c', 'level3.js'), 'code');
+
+      const files = collectFromDirectory(testDir, { maxDepth: 2 });
+      expect(files).toHaveLength(3); // root, level1, level2
+    });
+  });
+
+  describe('loadIgnorePatterns', () => {
+    it('loads patterns from .tlcignore', () => {
+      fs.writeFileSync(path.join(testDir, '.tlcignore'), 'custom_ignore\n*.tmp');
+
+      const patterns = loadIgnorePatterns(testDir);
+      expect(patterns).toContain('custom_ignore');
+      expect(patterns).toContain('*.tmp');
+    });
+
+    it('falls back to .gitignore if no .tlcignore', () => {
+      fs.writeFileSync(path.join(testDir, '.gitignore'), 'build\ncoverage');
+
+      const patterns = loadIgnorePatterns(testDir);
+      expect(patterns).toContain('build');
+      expect(patterns).toContain('coverage');
+    });
+
+    it('prefers .tlcignore over .gitignore', () => {
+      fs.writeFileSync(path.join(testDir, '.tlcignore'), 'tlc_pattern');
+      fs.writeFileSync(path.join(testDir, '.gitignore'), 'git_pattern');
+
+      const patterns = loadIgnorePatterns(testDir);
+      expect(patterns).toContain('tlc_pattern');
+      expect(patterns).not.toContain('git_pattern');
+    });
+
+    it('returns empty array if no ignore files', () => {
+      const patterns = loadIgnorePatterns(testDir);
+      expect(patterns).toEqual([]);
+    });
+  });
+
+  describe('collectFiles', () => {
+    it('collects single file', () => {
+      const filePath = path.join(testDir, 'test.js');
+      fs.writeFileSync(filePath, 'code');
+
+      const result = collectFiles(filePath);
+      expect(result.files).toHaveLength(1);
+      expect(result.stats.total).toBe(1);
+    });
+
+    it('returns error for non-existent path', () => {
+      const result = collectFiles('/nonexistent/path');
+      expect(result.files).toHaveLength(0);
+      expect(result.stats.error).toContain('not found');
+    });
+
+    it('skips binary files', () => {
+      const filePath = path.join(testDir, 'image.png');
+      fs.writeFileSync(filePath, 'binary');
+
+      const result = collectFiles(filePath);
+      expect(result.files).toHaveLength(0);
+      expect(result.stats.skipped).toBe(1);
+    });
+
+    it('collects directory with patterns', () => {
+      fs.writeFileSync(path.join(testDir, '.tlcignore'), 'ignored/');
+      fs.mkdirSync(path.join(testDir, 'src'));
+      fs.mkdirSync(path.join(testDir, 'ignored'));
+      fs.writeFileSync(path.join(testDir, 'src', 'index.js'), 'code');
+      fs.writeFileSync(path.join(testDir, 'ignored', 'skip.js'), 'code');
+
+      const result = collectFiles(testDir);
+      expect(result.files).toHaveLength(1);
+    });
+  });
+
+  describe('readFileContent', () => {
+    it('reads file content', () => {
+      const filePath = path.join(testDir, 'test.js');
+      fs.writeFileSync(filePath, 'const x = 1;');
+
+      const { content, error } = readFileContent(filePath);
+      expect(content).toBe('const x = 1;');
+      expect(error).toBeNull();
+    });
+
+    it('returns error for non-existent file', () => {
+      const { content, error } = readFileContent('/nonexistent');
+      expect(content).toBeNull();
+      expect(error).toBeTruthy();
+    });
+  });
+
+  describe('DEFAULT_IGNORES', () => {
+    it('includes common patterns', () => {
+      expect(DEFAULT_IGNORES).toContain('node_modules');
+      expect(DEFAULT_IGNORES).toContain('.git');
+      expect(DEFAULT_IGNORES).toContain('dist');
+      expect(DEFAULT_IGNORES).toContain('coverage');
+    });
+  });
+});

package/server/lib/memory-classifier.js

@@ -0,0 +1,175 @@
+/**
+ * Memory Classifier - Classify memory items as team or personal
+ */
+
+const CLASSIFICATION = {
+  TEAM: 'team',
+  PERSONAL: 'personal',
+};
+
+/**
+ * Keywords that indicate team-level memory
+ */
+const TEAM_KEYWORDS = [
+  'database',
+  'api',
+  'infrastructure',
+  'deployment',
+  'architecture',
+  'server',
+  'backend',
+  'frontend',
+  'service',
+  'microservice',
+  'queue',
+  'cache',
+  'redis',
+  'postgres',
+  'mysql',
+  'mongodb',
+  'docker',
+  'kubernetes',
+  'aws',
+  'gcp',
+  'azure',
+  'ci/cd',
+  'pipeline',
+  'authentication',
+  'authorization',
+  'security',
+  'scaling',
+  'performance',
+  'migration',
+];
+
+/**
+ * Keywords that indicate personal preference memory
+ */
+const PERSONAL_KEYWORDS = [
+  'prefer',
+  'style',
+  'formatting',
+  'indentation',
+  'tabs',
+  'spaces',
+  'semicolons',
+  'quotes',
+  'naming',
+  'convention',
+  'readable',
+  'cleaner',
+  'shorter',
+  'longer',
+  'comment',
+  'documentation',
+  'verbose',
+  'concise',
+];
+
+/**
+ * Check if text contains any of the keywords
+ * @param {string} text - Text to search
+ * @param {string[]} keywords - Keywords to look for
+ * @returns {boolean}
+ */
+function containsKeyword(text, keywords) {
+  if (!text) return false;
+  const lower = text.toLowerCase();
+  return keywords.some(kw => lower.includes(kw.toLowerCase()));
+}
+
+/**
+ * Get all text content from a memory item
+ * @param {Object} item - Memory item
+ * @returns {string}
+ */
+function getItemText(item) {
+  if (!item) return '';
+
+  const parts = [
+    item.raw,
+    item.choice,
+    item.preference,
+    item.antiPreference,
+    item.content,
+    item.subject,
+    item.issue,
+    item.reasoning,
+    item.context,
+  ].filter(Boolean);
+
+  return parts.join(' ');
+}
+
+/**
+ * Classify a memory item as team or personal
+ * @param {Object} item - Memory item from pattern detector
+ * @returns {string} 'team' or 'personal'
+ */
+function classifyMemory(item) {
+  if (!item) return CLASSIFICATION.PERSONAL;
+
+  const text = getItemText(item);
+  const type = item.type;
+
+  // Gotchas are almost always team-level
+  if (type === 'gotcha') {
+    return CLASSIFICATION.TEAM;
+  }
+
+  // Check for "we" language (team indicator)
+  if (item.raw && /\bwe\b/i.test(item.raw)) {
+    return CLASSIFICATION.TEAM;
+  }
+
+  // Check for "I" language (personal indicator)
+  if (item.raw && /\bI\b/.test(item.raw)) {
+    return CLASSIFICATION.PERSONAL;
+  }
+
+  // Decisions are usually team-level unless about personal style
+  if (type === 'decision') {
+    if (containsKeyword(text, PERSONAL_KEYWORDS)) {
+      return CLASSIFICATION.PERSONAL;
+    }
+    return CLASSIFICATION.TEAM;
+  }
+
+  // Preferences are usually personal unless about infrastructure
+  if (type === 'preference') {
+    if (containsKeyword(text, TEAM_KEYWORDS)) {
+      return CLASSIFICATION.TEAM;
+    }
+    return CLASSIFICATION.PERSONAL;
+  }
+
+  // Reasoning depends on content
+  if (type === 'reasoning') {
+    if (containsKeyword(text, TEAM_KEYWORDS)) {
+      return CLASSIFICATION.TEAM;
+    }
+    if (containsKeyword(text, PERSONAL_KEYWORDS)) {
+      return CLASSIFICATION.PERSONAL;
+    }
+    // Check for "I" in reasoning
+    if (/\bI\b/.test(text)) {
+      return CLASSIFICATION.PERSONAL;
+    }
+    return CLASSIFICATION.TEAM;
+  }
+
+  // Check keywords as fallback
+  if (containsKeyword(text, TEAM_KEYWORDS)) {
+    return CLASSIFICATION.TEAM;
+  }
+
+  // Default to personal when ambiguous
+  return CLASSIFICATION.PERSONAL;
+}
+
+module.exports = {
+  classifyMemory,
+  CLASSIFICATION,
+  TEAM_KEYWORDS,
+  PERSONAL_KEYWORDS,
+};

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

@@ -0,0 +1,169 @@
+import { describe, it, expect } from 'vitest';
+import { classifyMemory, CLASSIFICATION } from './memory-classifier.js';
+
+describe('memory-classifier', () => {
+  describe('classifyMemory', () => {
+    describe('team classification', () => {
+      it('classifies architectural decision as team', () => {
+        const item = {
+          type: 'decision',
+          choice: 'PostgreSQL',
+          context: 'database selection',
+        };
+
+        expect(classifyMemory(item)).toBe(CLASSIFICATION.TEAM);
+      });
+
+      it('classifies technology choice as team', () => {
+        const item = {
+          type: 'decision',
+          choice: 'React',
+          reasoning: 'for frontend',
+        };
+
+        expect(classifyMemory(item)).toBe(CLASSIFICATION.TEAM);
+      });
+
+      it('classifies project gotcha as team', () => {
+        const item = {
+          type: 'gotcha',
+          subject: 'auth service',
+          issue: 'needs warm up time',
+        };
+
+        expect(classifyMemory(item)).toBe(CLASSIFICATION.TEAM);
+      });
+
+      it('classifies "we decided" language as team', () => {
+        const item = {
+          type: 'decision',
+          raw: 'we decided to use REST',
+        };
+
+        expect(classifyMemory(item)).toBe(CLASSIFICATION.TEAM);
+      });
+
+      it('classifies API/infrastructure decisions as team', () => {
+        const item = {
+          type: 'decision',
+          choice: 'REST API',
+        };
+
+        expect(classifyMemory(item)).toBe(CLASSIFICATION.TEAM);
+      });
+    });
+
+    describe('personal classification', () => {
+      it('classifies style preference as personal', () => {
+        const item = {
+          type: 'preference',
+          preference: 'functional programming',
+          category: 'codeStyle',
+        };
+
+        expect(classifyMemory(item)).toBe(CLASSIFICATION.PERSONAL);
+      });
+
+      it('classifies code correction as personal', () => {
+        const item = {
+          type: 'preference',
+          preference: 'named exports',
+          antiPreference: 'default exports',
+        };
+
+        expect(classifyMemory(item)).toBe(CLASSIFICATION.PERSONAL);
+      });
+
+      it('classifies "I prefer" language as personal', () => {
+        const item = {
+          type: 'preference',
+          raw: 'I prefer small functions',
+        };
+
+        expect(classifyMemory(item)).toBe(CLASSIFICATION.PERSONAL);
+      });
+
+      it('classifies formatting preference as personal', () => {
+        const item = {
+          type: 'preference',
+          preference: 'tabs over spaces',
+        };
+
+        expect(classifyMemory(item)).toBe(CLASSIFICATION.PERSONAL);
+      });
+
+      it('classifies comment style as personal', () => {
+        const item = {
+          type: 'preference',
+          preference: 'minimal comments',
+        };
+
+        expect(classifyMemory(item)).toBe(CLASSIFICATION.PERSONAL);
+      });
+    });
+
+    describe('edge cases', () => {
+      it('defaults to personal when ambiguous', () => {
+        const item = {
+          type: 'unknown',
+          content: 'something vague',
+        };
+
+        expect(classifyMemory(item)).toBe(CLASSIFICATION.PERSONAL);
+      });
+
+      it('handles empty item', () => {
+        expect(classifyMemory({})).toBe(CLASSIFICATION.PERSONAL);
+      });
+
+      it('handles undefined', () => {
+        expect(classifyMemory(undefined)).toBe(CLASSIFICATION.PERSONAL);
+      });
+
+      it('classifies reasoning as team when about architecture', () => {
+        const item = {
+          type: 'reasoning',
+          content: 'because the database needs to scale',
+        };
+
+        expect(classifyMemory(item)).toBe(CLASSIFICATION.TEAM);
+      });
+
+      it('classifies reasoning as personal when about style', () => {
+        const item = {
+          type: 'reasoning',
+          content: 'because I find it more readable',
+        };
+
+        expect(classifyMemory(item)).toBe(CLASSIFICATION.PERSONAL);
+      });
+    });
+
+    describe('keyword detection', () => {
+      it('detects team keywords in content', () => {
+        const teamKeywords = ['database', 'API', 'infrastructure', 'deployment', 'architecture'];
+
+        for (const keyword of teamKeywords) {
+          const item = { type: 'decision', choice: `something with ${keyword}` };
+          expect(classifyMemory(item)).toBe(CLASSIFICATION.TEAM);
+        }
+      });
+
+      it('detects personal keywords in content', () => {
+        const personalKeywords = ['prefer', 'style', 'formatting', 'indentation'];
+
+        for (const keyword of personalKeywords) {
+          const item = { type: 'preference', preference: `my ${keyword} choice` };
+          expect(classifyMemory(item)).toBe(CLASSIFICATION.PERSONAL);
+        }
+      });
+    });
+  });
+
+  describe('CLASSIFICATION', () => {
+    it('exports classification constants', () => {
+      expect(CLASSIFICATION.TEAM).toBe('team');
+      expect(CLASSIFICATION.PERSONAL).toBe('personal');
+    });
+  });
+});