tlc-claude-code 2.4.3 → 2.4.4

package/server/lib/capture/classifier.js

@@ -0,0 +1,71 @@
+const PATTERN_GROUPS = [
+  {
+    type: 'gotcha',
+    scope: 'team',
+    patterns: [
+      { regex: /\bdon't do\b/i, confidence: 0.85 },
+      { regex: /\bwatch out\b/i, confidence: 0.85 },
+      { regex: /\bbreaks when\b/i, confidence: 0.9 },
+      { regex: /\bcareful with\b/i, confidence: 0.8 },
+      { regex: /\bnever use\b/i, confidence: 0.9 },
+      { regex: /\bgotcha\b/i, confidence: 0.75 },
+      { regex: /\bdon't use\b/i, confidence: 0.9 },
+    ],
+  },
+  {
+    type: 'preference',
+    scope: 'personal',
+    patterns: [
+      { regex: /\bi prefer\b/i, confidence: 0.8 },
+      { regex: /\bi like\b/i, confidence: 0.7 },
+      { regex: /\bfor me\b/i, confidence: 0.65 },
+      { regex: /\bmy workflow\b/i, confidence: 0.75 },
+    ],
+  },
+  {
+    type: 'decision',
+    scope: 'team',
+    patterns: [
+      { regex: /\bwe decided\b/i, confidence: 0.9 },
+      { regex: /\bchose\b/i, confidence: 0.75 },
+      { regex: /\bgoing with\b/i, confidence: 0.8 },
+      { regex: /\bthe approach is\b/i, confidence: 0.8 },
+      { regex: /\busing\b.+\bfor\b/i, confidence: 0.7 },
+      { regex: /\bsplit into\b/i, confidence: 0.75 },
+      { regex: /\bcreated\b/i, confidence: 0.7 },
+      { regex: /\bimplemented\b/i, confidence: 0.7 },
+    ],
+  },
+];
+
+function classify(statement) {
+  const text = typeof statement === 'string' ? statement.trim() : '';
+
+  if (!text) {
+    return { type: 'session', scope: 'personal', confidence: 0.1 };
+  }
+
+  let bestMatch = null;
+
+  for (const group of PATTERN_GROUPS) {
+    for (const pattern of group.patterns) {
+      if (!pattern.regex.test(text)) {
+        continue;
+      }
+
+      if (!bestMatch || pattern.confidence > bestMatch.confidence) {
+        bestMatch = {
+          type: group.type,
+          scope: group.scope,
+          confidence: pattern.confidence,
+        };
+      }
+    }
+  }
+
+  return bestMatch || { type: 'session', scope: 'personal', confidence: 0.1 };
+}
+
+module.exports = {
+  classify,
+};

package/server/lib/capture/classifier.test.js

@@ -0,0 +1,71 @@
+import { describe, it, expect } from 'vitest';
+
+const { classify } = require('./classifier.js');
+
+describe('capture/classifier', () => {
+  it('classifies explicit decision statements as decision/team', () => {
+    expect(classify('We decided to use Postgres')).toEqual({
+      type: 'decision',
+      scope: 'team',
+      confidence: expect.any(Number),
+    });
+  });
+
+  it('classifies gotcha statements as gotcha/team', () => {
+    const result = classify("Don't use synchronous fs calls");
+
+    expect(result.type).toBe('gotcha');
+    expect(result.scope).toBe('team');
+    expect(result.confidence).toBeGreaterThan(0.1);
+  });
+
+  it('classifies preference statements as preference/personal', () => {
+    const result = classify('I prefer dark theme');
+
+    expect(result).toEqual({
+      type: 'preference',
+      scope: 'personal',
+      confidence: expect.any(Number),
+    });
+  });
+
+  it('returns session/personal with low confidence for unknown text', () => {
+    expect(classify('Hello there')).toEqual({
+      type: 'session',
+      scope: 'personal',
+      confidence: 0.1,
+    });
+  });
+
+  it('treats code-change language as a team decision', () => {
+    const result = classify('Created 3 modules');
+
+    expect(result.type).toBe('decision');
+    expect(result.scope).toBe('team');
+  });
+
+  it('classifies using X for Y phrasing as a decision', () => {
+    const result = classify('Using Redis for rate limiting');
+
+    expect(result.type).toBe('decision');
+    expect(result.scope).toBe('team');
+  });
+
+  it('classifies watch out phrasing as a gotcha', () => {
+    const result = classify('Watch out for stale closures in async loops');
+
+    expect(result.type).toBe('gotcha');
+    expect(result.scope).toBe('team');
+  });
+
+  it('classifies workflow phrasing as a personal preference', () => {
+    const result = classify('My workflow is to review diffs before running tests');
+
+    expect(result.type).toBe('preference');
+    expect(result.scope).toBe('personal');
+  });
+
+  it('keeps decision confidence above the default fallback confidence', () => {
+    expect(classify('Implemented request tracing').confidence).toBeGreaterThan(0.1);
+  });
+});

package/server/lib/capture/claude-capture.js

@@ -0,0 +1,140 @@
+const path = require('path');
+
+const { createEnvelope } = require('./envelope');
+const { redact } = require('./redactor');
+const { ensureMemoryReady } = require('./ensure-ready');
+
+const SPOOL_PATH = path.join('.tlc', 'memory', '.spool.jsonl');
+
+function parseHookInput(hookInput) {
+  if (typeof hookInput !== 'string') {
+    return null;
+  }
+
+  try {
+    const parsed = JSON.parse(hookInput);
+    return parsed && typeof parsed === 'object' ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function normalizeContent(content) {
+  if (typeof content === 'string') {
+    return content;
+  }
+
+  if (Array.isArray(content)) {
+    return content
+      .map((item) => {
+        if (!item || typeof item !== 'object') {
+          return '';
+        }
+
+        if (typeof item.text === 'string') {
+          return item.text;
+        }
+
+        if (typeof item.content === 'string') {
+          return item.content;
+        }
+
+        return '';
+      })
+      .filter(Boolean)
+      .join('\n');
+  }
+
+  return '';
+}
+
+function extractUserMessage(transcriptPath, fs) {
+  if (typeof transcriptPath !== 'string' || transcriptPath.trim() === '') {
+    return '';
+  }
+
+  try {
+    const content = fs.readFileSync(transcriptPath, 'utf8').trim();
+
+    if (!content) {
+      return '';
+    }
+
+    const lines = content.split('\n');
+    let lastUserMessage = '';
+
+    for (const line of lines) {
+      if (!line.trim()) {
+        continue;
+      }
+
+      try {
+        const entry = JSON.parse(line);
+
+        if (entry.role !== 'user') {
+          continue;
+        }
+
+        const message = normalizeContent(entry.content || entry.message);
+
+        if (message.trim()) {
+          lastUserMessage = message;
+        }
+      } catch {
+        // Skip malformed transcript lines.
+      }
+    }
+
+    return lastUserMessage;
+  } catch {
+    return '';
+  }
+}
+
+function redactEnvelope(envelope) {
+  const userMessage = redact(envelope.metadata && envelope.metadata.userMessage ? envelope.metadata.userMessage : '');
+  const assistantMessage = redact(envelope.metadata && envelope.metadata.assistantMessage ? envelope.metadata.assistantMessage : '');
+
+  return {
+    ...envelope,
+    text: redact(envelope.text),
+    metadata: {
+      ...envelope.metadata,
+      userMessage,
+      assistantMessage,
+    },
+  };
+}
+
+function captureClaudeExchange({ hookInput, projectDir, fs = require('fs') }) {
+  const parsed = parseHookInput(hookInput);
+
+  if (!parsed) {
+    return { captured: 0, skipped: 1 };
+  }
+
+  if (typeof parsed.assistant_message !== 'string' || parsed.assistant_message.trim() === '') {
+    return { captured: 0, skipped: 0 };
+  }
+
+  const userMessage = extractUserMessage(parsed.transcript_path, fs);
+  const envelope = redactEnvelope(createEnvelope({
+    provider: 'claude',
+    source: 'stop-hook',
+    threadId: typeof parsed.session_id === 'string' ? parsed.session_id : undefined,
+    userMessage,
+    assistantMessage: parsed.assistant_message,
+  }));
+
+  ensureMemoryReady(projectDir, { fs });
+
+  const spoolPath = path.join(projectDir, SPOOL_PATH);
+  fs.mkdirSync(path.dirname(spoolPath), { recursive: true });
+  fs.appendFileSync(spoolPath, `${JSON.stringify(envelope)}\n`);
+
+  return { captured: 1, skipped: 0 };
+}
+
+module.exports = {
+  captureClaudeExchange,
+};

package/server/lib/capture/claude-capture.test.js

@@ -0,0 +1,152 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+describe('capture/claude-capture', () => {
+  let projectDir;
+  let captureClaudeExchange;
+
+  beforeEach(async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2026-03-28T12:34:56.000Z'));
+    projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tlc-claude-capture-test-'));
+    ({ captureClaudeExchange } = await import('./claude-capture.js'));
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.resetModules();
+    fs.rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  it('returns skipped for malformed hook input', () => {
+    const result = captureClaudeExchange({
+      hookInput: '{"session_id"',
+      projectDir,
+    });
+
+    expect(result).toEqual({ captured: 0, skipped: 1 });
+    expect(fs.existsSync(path.join(projectDir, '.tlc', 'memory', '.spool.jsonl'))).toBe(false);
+  });
+
+  it('returns no-op when assistant_message is missing', () => {
+    const result = captureClaudeExchange({
+      hookInput: JSON.stringify({
+        session_id: 'sess-1',
+        transcript_path: path.join(projectDir, 'transcript.jsonl'),
+      }),
+      projectDir,
+    });
+
+    expect(result).toEqual({ captured: 0, skipped: 0 });
+    expect(fs.existsSync(path.join(projectDir, '.tlc', 'memory', '.spool.jsonl'))).toBe(false);
+  });
+
+  it('captures the transcript user message and assistant message into the spool', () => {
+    const transcriptPath = path.join(projectDir, 'transcript.jsonl');
+
+    fs.writeFileSync(transcriptPath, [
+      JSON.stringify({ role: 'user', content: 'First prompt' }),
+      JSON.stringify({ role: 'assistant', content: 'First reply' }),
+      JSON.stringify({ role: 'user', content: 'Use PostgreSQL with JSONB' }),
+    ].join('\n') + '\n');
+
+    const result = captureClaudeExchange({
+      hookInput: JSON.stringify({
+        session_id: 'sess-2',
+        cwd: projectDir,
+        transcript_path: transcriptPath,
+        assistant_message: 'We should use PostgreSQL with JSONB indexes.',
+      }),
+      projectDir,
+    });
+
+    expect(result).toEqual({ captured: 1, skipped: 0 });
+
+    const spoolPath = path.join(projectDir, '.tlc', 'memory', '.spool.jsonl');
+    const envelope = JSON.parse(fs.readFileSync(spoolPath, 'utf8').trim());
+
+    expect(envelope).toMatchObject({
+      provider: 'claude',
+      source: 'stop-hook',
+      threadId: 'sess-2',
+      text: 'Use PostgreSQL with JSONB\n\nWe should use PostgreSQL with JSONB indexes.',
+      timestamp: '2026-03-28T12:34:56.000Z',
+      metadata: {
+        userMessage: 'Use PostgreSQL with JSONB',
+        assistantMessage: 'We should use PostgreSQL with JSONB indexes.',
+      },
+    });
+  });
+
+  it('redacts sensitive values before appending the envelope', () => {
+    const transcriptPath = path.join(projectDir, 'transcript.jsonl');
+
+    fs.writeFileSync(transcriptPath, `${JSON.stringify({
+      role: 'user',
+      content: 'token="sk-secret123" path=/Users/jurgen/private/app.js',
+    })}\n`);
+
+    captureClaudeExchange({
+      hookInput: JSON.stringify({
+        session_id: 'sess-3',
+        transcript_path: transcriptPath,
+        assistant_message: 'password=hunter2 Bearer abc.def.ghi',
+      }),
+      projectDir,
+    });
+
+    const spoolPath = path.join(projectDir, '.tlc', 'memory', '.spool.jsonl');
+    const envelope = JSON.parse(fs.readFileSync(spoolPath, 'utf8').trim());
+
+    expect(envelope.text).toContain('[TOKEN_REDACTED]');
+    expect(envelope.text).toContain('[REDACTED]');
+    expect(envelope.text).toContain('Bearer [TOKEN_REDACTED]');
+    expect(envelope.text).toContain('~/private/app.js');
+    expect(envelope.text).not.toContain('hunter2');
+    expect(envelope.text).not.toContain('/Users/jurgen');
+  });
+
+  it('appends new envelopes instead of overwriting the spool file', () => {
+    const spoolPath = path.join(projectDir, '.tlc', 'memory', '.spool.jsonl');
+    fs.mkdirSync(path.dirname(spoolPath), { recursive: true });
+    fs.writeFileSync(spoolPath, `${JSON.stringify({ existing: true })}\n`);
+
+    captureClaudeExchange({
+      hookInput: JSON.stringify({
+        session_id: 'sess-4',
+        assistant_message: 'Assistant only message',
+      }),
+      projectDir,
+    });
+
+    const lines = fs.readFileSync(spoolPath, 'utf8').trim().split('\n');
+
+    expect(lines).toHaveLength(2);
+    expect(JSON.parse(lines[0])).toEqual({ existing: true });
+    expect(JSON.parse(lines[1])).toMatchObject({
+      provider: 'claude',
+      source: 'stop-hook',
+      threadId: 'sess-4',
+      text: 'Assistant only message',
+    });
+  });
+
+  it('initializes the memory tree before writing the spool file', () => {
+    captureClaudeExchange({
+      hookInput: JSON.stringify({
+        session_id: 'sess-5',
+        assistant_message: 'Create the memory tree first',
+      }),
+      projectDir,
+    });
+
+    expect(fs.existsSync(path.join(projectDir, '.tlc', 'memory', '.team'))).toBe(false);
+    expect(fs.existsSync(path.join(projectDir, '.tlc', 'memory', 'team', 'decisions'))).toBe(true);
+    expect(fs.existsSync(path.join(projectDir, '.tlc', 'memory', 'team', 'gotchas'))).toBe(true);
+    expect(fs.existsSync(path.join(projectDir, '.tlc', 'memory', '.local', 'sessions'))).toBe(true);
+    expect(fs.existsSync(path.join(projectDir, '.tlc', 'memory', 'team', 'decisions', '.gitkeep'))).toBe(true);
+    expect(fs.existsSync(path.join(projectDir, '.tlc', 'memory', 'team', 'gotchas', '.gitkeep'))).toBe(true);
+  });
+});

package/server/lib/capture/codex-capture.js

@@ -0,0 +1,79 @@
+const path = require('path');
+
+const { createEnvelope } = require('./envelope');
+const { redact } = require('./redactor');
+const { ensureMemoryReady } = require('./ensure-ready');
+const { parseCodexEvents } = require('./codex-event-parser');
+
+const SPOOL_FILENAME = '.spool.jsonl';
+
+function resolveCaptureText({ lastMessageFile, jsonStream, stdout, fs }) {
+  if (lastMessageFile && fs.existsSync(lastMessageFile)) {
+    return {
+      source: 'last-message-file',
+      text: fs.readFileSync(lastMessageFile, 'utf8'),
+      parsedThreadId: null,
+    };
+  }
+
+  if (typeof jsonStream === 'string') {
+    const parsed = parseCodexEvents(jsonStream);
+    const joinedMessages = parsed.agentMessages.join('\n\n');
+
+    if (joinedMessages.trim() !== '') {
+      return {
+        source: 'json-stream',
+        text: joinedMessages,
+        parsedThreadId: parsed.threadId,
+      };
+    }
+  }
+
+  return {
+    source: 'stdout',
+    text: typeof stdout === 'string' ? stdout : '',
+    parsedThreadId: null,
+  };
+}
+
+function captureCodexOutput({
+  lastMessageFile,
+  jsonStream,
+  stdout,
+  taskName,
+  threadId,
+  projectDir,
+  fs = require('fs'),
+}) {
+  const capture = resolveCaptureText({ lastMessageFile, jsonStream, stdout, fs });
+
+  try {
+    const envelope = createEnvelope({
+      provider: 'codex',
+      source: capture.source,
+      taskName,
+      threadId: threadId || capture.parsedThreadId,
+      assistantMessage: capture.text,
+    });
+
+    envelope.text = redact(envelope.text);
+    if (envelope.metadata && typeof envelope.metadata.assistantMessage === 'string') {
+      envelope.metadata.assistantMessage = redact(envelope.metadata.assistantMessage);
+    }
+
+    ensureMemoryReady(projectDir, { fs });
+
+    const spoolPath = path.join(projectDir, '.tlc', 'memory', SPOOL_FILENAME);
+    fs.appendFileSync(spoolPath, JSON.stringify(envelope) + '\n', 'utf8');
+
+    return { captured: 1, skipped: 0 };
+  } catch (_) {
+    return { captured: 0, skipped: 1 };
+  }
+}
+
+module.exports = {
+  captureCodexOutput,
+  resolveCaptureText,
+  SPOOL_FILENAME,
+};

package/server/lib/capture/codex-capture.test.js

@@ -0,0 +1,161 @@
+import { describe, it, beforeEach, afterEach, expect, vi } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+import { captureCodexOutput } from './codex-capture.js';
+
+const SPOOL_PATH = ['.tlc', 'memory', '.spool.jsonl'];
+
+describe('capture/codex-capture', () => {
+  let projectDir;
+
+  beforeEach(() => {
+    projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tlc-codex-capture-'));
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    fs.rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  function readSpoolEntries() {
+    const spoolPath = path.join(projectDir, ...SPOOL_PATH);
+    const content = fs.readFileSync(spoolPath, 'utf8').trim();
+    return content.split('\n').filter(Boolean).map((line) => JSON.parse(line));
+  }
+
+  it('prefers lastMessageFile when it exists', () => {
+    const lastMessageFile = path.join(projectDir, 'last-message.txt');
+    fs.writeFileSync(lastMessageFile, 'Message from file');
+
+    const result = captureCodexOutput({
+      lastMessageFile,
+      jsonStream: '{"type":"agent_message","message":{"items":[{"type":"text","text":"json"}]}}',
+      stdout: 'raw stdout',
+      taskName: 'capture',
+      threadId: 'thread-from-arg',
+      projectDir,
+    });
+
+    const [entry] = readSpoolEntries();
+
+    expect(result).toEqual({ captured: 1, skipped: 0 });
+    expect(entry.provider).toBe('codex');
+    expect(entry.source).toBe('last-message-file');
+    expect(entry.text).toBe('Message from file');
+    expect(entry.threadId).toBe('thread-from-arg');
+  });
+
+  it('falls back to agent messages from jsonStream when no lastMessageFile is available', () => {
+    const jsonStream = [
+      '{"type":"thread.started","thread_id":"thread-from-json"}',
+      JSON.stringify({
+        type: 'agent_message',
+        message: {
+          items: [
+            { type: 'text', text: 'First agent message' },
+            { type: 'text', text: 'Second agent message' },
+          ],
+        },
+      }),
+    ].join('\n');
+
+    const result = captureCodexOutput({
+      lastMessageFile: path.join(projectDir, 'missing.txt'),
+      jsonStream,
+      stdout: 'raw stdout',
+      taskName: 'capture',
+      threadId: null,
+      projectDir,
+    });
+
+    const [entry] = readSpoolEntries();
+
+    expect(result).toEqual({ captured: 1, skipped: 0 });
+    expect(entry.source).toBe('json-stream');
+    expect(entry.threadId).toBe('thread-from-json');
+    expect(entry.text).toBe('First agent message\n\nSecond agent message');
+  });
+
+  it('falls back to raw stdout when jsonStream has no agent messages', () => {
+    const result = captureCodexOutput({
+      jsonStream: '{"type":"status","message":"booting"}\n',
+      stdout: 'stdout fallback text',
+      taskName: 'capture',
+      threadId: 'thread-stdout',
+      projectDir,
+    });
+
+    const [entry] = readSpoolEntries();
+
+    expect(result).toEqual({ captured: 1, skipped: 0 });
+    expect(entry.source).toBe('stdout');
+    expect(entry.text).toBe('stdout fallback text');
+    expect(entry.threadId).toBe('thread-stdout');
+  });
+
+  it('redacts sensitive values before appending to spool', () => {
+    captureCodexOutput({
+      stdout: 'token=abc123 sk-secret-key /Users/jurgen/private/file.js',
+      taskName: 'capture',
+      threadId: 'thread-redact',
+      projectDir,
+    });
+
+    const [entry] = readSpoolEntries();
+
+    expect(entry.text).toContain('[TOKEN_REDACTED]');
+    expect(entry.text).toContain('[API_KEY_REDACTED]');
+    expect(entry.text).toContain('~/private/file.js');
+  });
+
+  it('creates the memory spool path before writing', () => {
+    captureCodexOutput({
+      stdout: 'create spool dirs',
+      taskName: 'capture',
+      threadId: 'thread-dirs',
+      projectDir,
+    });
+
+    expect(fs.existsSync(path.join(projectDir, '.tlc', 'memory'))).toBe(true);
+    expect(fs.existsSync(path.join(projectDir, '.tlc', 'memory', '.spool.jsonl'))).toBe(true);
+  });
+
+  it('skips capture when all candidate sources are empty', () => {
+    const result = captureCodexOutput({
+      stdout: '   ',
+      jsonStream: 'not-json\n',
+      taskName: 'capture',
+      threadId: 'thread-empty',
+      projectDir,
+    });
+
+    const spoolPath = path.join(projectDir, ...SPOOL_PATH);
+
+    expect(result).toEqual({ captured: 0, skipped: 1 });
+    expect(fs.existsSync(spoolPath)).toBe(false);
+  });
+
+  it('supports injected fs implementations', () => {
+    const injectedFs = {
+      ...fs,
+      appendFileSync: vi.fn(fs.appendFileSync),
+      existsSync: vi.fn(fs.existsSync),
+      mkdirSync: vi.fn(fs.mkdirSync),
+      readFileSync: vi.fn(fs.readFileSync),
+      writeFileSync: vi.fn(fs.writeFileSync),
+    };
+
+    const result = captureCodexOutput({
+      stdout: 'injected fs',
+      taskName: 'capture',
+      threadId: 'thread-injected',
+      projectDir,
+      fs: injectedFs,
+    });
+
+    expect(result).toEqual({ captured: 1, skipped: 0 });
+    expect(injectedFs.appendFileSync).toHaveBeenCalledTimes(1);
+  });
+});