tlc-claude-code 2.4.3 → 2.4.5

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

@@ -0,0 +1,92 @@
+import { describe, it, expect } from 'vitest';
+
+const { extractDecisions } = require('./extractor.js');
+
+describe('capture/extractor', () => {
+  it('extracts a decision statement from explicit decision language', () => {
+    const results = extractDecisions('We decided to use Postgres for the event store.');
+
+    expect(results).toHaveLength(1);
+    expect(results[0]).toMatchObject({
+      statement: 'We decided to use Postgres for the event store.',
+      context: 'We decided to use Postgres for the event store.',
+      role: 'unknown',
+    });
+    expect(results[0].confidence).toBeGreaterThan(0);
+  });
+
+  it('boosts confidence by 1.5x for assistant role', () => {
+    const text = 'We decided to use Postgres.';
+
+    const base = extractDecisions(text)[0];
+    const boosted = extractDecisions(text, { role: 'assistant' })[0];
+
+    expect(boosted.confidence).toBeCloseTo(base.confidence * 1.5, 5);
+    expect(boosted.role).toBe('assistant');
+  });
+
+  it('extracts gotchas from warning phrases', () => {
+    const results = extractDecisions("Don't use synchronous fs calls in request handlers.");
+
+    expect(results).toHaveLength(1);
+    expect(results[0].statement).toBe("Don't use synchronous fs calls in request handlers.");
+    expect(results[0].context).toBe("Don't use synchronous fs calls in request handlers.");
+  });
+
+  it('extracts preferences from personal preference phrases', () => {
+    const results = extractDecisions('I prefer dark theme for late-night debugging.');
+
+    expect(results).toHaveLength(1);
+    expect(results[0].statement).toBe('I prefer dark theme for late-night debugging.');
+  });
+
+  it('returns an empty array when no phrases match', () => {
+    expect(extractDecisions('The server responded in 120ms and all tests passed.')).toEqual([]);
+  });
+
+  it('dedupes repeated statements with the same text', () => {
+    const text = 'We decided to use Postgres. We decided to use Postgres.';
+
+    const results = extractDecisions(text);
+
+    expect(results).toHaveLength(1);
+    expect(results[0].statement).toBe('We decided to use Postgres.');
+  });
+
+  it('extracts the containing sentence as context from multi-sentence input', () => {
+    const text = 'We reviewed the tradeoffs. The approach is to split into worker and api modules. Shipping stays on Friday.';
+
+    const results = extractDecisions(text);
+
+    expect(results).toHaveLength(1);
+    expect(results[0].statement).toBe('The approach is to split into worker and api modules.');
+    expect(results[0].context).toBe('The approach is to split into worker and api modules.');
+  });
+
+  it('extracts multiple unique matches across decision, gotcha, and preference sentences', () => {
+    const text = [
+      'We decided to use Postgres.',
+      'Careful with long transactions on SQLite.',
+      'I like terminal-first workflows.',
+    ].join(' ');
+
+    const results = extractDecisions(text);
+
+    expect(results).toHaveLength(3);
+    expect(results.map((entry) => entry.statement)).toEqual([
+      'We decided to use Postgres.',
+      'Careful with long transactions on SQLite.',
+      'I like terminal-first workflows.',
+    ]);
+  });
+
+  it('captures code-change style decision phrases such as created and implemented', () => {
+    const text = 'Created 3 modules for auth boundaries. Implemented request tracing for retries.';
+
+    const results = extractDecisions(text);
+
+    expect(results).toHaveLength(2);
+    expect(results[0].statement).toBe('Created 3 modules for auth boundaries.');
+    expect(results[1].statement).toBe('Implemented request tracing for retries.');
+  });
+});

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

@@ -0,0 +1,96 @@
+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 appendEnvelope(projectDir, envelope, fs) {
+  ensureMemoryReady(projectDir, { fs });
+
+  const spoolPath = path.join(projectDir, SPOOL_PATH);
+  fs.appendFileSync(spoolPath, `${JSON.stringify(envelope)}\n`, 'utf8');
+}
+
+function createRedactedEnvelope({ text, provider, source, taskName }) {
+  const envelope = createEnvelope({
+    provider,
+    source,
+    taskName,
+    assistantMessage: text,
+  });
+  const redactedText = redact(envelope.text);
+
+  return {
+    ...envelope,
+    text: redactedText,
+    metadata: {
+      ...envelope.metadata,
+      assistantMessage: redact(envelope.metadata.assistantMessage || ''),
+    },
+  };
+}
+
+function captureFromStdout({
+  stdout,
+  provider,
+  taskName,
+  projectDir,
+  fs = require('fs'),
+}) {
+  try {
+    const envelope = createRedactedEnvelope({
+      text: stdout,
+      provider,
+      source: 'stdout',
+      taskName,
+    });
+
+    appendEnvelope(projectDir, envelope, fs);
+
+    return { captured: 1, skipped: 0 };
+  } catch (_) {
+    return { captured: 0, skipped: 1 };
+  }
+}
+
+function extractResponseText(response) {
+  if (typeof response?.content === 'string') {
+    return response.content;
+  }
+
+  if (typeof response?.choices?.[0]?.message?.content === 'string') {
+    return response.choices[0].message.content;
+  }
+
+  return JSON.stringify(response);
+}
+
+function captureFromApiResponse({
+  response,
+  provider,
+  taskName,
+  projectDir,
+  fs = require('fs'),
+}) {
+  try {
+    const envelope = createRedactedEnvelope({
+      text: extractResponseText(response),
+      provider,
+      source: 'api-response',
+      taskName,
+    });
+
+    appendEnvelope(projectDir, envelope, fs);
+
+    return { captured: 1, skipped: 0 };
+  } catch (_) {
+    return { captured: 0, skipped: 1 };
+  }
+}
+
+module.exports = {
+  captureFromStdout,
+  captureFromApiResponse,
+};

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

@@ -0,0 +1,171 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+const SPOOL_PATH = path.join('.tlc', 'memory', '.spool.jsonl');
+
+function readSpoolEntries(projectDir) {
+  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));
+}
+
+describe('capture/generic-capture', () => {
+  let projectDir;
+  let captureFromStdout;
+  let captureFromApiResponse;
+
+  beforeEach(async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2026-03-28T12:34:56.000Z'));
+    projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tlc-generic-capture-'));
+    ({ captureFromStdout, captureFromApiResponse } = await import('./generic-capture.js'));
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.resetModules();
+    fs.rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  it('captures stdout into a redacted envelope', () => {
+    const result = captureFromStdout({
+      stdout: 'token=abc123 password=hunter2 /Users/jurgen/private/app.js',
+      provider: 'gemini',
+      taskName: 'Implement auth',
+      projectDir,
+    });
+
+    const [entry] = readSpoolEntries(projectDir);
+
+    expect(result).toEqual({ captured: 1, skipped: 0 });
+    expect(entry).toMatchObject({
+      provider: 'gemini',
+      source: 'stdout',
+      taskName: 'Implement auth',
+      timestamp: '2026-03-28T12:34:56.000Z',
+      metadata: {
+        assistantMessage: 'token=[TOKEN_REDACTED] password=[REDACTED] ~/private/app.js',
+      },
+    });
+    expect(entry.text).toBe('token=[TOKEN_REDACTED] password=[REDACTED] ~/private/app.js');
+  });
+
+  it('returns skipped when stdout is empty', () => {
+    const result = captureFromStdout({
+      stdout: '   ',
+      provider: 'gemini',
+      taskName: 'Implement auth',
+      projectDir,
+    });
+
+    expect(result).toEqual({ captured: 0, skipped: 1 });
+    expect(fs.existsSync(path.join(projectDir, SPOOL_PATH))).toBe(false);
+  });
+
+  it('appends to an existing spool file', () => {
+    const spoolPath = path.join(projectDir, SPOOL_PATH);
+    fs.mkdirSync(path.dirname(spoolPath), { recursive: true });
+    fs.writeFileSync(spoolPath, `${JSON.stringify({ existing: true })}\n`);
+
+    captureFromStdout({
+      stdout: 'We decided to use SQLite for local state.',
+      provider: 'openrouter',
+      taskName: 'State storage',
+      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: 'openrouter',
+      source: 'stdout',
+    });
+  });
+
+  it('captures api response content when present', () => {
+    const result = captureFromApiResponse({
+      response: {
+        content: 'secret=hunter2\nWe decided to use retries.',
+      },
+      provider: 'gemini',
+      taskName: 'Retry policy',
+      projectDir,
+    });
+
+    const [entry] = readSpoolEntries(projectDir);
+
+    expect(result).toEqual({ captured: 1, skipped: 0 });
+    expect(entry.source).toBe('api-response');
+    expect(entry.text).toContain('[REDACTED]');
+    expect(entry.text).toContain('We decided to use retries.');
+    expect(entry.text).not.toContain('hunter2');
+  });
+
+  it('falls back to choices[0].message.content for api responses', () => {
+    captureFromApiResponse({
+      response: {
+        choices: [
+          {
+            message: {
+              content: 'Use Redis for rate limits.',
+            },
+          },
+        ],
+      },
+      provider: 'openai',
+      taskName: 'Rate limits',
+      projectDir,
+    });
+
+    const [entry] = readSpoolEntries(projectDir);
+
+    expect(entry.text).toBe('Use Redis for rate limits.');
+    expect(entry.metadata.assistantMessage).toBe('Use Redis for rate limits.');
+  });
+
+  it('falls back to JSON stringification when api response has no direct text field', () => {
+    captureFromApiResponse({
+      response: {
+        status: 'ok',
+        data: {
+          message: 'We decided to shard by tenant.',
+        },
+      },
+      provider: 'anthropic-proxy',
+      taskName: 'Sharding',
+      projectDir,
+    });
+
+    const [entry] = readSpoolEntries(projectDir);
+
+    expect(entry.text).toContain('"status":"ok"');
+    expect(entry.text).toContain('"message":"We decided to shard by tenant."');
+  });
+
+  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 = captureFromApiResponse({
+      response: { content: 'Use a queue for webhooks.' },
+      provider: 'gemini',
+      taskName: 'Webhook delivery',
+      projectDir,
+      fs: injectedFs,
+    });
+
+    expect(result).toEqual({ captured: 1, skipped: 0 });
+    expect(injectedFs.appendFileSync).toHaveBeenCalledTimes(1);
+  });
+});

package/server/lib/capture/index.js

@@ -0,0 +1,117 @@
+const path = require('path');
+
+const { captureFromStdout, captureFromApiResponse } = require('./generic-capture');
+
+const zeroCaptureCounts = new Map();
+let warningCount = 0;
+const MAX_WARNINGS_PER_SESSION = 3;
+const WARNING_LOG_PATH = path.join('.tlc', 'memory', '.capture-warnings.log');
+
+function warningsEnabled() {
+  return process.env.TLC_CAPTURE_WARNINGS !== 'false';
+}
+
+function maybeWarn(projectDir, fs, message) {
+  if (!warningsEnabled() || warningCount >= MAX_WARNINGS_PER_SESSION) {
+    return;
+  }
+
+  warningCount += 1;
+  console.warn(message);
+
+  if (!projectDir) {
+    return;
+  }
+
+  try {
+    const logPath = path.join(projectDir, WARNING_LOG_PATH);
+    fs.mkdirSync(path.dirname(logPath), { recursive: true });
+    fs.appendFileSync(logPath, `${new Date().toISOString()} ${message}\n`, 'utf8');
+  } catch (_) {
+    // Warning emission must not break capture routing.
+  }
+}
+
+function maybeEmitWarning({ provider, output, taskName, projectDir, result, fs }) {
+  if (result && result.captured > 0) {
+    zeroCaptureCounts.set(provider, 0);
+    return;
+  }
+
+  const nextCount = (zeroCaptureCounts.get(provider) || 0) + 1;
+  zeroCaptureCounts.set(provider, nextCount);
+
+  if (typeof output !== 'string' || output.length <= 500) {
+    return;
+  }
+
+  if (nextCount >= 3) {
+    maybeWarn(
+      projectDir,
+      fs,
+      `[TLC WARNING] ${provider} has produced 0 memory captures for ${nextCount} consecutive tasks. Check capture configuration.`,
+    );
+    return;
+  }
+
+  maybeWarn(
+    projectDir,
+    fs,
+    `[TLC WARNING] No decisions captured from ${provider} for task "${taskName}". Memory capture may not be working for this provider.`,
+  );
+}
+
+function captureFromProvider({
+  provider,
+  output,
+  taskName,
+  threadId,
+  projectDir,
+  hookInput,
+  lastMessageFile,
+  jsonStream,
+  fs = require('fs'),
+}) {
+  let result;
+
+  if (provider === 'claude') {
+    const { captureClaudeExchange } = require('./claude-capture');
+    result = captureClaudeExchange({ hookInput, projectDir, fs });
+  } else if (provider === 'codex') {
+    const { captureCodexOutput } = require('./codex-capture');
+    result = captureCodexOutput({
+      lastMessageFile,
+      jsonStream,
+      stdout: output,
+      taskName,
+      threadId,
+      projectDir,
+      fs,
+    });
+  } else {
+    result = captureFromStdout({
+      stdout: output,
+      provider,
+      taskName,
+      projectDir,
+      fs,
+    });
+  }
+
+  maybeEmitWarning({
+    provider,
+    output,
+    taskName,
+    projectDir,
+    result,
+    fs,
+  });
+
+  return result;
+}
+
+module.exports = {
+  captureFromProvider,
+  captureFromStdout,
+  captureFromApiResponse,
+};