tlc-claude-code 2.4.2 → 2.4.4

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);
+  });
+});

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

@@ -0,0 +1,76 @@
+function parseCodexEventLine(line) {
+  if (typeof line !== 'string' || line.trim() === '') {
+    return null;
+  }
+
+  try {
+    return JSON.parse(line);
+  } catch (_) {
+    return null;
+  }
+}
+
+function extractThreadId(event) {
+  if (
+    event &&
+    event.type === 'thread.started' &&
+    typeof event.thread_id === 'string' &&
+    event.thread_id.trim() !== ''
+  ) {
+    return event.thread_id;
+  }
+
+  return null;
+}
+
+function extractAgentMessages(event) {
+  if (!event || event.type !== 'agent_message') {
+    return [];
+  }
+
+  const items = Array.isArray(event.message && event.message.items)
+    ? event.message.items
+    : Array.isArray(event.items)
+      ? event.items
+      : [];
+
+  return items
+    .filter((item) => item && item.type === 'text' && typeof item.text === 'string' && item.text.trim() !== '')
+    .map((item) => item.text);
+}
+
+function parseCodexEvents(jsonStream) {
+  const lines = typeof jsonStream === 'string' ? jsonStream.split('\n') : [];
+  const events = [];
+  const agentMessages = [];
+  let threadId = null;
+
+  for (const line of lines) {
+    const event = parseCodexEventLine(line);
+    if (!event) {
+      continue;
+    }
+
+    events.push(event);
+
+    const nextThreadId = extractThreadId(event);
+    if (nextThreadId) {
+      threadId = nextThreadId;
+    }
+
+    agentMessages.push(...extractAgentMessages(event));
+  }
+
+  return {
+    threadId,
+    agentMessages,
+    events,
+  };
+}
+
+module.exports = {
+  extractAgentMessages,
+  extractThreadId,
+  parseCodexEventLine,
+  parseCodexEvents,
+};

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

@@ -0,0 +1,83 @@
+import { describe, it, expect } from 'vitest';
+
+import { parseCodexEvents } from './codex-event-parser.js';
+
+describe('capture/codex-event-parser', () => {
+  it('extracts threadId from thread.started events', () => {
+    const result = parseCodexEvents([
+      '{"type":"status","message":"booting"}',
+      '{"type":"thread.started","thread_id":"thread_123"}',
+    ].join('\n'));
+
+    expect(result.threadId).toBe('thread_123');
+  });
+
+  it('extracts text from agent_message item arrays', () => {
+    const result = parseCodexEvents([
+      JSON.stringify({
+        type: 'agent_message',
+        message: {
+          items: [
+            { type: 'text', text: 'First message' },
+            { type: 'image', url: 'ignored' },
+            { type: 'text', text: 'Second message' },
+          ],
+        },
+      }),
+    ].join('\n'));
+
+    expect(result.agentMessages).toEqual(['First message', 'Second message']);
+  });
+
+  it('preserves all parsed JSON events while skipping malformed lines', () => {
+    const result = parseCodexEvents([
+      '{"type":"status","message":"booting"}',
+      'not-json',
+      '{"type":"thread.started","thread_id":"thread_999"}',
+    ].join('\n'));
+
+    expect(result.events).toEqual([
+      { type: 'status', message: 'booting' },
+      { type: 'thread.started', thread_id: 'thread_999' },
+    ]);
+  });
+
+  it('returns null threadId when no thread.started event exists', () => {
+    const result = parseCodexEvents('{"type":"status","message":"booting"}\n');
+
+    expect(result.threadId).toBeNull();
+  });
+
+  it('ignores blank lines and non-agent_message events', () => {
+    const result = parseCodexEvents([
+      '',
+      '{"type":"status","message":"booting"}',
+      '',
+      '{"type":"message.delta","delta":"partial"}',
+      '',
+    ].join('\n'));
+
+    expect(result.agentMessages).toEqual([]);
+    expect(result.events).toEqual([
+      { type: 'status', message: 'booting' },
+      { type: 'message.delta', delta: 'partial' },
+    ]);
+  });
+
+  it('handles missing or non-string agent message text safely', () => {
+    const result = parseCodexEvents([
+      JSON.stringify({
+        type: 'agent_message',
+        message: {
+          items: [
+            { type: 'text', text: '' },
+            { type: 'text', text: 42 },
+            { type: 'text', text: 'usable' },
+          ],
+        },
+      }),
+    ].join('\n'));
+
+    expect(result.agentMessages).toEqual(['usable']);
+  });
+});