tlc-claude-code 1.2.27 → 1.2.29

package/server/lib/memory-committer.js

@@ -0,0 +1,138 @@
+/**
+ * Memory Committer - Auto-commit team memory with conventional commits
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const { exec } = require('child_process');
+const { promisify } = require('util');
+
+const execAsync = promisify(exec);
+
+/**
+ * Detect uncommitted memory files in team directory
+ * @param {string} projectRoot - Project root directory
+ * @returns {Promise<string[]>} List of uncommitted file paths
+ */
+async function detectUncommittedMemory(projectRoot) {
+  const teamDir = path.join(projectRoot, '.tlc', 'memory', 'team');
+
+  try {
+    await fs.access(teamDir);
+  } catch {
+    return [];
+  }
+
+  // Get all files in team directory
+  const files = [];
+
+  async function walkDir(dir) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walkDir(fullPath);
+      } else if (entry.name.endsWith('.json') || entry.name.endsWith('.md')) {
+        // Skip template files like conventions.md
+        if (entry.name === 'conventions.md') continue;
+
+        // Get path relative to projectRoot
+        const relativePath = path.relative(projectRoot, fullPath);
+        files.push(relativePath);
+      }
+    }
+  }
+
+  await walkDir(teamDir);
+
+  return files;
+}
+
+/**
+ * Generate conventional commit message for memory files
+ * @param {string[]} files - List of file paths
+ * @returns {string} Commit message
+ */
+function generateCommitMessage(files) {
+  if (!files || files.length === 0) return '';
+
+  const types = new Set();
+
+  for (const file of files) {
+    if (file.includes('decisions')) {
+      types.add('decision');
+    } else if (file.includes('gotchas')) {
+      types.add('gotcha');
+    }
+  }
+
+  const typeList = Array.from(types);
+  const typeStr = typeList.length === 1
+    ? typeList[0]
+    : typeList.slice(0, -1).join(', ') + ' and ' + typeList[typeList.length - 1];
+
+  return `docs(memory): add ${typeStr}${typeList.length > 1 || files.length > 1 ? 's' : ''}`;
+}
+
+/**
+ * Commit team memory files
+ * @param {string} projectRoot - Project root directory
+ * @param {Object} options - Options
+ * @param {boolean} options.dryRun - If true, don't actually commit
+ * @returns {Promise<Object>} Commit result
+ */
+async function commitTeamMemory(projectRoot, options = {}) {
+  const { dryRun = false } = options;
+
+  const files = await detectUncommittedMemory(projectRoot);
+
+  if (files.length === 0) {
+    return {
+      success: false,
+      reason: 'nothing to commit',
+      files: [],
+    };
+  }
+
+  const message = generateCommitMessage(files);
+
+  if (dryRun) {
+    return {
+      success: true,
+      dryRun: true,
+      committed: false,
+      files,
+      message,
+    };
+  }
+
+  try {
+    // Stage memory files
+    for (const file of files) {
+      await execAsync(`git add "${file}"`, { cwd: projectRoot });
+    }
+
+    // Commit
+    await execAsync(`git commit -m "${message}"`, { cwd: projectRoot });
+
+    return {
+      success: true,
+      committed: true,
+      files,
+      message,
+    };
+  } catch (err) {
+    return {
+      success: false,
+      reason: err.message,
+      files,
+      message,
+    };
+  }
+}
+
+module.exports = {
+  detectUncommittedMemory,
+  generateCommitMessage,
+  commitTeamMemory,
+};

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

@@ -0,0 +1,136 @@
+import { describe, it, beforeEach, afterEach, expect, vi } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { detectUncommittedMemory, generateCommitMessage, commitTeamMemory } from './memory-committer.js';
+import { initMemoryStructure } from './memory-storage.js';
+import { writeTeamDecision, writeTeamGotcha } from './memory-writer.js';
+
+describe('memory-committer', () => {
+  let testDir;
+
+  beforeEach(async () => {
+    testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tlc-committer-test-'));
+    await initMemoryStructure(testDir);
+  });
+
+  afterEach(() => {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  });
+
+  describe('detectUncommittedMemory', () => {
+    it('returns empty array for no memory files', async () => {
+      const uncommitted = await detectUncommittedMemory(testDir);
+      expect(uncommitted).toHaveLength(0);
+    });
+
+    it('detects new decision files', async () => {
+      await writeTeamDecision(testDir, {
+        title: 'Use PostgreSQL',
+        reasoning: 'JSONB support',
+      });
+
+      const uncommitted = await detectUncommittedMemory(testDir);
+
+      expect(uncommitted.length).toBeGreaterThan(0);
+      expect(uncommitted.some(f => f.includes('decisions'))).toBe(true);
+    });
+
+    it('detects new gotcha files', async () => {
+      await writeTeamGotcha(testDir, {
+        title: 'Auth delay',
+        issue: 'warmup needed',
+      });
+
+      const uncommitted = await detectUncommittedMemory(testDir);
+
+      expect(uncommitted.length).toBeGreaterThan(0);
+      expect(uncommitted.some(f => f.includes('gotchas'))).toBe(true);
+    });
+
+    it('excludes .local files', async () => {
+      // .local files should never be in uncommitted list
+      const localFile = path.join(testDir, '.tlc', 'memory', '.local', 'test.json');
+      fs.mkdirSync(path.dirname(localFile), { recursive: true });
+      fs.writeFileSync(localFile, '{}');
+
+      const uncommitted = await detectUncommittedMemory(testDir);
+
+      expect(uncommitted.every(f => !f.includes('.local'))).toBe(true);
+    });
+  });
+
+  describe('generateCommitMessage', () => {
+    it('generates message for decisions', () => {
+      const files = ['.tlc/memory/team/decisions/001.json'];
+      const message = generateCommitMessage(files);
+
+      expect(message).toContain('memory');
+      expect(message).toContain('decision');
+    });
+
+    it('generates message for gotchas', () => {
+      const files = ['.tlc/memory/team/gotchas/001.json'];
+      const message = generateCommitMessage(files);
+
+      expect(message).toContain('gotcha');
+    });
+
+    it('generates message for mixed types', () => {
+      const files = [
+        '.tlc/memory/team/decisions/001.json',
+        '.tlc/memory/team/gotchas/001.json',
+      ];
+      const message = generateCommitMessage(files);
+
+      expect(message).toContain('decision');
+      expect(message).toContain('gotcha');
+    });
+
+    it('uses conventional commit format', () => {
+      const files = ['.tlc/memory/team/decisions/001.json'];
+      const message = generateCommitMessage(files);
+
+      // Should start with docs: or chore: or similar (with optional scope)
+      expect(message).toMatch(/^(docs|chore|feat)(\([\w-]+\))?:/);
+    });
+
+    it('handles empty files array', () => {
+      const message = generateCommitMessage([]);
+      expect(message).toBe('');
+    });
+  });
+
+  describe('commitTeamMemory', () => {
+    it('returns success false for no uncommitted files', async () => {
+      const result = await commitTeamMemory(testDir, { dryRun: true });
+
+      expect(result.success).toBe(false);
+      expect(result.reason).toContain('nothing');
+    });
+
+    it('returns files that would be committed', async () => {
+      await writeTeamDecision(testDir, {
+        title: 'Test decision',
+        reasoning: 'Test',
+      });
+
+      const result = await commitTeamMemory(testDir, { dryRun: true });
+
+      expect(result.files.length).toBeGreaterThan(0);
+      expect(result.message).toBeTruthy();
+    });
+
+    it('respects dryRun option', async () => {
+      await writeTeamDecision(testDir, {
+        title: 'Test decision',
+        reasoning: 'Test',
+      });
+
+      const result = await commitTeamMemory(testDir, { dryRun: true });
+
+      expect(result.dryRun).toBe(true);
+      expect(result.committed).toBe(false);
+    });
+  });
+});

package/server/lib/memory-hooks.js

@@ -0,0 +1,127 @@
+/**
+ * Memory Hooks - Hook memory system into TLC command lifecycle
+ */
+
+const { buildSessionContext } = require('./context-builder.js');
+const { observeAndRemember, processExchange } = require('./memory-observer.js');
+const { generateSessionSummary, formatSummary } = require('./session-summary.js');
+const { appendSessionLog } = require('./memory-writer.js');
+
+/**
+ * MemoryHooks class for stateful hook management
+ */
+class MemoryHooks {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.sessionStartTime = null;
+    this.responseCount = 0;
+  }
+
+  /**
+   * Called when session starts - returns context for injection
+   * @returns {Promise<{context: string}>}
+   */
+  async onSessionStart() {
+    this.sessionStartTime = Date.now();
+    this.responseCount = 0;
+
+    const context = await buildSessionContext(this.projectRoot);
+
+    return { context };
+  }
+
+  /**
+   * Called after each response - observes for patterns
+   * @param {string} response - The response text
+   * @returns {Promise<{detected: boolean}>}
+   */
+  async onResponse(response) {
+    this.responseCount++;
+
+    // Create exchange object from response
+    const exchange = { assistant: response };
+
+    // Process the exchange for patterns (synchronous detection)
+    const classified = await processExchange(exchange);
+
+    // Fire and forget the storage (non-blocking)
+    observeAndRemember(this.projectRoot, exchange);
+
+    const detected = classified.decisions.length > 0 ||
+      classified.preferences.length > 0 ||
+      classified.gotchas.length > 0 ||
+      classified.reasoning.length > 0;
+
+    return { detected };
+  }
+
+  /**
+   * Called when session ends - returns summary
+   * @returns {Promise<{summary: string}>}
+   */
+  async onSessionEnd() {
+    const summaryData = await generateSessionSummary(this.projectRoot);
+    const summary = formatSummary(summaryData);
+
+    // Log session end
+    await appendSessionLog(this.projectRoot, {
+      type: 'session_end',
+      responseCount: this.responseCount,
+      duration: Date.now() - this.sessionStartTime,
+    });
+
+    return { summary };
+  }
+
+  /**
+   * Called before a command runs
+   * @param {string} command - Command name
+   * @returns {Promise<{command: string}>}
+   */
+  async beforeCommand(command) {
+    await appendSessionLog(this.projectRoot, {
+      type: 'command_start',
+      command,
+    });
+
+    return { command };
+  }
+
+  /**
+   * Called after a command runs
+   * @param {string} command - Command name
+   * @param {Object} result - Command result
+   * @returns {Promise<{logged: boolean}>}
+   */
+  async afterCommand(command, result) {
+    await appendSessionLog(this.projectRoot, {
+      type: 'command_end',
+      command,
+      success: result?.success,
+    });
+
+    return { logged: true };
+  }
+}
+
+/**
+ * Create memory hooks for a project
+ * @param {string} projectRoot - Project root directory
+ * @returns {Object} Hook functions
+ */
+function createMemoryHooks(projectRoot) {
+  const hooks = new MemoryHooks(projectRoot);
+
+  return {
+    onSessionStart: () => hooks.onSessionStart(),
+    onResponse: (response) => hooks.onResponse(response),
+    onSessionEnd: () => hooks.onSessionEnd(),
+    beforeCommand: (command) => hooks.beforeCommand(command),
+    afterCommand: (command, result) => hooks.afterCommand(command, result),
+  };
+}
+
+module.exports = {
+  createMemoryHooks,
+  MemoryHooks,
+};

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

@@ -0,0 +1,136 @@
+import { describe, it, beforeEach, afterEach, expect, vi } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { createMemoryHooks, MemoryHooks } from './memory-hooks.js';
+import { initMemoryStructure } from './memory-storage.js';
+
+describe('memory-hooks', () => {
+  let testDir;
+
+  beforeEach(async () => {
+    testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tlc-hooks-test-'));
+    await initMemoryStructure(testDir);
+  });
+
+  afterEach(() => {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  });
+
+  describe('createMemoryHooks', () => {
+    it('returns hooks object', () => {
+      const hooks = createMemoryHooks(testDir);
+
+      expect(hooks).toHaveProperty('onSessionStart');
+      expect(hooks).toHaveProperty('onResponse');
+      expect(hooks).toHaveProperty('onSessionEnd');
+      expect(hooks).toHaveProperty('beforeCommand');
+      expect(hooks).toHaveProperty('afterCommand');
+    });
+
+    it('hooks are callable functions', () => {
+      const hooks = createMemoryHooks(testDir);
+
+      expect(typeof hooks.onSessionStart).toBe('function');
+      expect(typeof hooks.onResponse).toBe('function');
+      expect(typeof hooks.onSessionEnd).toBe('function');
+    });
+  });
+
+  describe('onSessionStart', () => {
+    it('returns context for injection', async () => {
+      const hooks = createMemoryHooks(testDir);
+      const context = await hooks.onSessionStart();
+
+      expect(context).toHaveProperty('context');
+    });
+
+    it('returns empty context for new project', async () => {
+      const hooks = createMemoryHooks(testDir);
+      const result = await hooks.onSessionStart();
+
+      // New project has no memory, so context should be empty
+      expect(result.context).toBe('');
+    });
+  });
+
+  describe('onResponse', () => {
+    it('observes response for patterns', async () => {
+      const hooks = createMemoryHooks(testDir);
+
+      // Should not throw
+      await expect(hooks.onResponse('let\'s use PostgreSQL instead of MySQL')).resolves.not.toThrow();
+    });
+
+    it('returns detection results', async () => {
+      const hooks = createMemoryHooks(testDir);
+      const result = await hooks.onResponse('let\'s use PostgreSQL instead of MySQL');
+
+      expect(result).toHaveProperty('detected');
+    });
+  });
+
+  describe('onSessionEnd', () => {
+    it('returns session summary', async () => {
+      const hooks = createMemoryHooks(testDir);
+      const summary = await hooks.onSessionEnd();
+
+      expect(summary).toHaveProperty('summary');
+    });
+
+    it('includes formatted summary text', async () => {
+      const hooks = createMemoryHooks(testDir);
+      const result = await hooks.onSessionEnd();
+
+      expect(typeof result.summary).toBe('string');
+    });
+  });
+
+  describe('beforeCommand', () => {
+    it('runs without error', async () => {
+      const hooks = createMemoryHooks(testDir);
+
+      await expect(hooks.beforeCommand('build')).resolves.not.toThrow();
+    });
+
+    it('returns command context', async () => {
+      const hooks = createMemoryHooks(testDir);
+      const result = await hooks.beforeCommand('build');
+
+      expect(result).toHaveProperty('command');
+      expect(result.command).toBe('build');
+    });
+  });
+
+  describe('afterCommand', () => {
+    it('runs without error', async () => {
+      const hooks = createMemoryHooks(testDir);
+
+      await expect(hooks.afterCommand('build', { success: true })).resolves.not.toThrow();
+    });
+
+    it('logs command result', async () => {
+      const hooks = createMemoryHooks(testDir);
+      const result = await hooks.afterCommand('build', { success: true });
+
+      expect(result).toHaveProperty('logged');
+    });
+  });
+
+  describe('MemoryHooks class', () => {
+    it('can be instantiated', () => {
+      const hooks = new MemoryHooks(testDir);
+      expect(hooks).toBeInstanceOf(MemoryHooks);
+    });
+
+    it('shares state across calls', async () => {
+      const hooks = new MemoryHooks(testDir);
+
+      await hooks.onSessionStart();
+      await hooks.onResponse('test response');
+      const result = await hooks.onSessionEnd();
+
+      expect(result).toBeTruthy();
+    });
+  });
+});

package/server/lib/memory-init.js

@@ -0,0 +1,104 @@
+/**
+ * Memory Init - Initialize memory system directories
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+
+/**
+ * Directory structure for memory system
+ */
+const MEMORY_STRUCTURE = {
+  team: ['decisions', 'gotchas'],
+  local: ['preferences', 'sessions'],
+};
+
+/**
+ * Initialize the memory system directories
+ * @param {string} projectRoot - Project root directory
+ * @returns {Promise<{created: boolean, directories: string[]}>}
+ */
+async function initMemorySystem(projectRoot) {
+  const memoryRoot = path.join(projectRoot, '.tlc', 'memory');
+  const created = [];
+
+  // Create team directories
+  for (const subdir of MEMORY_STRUCTURE.team) {
+    const dirPath = path.join(memoryRoot, 'team', subdir);
+    try {
+      await fs.mkdir(dirPath, { recursive: true });
+      created.push(dirPath);
+    } catch (err) {
+      if (err.code !== 'EEXIST') throw err;
+    }
+  }
+
+  // Create local directories
+  for (const subdir of MEMORY_STRUCTURE.local) {
+    const dirPath = path.join(memoryRoot, '.local', subdir);
+    try {
+      await fs.mkdir(dirPath, { recursive: true });
+      created.push(dirPath);
+    } catch (err) {
+      if (err.code !== 'EEXIST') throw err;
+    }
+  }
+
+  // Ensure .gitignore has .local entry
+  const gitignorePath = path.join(memoryRoot, '.gitignore');
+  let gitignoreContent = '';
+  try {
+    gitignoreContent = await fs.readFile(gitignorePath, 'utf-8');
+  } catch (err) {
+    if (err.code !== 'ENOENT') throw err;
+  }
+
+  if (!gitignoreContent.includes('.local')) {
+    const newContent = gitignoreContent
+      ? gitignoreContent.trim() + '\n.local\n'
+      : '.local\n';
+    await fs.writeFile(gitignorePath, newContent, 'utf-8');
+  }
+
+  return {
+    created: created.length > 0,
+    directories: created,
+  };
+}
+
+/**
+ * Check if memory system is initialized
+ * @param {string} projectRoot - Project root directory
+ * @returns {Promise<boolean>}
+ */
+async function isMemoryInitialized(projectRoot) {
+  const memoryRoot = path.join(projectRoot, '.tlc', 'memory');
+
+  // Check team directories
+  for (const subdir of MEMORY_STRUCTURE.team) {
+    const dirPath = path.join(memoryRoot, 'team', subdir);
+    try {
+      await fs.access(dirPath);
+    } catch {
+      return false;
+    }
+  }
+
+  // Check local directories
+  for (const subdir of MEMORY_STRUCTURE.local) {
+    const dirPath = path.join(memoryRoot, '.local', subdir);
+    try {
+      await fs.access(dirPath);
+    } catch {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+module.exports = {
+  initMemorySystem,
+  isMemoryInitialized,
+  MEMORY_STRUCTURE,
+};