tlc-claude-code 2.4.2 → 2.4.4

package/.claude/hooks/tlc-capture-exchange.sh

@@ -15,35 +15,64 @@ INPUT=$(cat)
 # Quick exit if no input
 [ -z "$INPUT" ] && exit 0
 
-# Use the capture-bridge Node.js module for reliable processing
 PROJECT_DIR="${CLAUDE_PROJECT_DIR:-$(pwd)}"
-BRIDGE_SCRIPT="$PROJECT_DIR/server/lib/capture-bridge.js"
+CAPTURE_MOD=""
+if node -e "require('tlc-claude-code/server/lib/capture/claude-capture')" 2>/dev/null; then
+  CAPTURE_MOD="tlc-claude-code/server/lib/capture/claude-capture"
+elif [ -f "$PROJECT_DIR/server/lib/capture/claude-capture.js" ]; then
+  CAPTURE_MOD="$PROJECT_DIR/server/lib/capture/claude-capture"
+fi
+
+if [ -n "$CAPTURE_MOD" ]; then
+  # Resolve spool processor for same-session drain
+  SPOOL_MOD=""
+  if node -e "require('tlc-claude-code/server/lib/capture/spool-processor')" 2>/dev/null; then
+    SPOOL_MOD="tlc-claude-code/server/lib/capture/spool-processor"
+  elif [ -f "$PROJECT_DIR/server/lib/capture/spool-processor.js" ]; then
+    SPOOL_MOD="$PROJECT_DIR/server/lib/capture/spool-processor"
+  fi
 
-if [ -f "$BRIDGE_SCRIPT" ]; then
   echo "$INPUT" | node -e "
-    const bridge = require('$BRIDGE_SCRIPT');
+    const { captureClaudeExchange } = require('$CAPTURE_MOD');
     let input = '';
     process.stdin.on('data', d => input += d);
     process.stdin.on('end', async () => {
-      const parsed = bridge.parseStopHookInput(input);
-      if (!parsed || !parsed.assistantMessage) process.exit(0);
-
-      const userMessage = parsed.transcriptPath
-        ? bridge.extractLastUserMessage(parsed.transcriptPath)
-        : null;
-
-      await bridge.captureExchange({
-        cwd: parsed.cwd || '$PROJECT_DIR',
-        assistantMessage: parsed.assistantMessage,
-        userMessage,
-        sessionId: parsed.sessionId,
-      });
-
-      const path = require('path');
-      const spoolDir = path.join(parsed.cwd || '$PROJECT_DIR', '.tlc', 'memory');
-      await bridge.drainSpool(spoolDir);
+      captureClaudeExchange({ hookInput: input, projectDir: '$PROJECT_DIR' });
+      // Drain spool so memories are available same-session
+      try {
+        const { processSpool } = require('$SPOOL_MOD');
+        await processSpool('$PROJECT_DIR');
+      } catch {}
     });
   " 2>/dev/null
+else
+  BRIDGE_SCRIPT="$PROJECT_DIR/server/lib/capture-bridge.js"
+  if [ -f "$BRIDGE_SCRIPT" ]; then
+    echo "$INPUT" | node -e "
+      const bridge = require('$BRIDGE_SCRIPT');
+      let input = '';
+      process.stdin.on('data', d => input += d);
+      process.stdin.on('end', async () => {
+        const parsed = bridge.parseStopHookInput(input);
+        if (!parsed || !parsed.assistantMessage) process.exit(0);
+
+        const userMessage = parsed.transcriptPath
+          ? bridge.extractLastUserMessage(parsed.transcriptPath)
+          : null;
+
+        await bridge.captureExchange({
+          cwd: parsed.cwd || '$PROJECT_DIR',
+          assistantMessage: parsed.assistantMessage,
+          userMessage,
+          sessionId: parsed.sessionId,
+        });
+
+        const path = require('path');
+        const spoolDir = path.join(parsed.cwd || '$PROJECT_DIR', '.tlc', 'memory');
+        await bridge.drainSpool(spoolDir);
+      });
+    " 2>/dev/null
+  fi
 fi
 
 # Always exit 0 - never block Claude

package/.claude/hooks/tlc-session-init.sh

@@ -43,6 +43,23 @@ else
   done
 fi
 
+# ─── Memory System Init ─────────────────────────────
+mkdir -p "$PROJECT_DIR/.tlc/memory/team/decisions" \
+         "$PROJECT_DIR/.tlc/memory/team/gotchas" \
+         "$PROJECT_DIR/.tlc/memory/.local/sessions"
+
+# ─── Spool Drain ─────────────────────────────────────
+# Try to drain any pending spool entries from previous sessions
+SPOOL_DRAIN=""
+if node -e "require('tlc-claude-code/server/lib/capture/spool-processor')" 2>/dev/null; then
+  SPOOL_DRAIN="require('tlc-claude-code/server/lib/capture/spool-processor').processSpool('$PROJECT_DIR')"
+elif [ -f "$PROJECT_DIR/server/lib/capture/spool-processor.js" ]; then
+  SPOOL_DRAIN="require('$PROJECT_DIR/server/lib/capture/spool-processor').processSpool('$PROJECT_DIR')"
+fi
+if [ -n "$SPOOL_DRAIN" ]; then
+  node -e "$SPOOL_DRAIN" 2>/dev/null
+fi
+
 # ─── LLM Router: Probe Providers ─────────────────────────
 #
 # Writes .tlc/.router-state.json with provider availability.
@@ -132,3 +149,16 @@ else
     echo "LLM Router: ${COUNT} providers available (cached). State at .tlc/.router-state.json."
   fi
 fi
+
+# ─── Health Check (runs AFTER router probe so provider state is fresh) ───
+HEALTH_MOD=""
+if node -e "require('tlc-claude-code/server/lib/health-check')" 2>/dev/null; then
+  HEALTH_MOD="tlc-claude-code/server/lib/health-check"
+elif [ -f "$PROJECT_DIR/server/lib/health-check.js" ]; then
+  HEALTH_MOD="$PROJECT_DIR/server/lib/health-check"
+fi
+if [ -n "$HEALTH_MOD" ]; then
+  node -e "require('$HEALTH_MOD').runHealthChecks('$PROJECT_DIR').then(r => r.warnings.forEach(w => console.error(w)))" 2>/dev/null
+fi
+
+exit 0

package/CLAUDE.md

@@ -4,11 +4,12 @@
 
 ## Rules (Enforced by hooks — violations are blocked)
 
-1. **Tests before code.** Always. Red → Green → Refactor. Use `/tlc:build`.
-2. **Plans go in files.** Use `/tlc:plan` → writes to `.planning/phases/`. Never plan in chat.
-3. **No direct implementation.** User says "build X" → run `/tlc:progress` then `/tlc:build`.
-4. **No Co-Authored-By in commits.** The user is the author. Claude is a tool.
-5. **Ask before `git push`.** Never push without explicit approval.
+1. **Never commit to main.** Always create `phase/{N}` branch. PR back to main when done.
+2. **Tests before code.** Always. Red → Green → Refactor. Use `/tlc:build`.
+3. **Plans go in files.** Use `/tlc:plan` → writes to `.planning/phases/`. Never plan in chat.
+4. **No direct implementation.** User says "build X" → run `/tlc:progress` then `/tlc:build`.
+5. **No Co-Authored-By in commits.** The user is the author. Claude is a tool.
+6. **Ask before `git push`.** Never push without explicit approval.
 
 ## Command Dispatch
 

package/bin/init.js

@@ -9,6 +9,7 @@ const fs = require('fs');
 const path = require('path');
 
 const projectDir = process.cwd();
+const TLC_GITIGNORE_BLOCK = '.tlc/*\n!.tlc/memory/\n.tlc/memory/.local/\n';
 
 // Windows batch file content
 const batContent = `@echo off
@@ -217,8 +218,16 @@ if (fs.existsSync(gitignorePath)) {
         gitignore += '\n# TLC dev server (local only)\ntlc-start.*\n';
         updated = true;
     }
-    if (!gitignore.includes('.tlc/')) {
-        gitignore += '.tlc/\n';
+    // Remove legacy ".tlc/" ignore that blocks team memory in upgraded repos
+    if (gitignore.includes('.tlc/') && !gitignore.includes('.tlc/*')) {
+        gitignore = gitignore.replace(/^\.tlc\/\s*$/gm, '');
+        updated = true;
+    }
+    if (!gitignore.includes('.tlc/*') || !gitignore.includes('!.tlc/memory/') || !gitignore.includes('.tlc/memory/.local/')) {
+        if (!gitignore.endsWith('\n')) {
+            gitignore += '\n';
+        }
+        gitignore += TLC_GITIGNORE_BLOCK;
         updated = true;
     }
     if (updated) {
@@ -226,7 +235,7 @@ if (fs.existsSync(gitignorePath)) {
         console.log('[TLC] Updated .gitignore');
     }
 } else {
-    fs.writeFileSync(gitignorePath, '# TLC dev server (local only)\ntlc-start.*\n.tlc/\n');
+    fs.writeFileSync(gitignorePath, '# TLC dev server (local only)\ntlc-start.*\n' + TLC_GITIGNORE_BLOCK);
     console.log('[TLC] Created .gitignore');
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tlc-claude-code",
-  "version": "2.4.2",
+  "version": "2.4.4",
   "description": "TLC - Test Led Coding for Claude Code",
   "bin": {
     "tlc-claude-code": "./bin/install.js",
@@ -34,11 +34,14 @@
     "postinstall": "node bin/postinstall.js",
     "build": "cd dashboard && npm run build",
     "build:web": "cd dashboard-web && npm install && npm run build",
+    "preversion": "node scripts/version-sync.js && git diff --quiet || (echo 'Working tree not clean' && exit 1)",
+    "version": "node scripts/version-sync.js && git add .tlc.json",
     "prepublishOnly": "npm run build && npm run build:web",
     "docs": "node scripts/docs-update.js",
     "docs:check": "node scripts/docs-update.js --check",
     "docs:screenshots": "node scripts/generate-screenshots.js",
     "docs:capture": "node scripts/capture-screenshots.js",
+    "test:version-sync": "cd server && npx vitest run --dir .. scripts/version-sync.test.js",
     "test:e2e": "npx playwright test",
     "test:e2e:ui": "npx playwright test --ui"
   },

package/scripts/dev-link.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+set -u
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)"
+
+cd "${REPO_ROOT}" || {
+  echo "Error: failed to change to repo root: ${REPO_ROOT}" >&2
+  exit 1
+}
+
+if ! npm link; then
+  echo "Error: npm link failed" >&2
+  exit 1
+fi
+
+LINK_PATH="$(command -v tlc-claude-code || true)"
+
+if [ -z "${LINK_PATH}" ]; then
+  echo "Error: tlc-claude-code was not found on PATH after npm link" >&2
+  exit 1
+fi
+
+echo "Local link created successfully."
+echo "Use it from another project with:"
+echo "  npm link tlc-claude-code"
+echo "Resolved binary:"
+echo "  ${LINK_PATH}"

package/scripts/test-package.sh

@@ -0,0 +1,54 @@
+#!/bin/bash
+
+set -u
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)"
+TMP_DIR=""
+TARBALL_PATH=""
+NPM_CACHE_DIR=""
+
+cleanup() {
+  if [ -n "${TMP_DIR}" ] && [ -d "${TMP_DIR}" ]; then
+    rm -rf "${TMP_DIR}"
+  fi
+
+  if [ -n "${TARBALL_PATH}" ] && [ -f "${TARBALL_PATH}" ]; then
+    rm -f "${TARBALL_PATH}"
+  fi
+}
+
+fail() {
+  echo "Error: $1" >&2
+  exit 1
+}
+
+trap cleanup EXIT
+
+TMP_DIR="$(mktemp -d 2>/dev/null || mktemp -d -t tlc-test-package)" || fail "failed to create temporary directory"
+NPM_CACHE_DIR="${TMP_DIR}/npm-cache"
+mkdir -p "${NPM_CACHE_DIR}" || fail "failed to create npm cache directory"
+
+cd "${REPO_ROOT}" || fail "failed to change to repo root: ${REPO_ROOT}"
+
+PACK_OUTPUT="$(npm_config_cache="${NPM_CACHE_DIR}" npm pack --json 2>&1)" || fail "npm pack failed: ${PACK_OUTPUT}"
+TARBALL_NAME="$(printf '%s\n' "${PACK_OUTPUT}" | node -e "let input=''; process.stdin.on('data', (chunk) => input += chunk); process.stdin.on('end', () => { const start = input.indexOf('['); if (start === -1) { process.exit(1); } const data = JSON.parse(input.slice(start)); if (!Array.isArray(data) || !data[0] || !data[0].filename) { process.exit(1); } process.stdout.write(data[0].filename); });")" || fail "failed to parse npm pack output"
+
+[ -n "${TARBALL_NAME}" ] || fail "npm pack did not return a tarball name"
+
+TARBALL_PATH="${REPO_ROOT}/${TARBALL_NAME}"
+[ -f "${TARBALL_PATH}" ] || fail "tarball was not created: ${TARBALL_PATH}"
+
+cd "${TMP_DIR}" || fail "failed to change to temp directory: ${TMP_DIR}"
+
+npm_config_cache="${NPM_CACHE_DIR}" npm install "${TARBALL_PATH}" >/dev/null 2>&1 || fail "npm install failed for ${TARBALL_NAME}"
+
+PACKAGE_FILE="${TMP_DIR}/node_modules/tlc-claude-code/server/lib/routing-preamble.js"
+[ -f "${PACKAGE_FILE}" ] || fail "installed package is missing server/lib/routing-preamble.js"
+
+OUTPUT="$(node -e "const {generatePreamble} = require('tlc-claude-code/server/lib/routing-preamble'); const p = generatePreamble('build'); console.log(p.substring(0,20))" 2>&1)" || fail "routing preamble validation failed: ${OUTPUT}"
+
+[ -n "${OUTPUT}" ] || fail "routing preamble validation produced no output"
+
+echo "Package test passed."
+exit 0

package/scripts/version-sync.js

@@ -0,0 +1,42 @@
+const fs = require('fs');
+const path = require('path');
+
+function syncVersion(rootDir = path.resolve(__dirname, '..')) {
+  const packageJsonPath = path.join(rootDir, 'package.json');
+  const tlcConfigPath = path.join(rootDir, '.tlc.json');
+
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+
+  if (typeof packageJson.version !== 'string' || packageJson.version.trim() === '') {
+    throw new Error('package.json is missing a valid version field');
+  }
+
+  let tlcConfig = {};
+
+  if (fs.existsSync(tlcConfigPath)) {
+    tlcConfig = JSON.parse(fs.readFileSync(tlcConfigPath, 'utf8'));
+  }
+
+  tlcConfig.version = packageJson.version;
+  tlcConfig.tlcVersion = packageJson.version;
+
+  fs.writeFileSync(tlcConfigPath, `${JSON.stringify(tlcConfig, null, 2)}\n`);
+}
+
+function main() {
+  try {
+    syncVersion();
+    process.exit(0);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  syncVersion,
+};

package/scripts/version-sync.test.js

@@ -0,0 +1,100 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+import { afterEach, describe, expect, it } from 'vitest';
+
+import versionSyncModule from './version-sync.js';
+
+const { syncVersion } = versionSyncModule;
+
+const tempDirs = [];
+
+function createTempProject(packageVersion, tlcConfig) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'version-sync-'));
+  tempDirs.push(tempDir);
+
+  fs.writeFileSync(
+    path.join(tempDir, 'package.json'),
+    `${JSON.stringify({ version: packageVersion }, null, 2)}\n`
+  );
+
+  if (tlcConfig !== undefined) {
+    fs.writeFileSync(
+      path.join(tempDir, '.tlc.json'),
+      `${JSON.stringify(tlcConfig, null, 2)}\n`
+    );
+  }
+
+  return tempDir;
+}
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+afterEach(() => {
+  while (tempDirs.length > 0) {
+    fs.rmSync(tempDirs.pop(), { recursive: true, force: true });
+  }
+});
+
+describe('syncVersion', () => {
+  it('reads version from package.json correctly', () => {
+    const tempDir = createTempProject('1.2.3', { existing: true });
+
+    syncVersion(tempDir);
+
+    const tlcConfig = readJson(path.join(tempDir, '.tlc.json'));
+    expect(tlcConfig.version).toBe('1.2.3');
+  });
+
+  it('writes to .tlc.json version field', () => {
+    const tempDir = createTempProject('2.3.4', {});
+
+    syncVersion(tempDir);
+
+    const tlcConfig = readJson(path.join(tempDir, '.tlc.json'));
+    expect(tlcConfig.version).toBe('2.3.4');
+  });
+
+  it('writes to .tlc.json tlcVersion field', () => {
+    const tempDir = createTempProject('3.4.5', {});
+
+    syncVersion(tempDir);
+
+    const tlcConfig = readJson(path.join(tempDir, '.tlc.json'));
+    expect(tlcConfig.tlcVersion).toBe('3.4.5');
+  });
+
+  it('handles missing .tlc.json gracefully', () => {
+    const tempDir = createTempProject('4.5.6');
+
+    expect(() => syncVersion(tempDir)).not.toThrow();
+
+    const tlcConfig = readJson(path.join(tempDir, '.tlc.json'));
+    expect(tlcConfig).toEqual({
+      version: '4.5.6',
+      tlcVersion: '4.5.6',
+    });
+  });
+
+  it('does not overwrite other .tlc.json fields', () => {
+    const tempDir = createTempProject('5.6.7', {
+      project: 'TLC',
+      nested: { keep: true },
+      version: 'old',
+      tlcVersion: 'old',
+    });
+
+    syncVersion(tempDir);
+
+    const tlcConfig = readJson(path.join(tempDir, '.tlc.json'));
+    expect(tlcConfig).toEqual({
+      project: 'TLC',
+      nested: { keep: true },
+      version: '5.6.7',
+      tlcVersion: '5.6.7',
+    });
+  });
+});

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