tlc-claude-code 2.4.2 → 2.4.4

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

@@ -0,0 +1,93 @@
+import { describe, it, expect } from 'vitest';
+
+describe('capture/redactor', () => {
+  it('redacts OpenAI style API keys', async () => {
+    const { redact } = await import('./redactor.js');
+
+    expect(redact('token sk-abcdefghijklmnopqrstuvwxyz123456')).toContain('[API_KEY_REDACTED]');
+  });
+
+  it('redacts GitHub tokens with ghp_ and ghu_ prefixes', async () => {
+    const { redact } = await import('./redactor.js');
+
+    const output = redact('ghp_abcdefghijklmnopqrstuvwxyz123456 and ghu_abcdefghijklmnopqrstuvwxyz123456');
+
+    expect(output).not.toContain('ghp_abcdefghijklmnopqrstuvwxyz123456');
+    expect(output).not.toContain('ghu_abcdefghijklmnopqrstuvwxyz123456');
+  });
+
+  it('redacts bearer tokens', async () => {
+    const { redact } = await import('./redactor.js');
+
+    expect(redact('Authorization: Bearer abc.def.ghi')).toBe('Authorization: Bearer [TOKEN_REDACTED]');
+  });
+
+  it('redacts token fields inside quoted JSON-like text', async () => {
+    const { redact } = await import('./redactor.js');
+
+    expect(redact('{"token":"abc123secret"}')).toBe('{"token":"[TOKEN_REDACTED]"}');
+  });
+
+  it('redacts password and secret assignments', async () => {
+    const { redact } = await import('./redactor.js');
+
+    const output = redact('password=hunter2 secret=abc PASSWORD="quoted-secret"');
+
+    expect(output).toContain('password=[REDACTED]');
+    expect(output).toContain('secret=[REDACTED]');
+    expect(output).toContain('PASSWORD="[REDACTED]"');
+  });
+
+  it('rewrites absolute user paths under /Users and /home', async () => {
+    const { redact } = await import('./redactor.js');
+
+    const output = redact('See /Users/jurgen/project/file.js and /home/alice/work/app.js');
+
+    expect(output).toBe('See ~/project/file.js and ~/work/app.js');
+  });
+
+  it('collapses stack traces to first and last line with omitted count', async () => {
+    const { redact } = await import('./redactor.js');
+    const input = [
+      'Error: boom',
+      '    at a (/tmp/a.js:1:1)',
+      '    at b (/tmp/b.js:2:2)',
+      '    at c (/tmp/c.js:3:3)',
+      'Caused by: root issue',
+    ].join('\n');
+
+    expect(redact(input)).toBe('Error: boom\n... 3 more lines\nCaused by: root issue');
+  });
+
+  it('does not collapse short multi-line text that is not a stack trace', async () => {
+    const { redact } = await import('./redactor.js');
+    const input = 'line one\nline two';
+
+    expect(redact(input)).toBe('line one\nline two');
+  });
+
+  it('redacts long base64 blobs', async () => {
+    const { redact } = await import('./redactor.js');
+    const blob = 'QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVo='.repeat(4);
+
+    expect(redact(`payload=${blob}`)).toBe('payload=[BASE64_REDACTED]');
+  });
+
+  it('applies extra custom patterns after built-in redaction', async () => {
+    const { redact } = await import('./redactor.js');
+
+    const output = redact('Order ID: 12345', {
+      extraPatterns: [
+        { pattern: /12345/g, replacement: '[ORDER_ID]' },
+      ],
+    });
+
+    expect(output).toBe('Order ID: [ORDER_ID]');
+  });
+
+  it('returns the original string when there is nothing to redact', async () => {
+    const { redact } = await import('./redactor.js');
+
+    expect(redact('plain text only')).toBe('plain text only');
+  });
+});

package/server/lib/capture/spool-processor.js

@@ -0,0 +1,155 @@
+const path = require('path');
+
+const { validateEnvelope } = require('./envelope');
+const { redact } = require('./redactor');
+const { extractDecisions } = require('./extractor');
+const { classify } = require('./classifier');
+const { ensureMemoryReady } = require('./ensure-ready');
+
+const SPOOL_PATH = path.join('.tlc', 'memory', '.spool.jsonl');
+
+function escapeYamlString(value) {
+  return String(value ?? '').replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+
+function slugify(statement) {
+  const words = String(statement)
+    .toLowerCase()
+    .replace(/['"]/g, '')
+    .match(/[a-z0-9]+/g) || [];
+
+  const slug = words.slice(0, 5).join('-').slice(0, 40).replace(/-+$/g, '');
+
+  return slug || 'entry';
+}
+
+function dateFromTimestamp(timestamp) {
+  const value = typeof timestamp === 'string' ? timestamp.slice(0, 10) : '';
+  return /^\d{4}-\d{2}-\d{2}$/.test(value) ? value : 'unknown-date';
+}
+
+function buildFrontmatter(envelope, classification, confidence, statement) {
+  return [
+    '---',
+    `provider: ${envelope.provider}`,
+    `source: ${envelope.source || 'unknown'}`,
+    `timestamp: ${envelope.timestamp}`,
+    `taskName: "${escapeYamlString(envelope.taskName || '')}"`,
+    `confidence: ${Number(confidence.toFixed(4))}`,
+    `type: ${classification.type}`,
+    `scope: ${classification.scope}`,
+    '---',
+    '',
+    statement,
+    '',
+  ].join('\n');
+}
+
+function resolveTargetDir(classification) {
+  if (classification.scope === 'team' && classification.type === 'decision') {
+    return path.join('.tlc', 'memory', 'team', 'decisions');
+  }
+
+  if (classification.scope === 'team' && classification.type === 'gotcha') {
+    return path.join('.tlc', 'memory', 'team', 'gotchas');
+  }
+
+  return path.join('.tlc', 'memory', '.local', 'sessions');
+}
+
+function nextAvailableFilePath(projectDir, relativeDir, baseName, fs) {
+  const directory = path.join(projectDir, relativeDir);
+  let candidate = `${baseName}.md`;
+  let counter = 2;
+
+  while (fs.existsSync(path.join(directory, candidate))) {
+    candidate = `${baseName}-${counter}.md`;
+    counter += 1;
+  }
+
+  return path.join(directory, candidate);
+}
+
+function writeStatements(projectDir, envelope, statements, fs) {
+  for (const entry of statements) {
+    const classification = classify(entry.statement);
+
+    if (!classification || classification.type === 'session') {
+      continue;
+    }
+
+    const relativeDir = resolveTargetDir(classification);
+    const baseName = `${dateFromTimestamp(envelope.timestamp)}-${slugify(entry.statement)}`;
+    const targetPath = nextAvailableFilePath(projectDir, relativeDir, baseName, fs);
+    const content = buildFrontmatter(envelope, classification, entry.confidence, entry.statement);
+
+    fs.writeFileSync(targetPath, content);
+  }
+}
+
+function processSpool(projectDir, { fs = require('fs') } = {}) {
+  const spoolPath = path.join(projectDir, SPOOL_PATH);
+
+  if (!fs.existsSync(spoolPath)) {
+    return { processed: 0, skipped: 0, warnings: [] };
+  }
+
+  const input = fs.readFileSync(spoolPath, 'utf8');
+  const lines = input === '' ? [] : input.split('\n');
+  const warnings = [];
+  const remainingLines = [];
+  let processed = 0;
+  let skipped = 0;
+  let ensured = false;
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+
+    if (!line.trim()) {
+      continue;
+    }
+
+    let envelope;
+
+    try {
+      envelope = JSON.parse(line);
+    } catch (error) {
+      skipped += 1;
+      remainingLines.push(line);
+      warnings.push(`Malformed JSON on line ${index + 1}: ${error.message}`);
+      continue;
+    }
+
+    const validation = validateEnvelope(envelope);
+
+    if (!validation.valid) {
+      skipped += 1;
+      remainingLines.push(line);
+      warnings.push(`Invalid envelope on line ${index + 1}: ${validation.errors.join(', ')}`);
+      continue;
+    }
+
+    const redactedText = redact(envelope.text);
+    const statements = extractDecisions(redactedText);
+
+    if (!ensured) {
+      ensureMemoryReady(projectDir, { fs });
+      ensured = true;
+    }
+
+    writeStatements(projectDir, envelope, statements, fs);
+    processed += 1;
+  }
+
+  fs.writeFileSync(spoolPath, remainingLines.join('\n'));
+
+  return {
+    processed,
+    skipped,
+    warnings,
+  };
+}
+
+module.exports = {
+  processSpool,
+};

package/server/lib/capture/spool-processor.test.js

@@ -0,0 +1,278 @@
+import { describe, it, beforeEach, afterEach, expect, vi } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+const spoolRelativePath = path.join('.tlc', 'memory', '.spool.jsonl');
+
+function readFile(filePath) {
+  return fs.readFileSync(filePath, 'utf8');
+}
+
+function readSpool(projectDir) {
+  const spoolPath = path.join(projectDir, spoolRelativePath);
+
+  if (!fs.existsSync(spoolPath)) {
+    return null;
+  }
+
+  return readFile(spoolPath);
+}
+
+function writeSpool(projectDir, lines) {
+  const spoolPath = path.join(projectDir, spoolRelativePath);
+  fs.mkdirSync(path.dirname(spoolPath), { recursive: true });
+  fs.writeFileSync(spoolPath, lines.join('\n'));
+}
+
+function findMarkdownFiles(projectDir, relativeDir) {
+  const targetDir = path.join(projectDir, relativeDir);
+
+  if (!fs.existsSync(targetDir)) {
+    return [];
+  }
+
+  return fs.readdirSync(targetDir)
+    .filter((entry) => entry.endsWith('.md') && entry !== '.gitkeep')
+    .sort();
+}
+
+describe('capture/spool-processor', () => {
+  let projectDir;
+  let processSpool;
+
+  beforeEach(async () => {
+    projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tlc-spool-processor-test-'));
+    ({ processSpool } = await import('./spool-processor.js'));
+  });
+
+  afterEach(() => {
+    vi.resetModules();
+    fs.rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  it('returns zero counts when the spool file is missing', () => {
+    const result = processSpool(projectDir);
+
+    expect(result).toEqual({
+      processed: 0,
+      skipped: 0,
+      warnings: [],
+    });
+  });
+
+  it('writes team decisions, team gotchas, and personal sessions to their target directories', () => {
+    writeSpool(projectDir, [
+      JSON.stringify({
+        provider: 'codex',
+        source: 'stdout',
+        taskName: 'Build auth module',
+        timestamp: '2026-03-28T12:34:56.000Z',
+        text: [
+          'We decided to use Postgres for auth state.',
+          "Don't use synchronous fs calls in request handlers.",
+          'I prefer terminal-first workflows for debugging.',
+        ].join(' '),
+      }),
+    ]);
+
+    const result = processSpool(projectDir);
+
+    expect(result).toEqual({
+      processed: 1,
+      skipped: 0,
+      warnings: [],
+    });
+
+    const decisionFiles = findMarkdownFiles(projectDir, path.join('.tlc', 'memory', 'team', 'decisions'));
+    const gotchaFiles = findMarkdownFiles(projectDir, path.join('.tlc', 'memory', 'team', 'gotchas'));
+    const sessionFiles = findMarkdownFiles(projectDir, path.join('.tlc', 'memory', '.local', 'sessions'));
+
+    expect(decisionFiles).toEqual(['2026-03-28-we-decided-to-use-postgres.md']);
+    expect(gotchaFiles).toEqual(['2026-03-28-dont-use-synchronous-fs-calls.md']);
+    expect(sessionFiles).toEqual(['2026-03-28-i-prefer-terminal-first-workflows.md']);
+
+    expect(readFile(path.join(projectDir, '.tlc', 'memory', 'team', 'decisions', decisionFiles[0]))).toContain([
+      '---',
+      'provider: codex',
+      'source: stdout',
+      'timestamp: 2026-03-28T12:34:56.000Z',
+      'taskName: "Build auth module"',
+      'confidence: 0.9',
+      'type: decision',
+      'scope: team',
+      '---',
+      '',
+      'We decided to use Postgres for auth state.',
+    ].join('\n'));
+
+    expect(readFile(path.join(projectDir, '.tlc', 'memory', 'team', 'gotchas', gotchaFiles[0]))).toContain('type: gotcha');
+    expect(readFile(path.join(projectDir, '.tlc', 'memory', '.local', 'sessions', sessionFiles[0]))).toContain('scope: personal');
+    expect(readSpool(projectDir)).toBe('');
+  });
+
+  it('skips malformed JSON lines and keeps them in the spool with a warning', () => {
+    writeSpool(projectDir, [
+      '{"provider":"codex"',
+      JSON.stringify({
+        provider: 'codex',
+        source: 'stdout',
+        taskName: 'Build auth module',
+        timestamp: '2026-03-28T12:34:56.000Z',
+        text: 'We decided to use Postgres for auth state.',
+      }),
+    ]);
+
+    const result = processSpool(projectDir);
+
+    expect(result.processed).toBe(1);
+    expect(result.skipped).toBe(1);
+    expect(result.warnings).toHaveLength(1);
+    expect(result.warnings[0]).toContain('Malformed JSON');
+    expect(readSpool(projectDir)).toBe('{"provider":"codex"');
+  });
+
+  it('skips invalid envelopes and leaves them in the spool', () => {
+    writeSpool(projectDir, [
+      JSON.stringify({
+        provider: 'codex',
+        source: 'stdout',
+        taskName: 'Build auth module',
+        timestamp: '2026-03-28T12:34:56.000Z',
+      }),
+      JSON.stringify({
+        provider: 'codex',
+        source: 'stdout',
+        taskName: 'Build auth module',
+        timestamp: '2026-03-28T12:34:56.000Z',
+        text: 'We decided to use Postgres for auth state.',
+      }),
+    ]);
+
+    const result = processSpool(projectDir);
+
+    expect(result.processed).toBe(1);
+    expect(result.skipped).toBe(1);
+    expect(result.warnings).toHaveLength(1);
+    expect(result.warnings[0]).toContain('Invalid envelope');
+    expect(readSpool(projectDir)).toBe(JSON.stringify({
+      provider: 'codex',
+      source: 'stdout',
+      taskName: 'Build auth module',
+      timestamp: '2026-03-28T12:34:56.000Z',
+    }));
+  });
+
+  it('treats valid envelopes with no extracted statements as processed and removes them from the spool', () => {
+    writeSpool(projectDir, [
+      JSON.stringify({
+        provider: 'codex',
+        source: 'stdout',
+        taskName: 'Build auth module',
+        timestamp: '2026-03-28T12:34:56.000Z',
+        text: 'The server responded in 120ms and all tests passed.',
+      }),
+    ]);
+
+    const result = processSpool(projectDir);
+
+    expect(result).toEqual({
+      processed: 1,
+      skipped: 0,
+      warnings: [],
+    });
+    expect(findMarkdownFiles(projectDir, path.join('.tlc', 'memory', 'team', 'decisions'))).toEqual([]);
+    expect(findMarkdownFiles(projectDir, path.join('.tlc', 'memory', 'team', 'gotchas'))).toEqual([]);
+    expect(findMarkdownFiles(projectDir, path.join('.tlc', 'memory', '.local', 'sessions'))).toEqual([]);
+    expect(readSpool(projectDir)).toBe('');
+  });
+
+  it('redacts secrets before extraction and writing files', () => {
+    writeSpool(projectDir, [
+      JSON.stringify({
+        provider: 'codex',
+        source: 'stdout',
+        taskName: 'Build auth module',
+        timestamp: '2026-03-28T12:34:56.000Z',
+        text: 'We decided to store token=abc123secret in env docs.',
+      }),
+    ]);
+
+    processSpool(projectDir);
+
+    const [decisionFile] = findMarkdownFiles(projectDir, path.join('.tlc', 'memory', 'team', 'decisions'));
+    const content = readFile(path.join(projectDir, '.tlc', 'memory', 'team', 'decisions', decisionFile));
+
+    expect(content).toContain('We decided to store token=[TOKEN_REDACTED] in env docs.');
+    expect(content).not.toContain('abc123secret');
+  });
+
+  it('truncates slugs to 40 characters and uses the timestamp date prefix', () => {
+    writeSpool(projectDir, [
+      JSON.stringify({
+        provider: 'codex',
+        source: 'stdout',
+        taskName: 'Build auth module',
+        timestamp: '2026-03-29T00:00:01.000Z',
+        text: 'We decided to use extremely descriptive boundary names across packages for clarity.',
+      }),
+    ]);
+
+    processSpool(projectDir);
+
+    const decisionFiles = findMarkdownFiles(projectDir, path.join('.tlc', 'memory', 'team', 'decisions'));
+
+    expect(decisionFiles).toEqual(['2026-03-29-we-decided-to-use-extremely.md']);
+  });
+
+  it('preserves skipped lines in order after processing other entries', () => {
+    const invalidLine = '{"provider":';
+    const validDecision = JSON.stringify({
+      provider: 'codex',
+      source: 'stdout',
+      taskName: 'Build auth module',
+      timestamp: '2026-03-28T12:34:56.000Z',
+      text: 'We decided to use Postgres for auth state.',
+    });
+    const invalidEnvelope = JSON.stringify({
+      provider: 'codex',
+      source: 'stdout',
+      taskName: 'Build auth module',
+      timestamp: '2026-03-28T12:34:56.000Z',
+    });
+
+    writeSpool(projectDir, [invalidLine, validDecision, invalidEnvelope]);
+
+    const result = processSpool(projectDir);
+
+    expect(result.processed).toBe(1);
+    expect(result.skipped).toBe(2);
+    expect(readSpool(projectDir)).toBe([invalidLine, invalidEnvelope].join('\n'));
+  });
+
+  it('supports injected fs implementations', () => {
+    writeSpool(projectDir, [
+      JSON.stringify({
+        provider: 'codex',
+        source: 'stdout',
+        taskName: 'Build auth module',
+        timestamp: '2026-03-28T12:34:56.000Z',
+        text: 'We decided to use Postgres for auth state.',
+      }),
+    ]);
+
+    const injectedFs = {
+      ...fs,
+      existsSync: vi.fn(fs.existsSync),
+      mkdirSync: vi.fn(fs.mkdirSync),
+      readFileSync: vi.fn(fs.readFileSync),
+      writeFileSync: vi.fn(fs.writeFileSync),
+    };
+
+    const result = processSpool(projectDir, { fs: injectedFs });
+
+    expect(result.processed).toBe(1);
+    expect(injectedFs.readFileSync).toHaveBeenCalled();
+    expect(injectedFs.writeFileSync).toHaveBeenCalled();
+  });
+});