Skip to content

armgit / ECC

Public Imported from GitHub
0

The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.

perf(hooks): eliminate npx overhead and merge biome invocations

Jonghyeok Parke5d02000c3d6
diff --git a/scripts/hooks/post-edit-format.js b/scripts/hooks/post-edit-format.js
index 08afad095..89643830c 100644
--- a/scripts/hooks/post-edit-format.js
+++ b/scripts/hooks/post-edit-format.js
@@ -7,159 +7,59 @@
* Runs after Edit tool use. If the edited file is a JS/TS file,
* auto-detects the project formatter (Biome or Prettier) by looking
* for config files, then formats accordingly.
+ *
+ * For Biome, uses `check --write` (format + lint in one pass) to
+ * avoid a redundant second invocation from quality-gate.js.
+ *
+ * Prefers the local node_modules/.bin binary over npx to skip
+ * package-resolution overhead (~200-500ms savings per invocation).
+ *
* Fails silently if no formatter is found or installed.
*/
-const { execFileSync, spawnSync } = require('child_process');
-const fs = require('fs');
+const { execFileSync } = require('child_process');
const path = require('path');
-const { getPackageManager } = require('../lib/package-manager');
-
-const MAX_STDIN = 1024 * 1024; // 1MB limit
-const BIOME_CONFIGS = ['biome.json', 'biome.jsonc'];
-const PRETTIER_CONFIGS = [
- '.prettierrc',
- '.prettierrc.json',
- '.prettierrc.json5',
- '.prettierrc.js',
- '.prettierrc.cjs',
- '.prettierrc.mjs',
- '.prettierrc.ts',
- '.prettierrc.cts',
- '.prettierrc.mts',
- '.prettierrc.yml',
- '.prettierrc.yaml',
- '.prettierrc.toml',
- 'prettier.config.js',
- 'prettier.config.cjs',
- 'prettier.config.mjs',
- 'prettier.config.ts',
- 'prettier.config.cts',
- 'prettier.config.mts',
-];
-const PROJECT_ROOT_MARKERS = ['package.json', ...BIOME_CONFIGS, ...PRETTIER_CONFIGS];
-let data = '';
-process.stdin.setEncoding('utf8');
-
-process.stdin.on('data', chunk => {
- if (data.length < MAX_STDIN) {
- const remaining = MAX_STDIN - data.length;
- data += chunk.substring(0, remaining);
- }
-});
-
-function findProjectRoot(startDir) {
- let dir = startDir;
- let fallbackDir = null;
-
- while (true) {
- if (detectFormatter(dir)) {
- return dir;
- }
-
- if (!fallbackDir && PROJECT_ROOT_MARKERS.some(marker => fs.existsSync(path.join(dir, marker)))) {
- fallbackDir = dir;
- }
-
- const parentDir = path.dirname(dir);
- if (parentDir === dir) break;
- dir = parentDir;
- }
-
- return fallbackDir || startDir;
-}
-
-function detectFormatter(projectRoot) {
- for (const cfg of BIOME_CONFIGS) {
- if (fs.existsSync(path.join(projectRoot, cfg))) return 'biome';
- }
-
- for (const cfg of PRETTIER_CONFIGS) {
- if (fs.existsSync(path.join(projectRoot, cfg))) return 'prettier';
- }
-
- return null;
-}
-
-function getRunnerBin(bin) {
- if (process.platform !== 'win32') return bin;
- if (bin === 'npx') return 'npx.cmd';
- if (bin === 'pnpm') return 'pnpm.cmd';
- if (bin === 'yarn') return 'yarn.cmd';
- if (bin === 'bunx') return 'bunx.cmd';
- return bin;
-}
-
-function getFormatterRunner(projectRoot) {
- const pm = getPackageManager({ projectDir: projectRoot });
- const execCmd = pm?.config?.execCmd || 'npx';
- const [bin = 'npx', ...prefix] = execCmd.split(/\s+/).filter(Boolean);
-
- return {
- bin: getRunnerBin(bin),
- prefix
- };
-}
-function getFormatterCommand(formatter, filePath, projectRoot) {
- const runner = getFormatterRunner(projectRoot);
+const {
+ findProjectRoot,
+ detectFormatter,
+ resolveFormatterBin,
+} = require('../lib/resolve-formatter');
- if (formatter === 'biome') {
- return {
- bin: runner.bin,
- args: [...runner.prefix, '@biomejs/biome', 'format', '--write', filePath]
- };
- }
- if (formatter === 'prettier') {
- return {
- bin: runner.bin,
- args: [...runner.prefix, 'prettier', '--write', filePath]
- };
- }
- return null;
-}
-
-function runFormatterCommand(cmd, projectRoot) {
- if (process.platform === 'win32' && cmd.bin.endsWith('.cmd')) {
- const result = spawnSync(cmd.bin, cmd.args, {
- cwd: projectRoot,
- shell: true,
- stdio: 'pipe',
- timeout: 15000
- });
-
- if (result.error) {
- throw result.error;
- }
-
- if (typeof result.status === 'number' && result.status !== 0) {
- throw new Error(result.stderr?.toString() || `Formatter exited with status ${result.status}`);
- }
-
- return;
- }
-
- execFileSync(cmd.bin, cmd.args, {
- cwd: projectRoot,
- stdio: ['pipe', 'pipe', 'pipe'],
- timeout: 15000
- });
-}
+const MAX_STDIN = 1024 * 1024; // 1MB limit
-process.stdin.on('end', () => {
+/**
+ * Core logic — exported so run-with-flags.js can call directly
+ * without spawning a child process.
+ *
+ * @param {string} rawInput - Raw JSON string from stdin
+ * @returns {string} The original input (pass-through)
+ */
+function run(rawInput) {
try {
- const input = JSON.parse(data);
+ const input = JSON.parse(rawInput);
const filePath = input.tool_input?.file_path;
if (filePath && /\.(ts|tsx|js|jsx)$/.test(filePath)) {
try {
const projectRoot = findProjectRoot(path.dirname(path.resolve(filePath)));
const formatter = detectFormatter(projectRoot);
- const cmd = getFormatterCommand(formatter, filePath, projectRoot);
-
- if (cmd) {
- runFormatterCommand(cmd, projectRoot);
- }
+ if (!formatter) return rawInput;
+
+ const resolved = resolveFormatterBin(projectRoot, formatter);
+
+ // Biome: `check --write` = format + lint in one pass
+ // Prettier: `--write` = format only
+ const args =
+ formatter === 'biome'
+ ? [...resolved.prefix, 'check', '--write', filePath]
+ : [...resolved.prefix, '--write', filePath];
+
+ execFileSync(resolved.bin, args, {
+ cwd: projectRoot,
+ stdio: ['pipe', 'pipe', 'pipe'],
+ timeout: 15000,
+ });
} catch {
// Formatter not installed, file missing, or failed — non-blocking
}
@@ -168,6 +68,26 @@ process.stdin.on('end', () => {
// Invalid input — pass through
}
- process.stdout.write(data);
- process.exit(0);
-});
+ return rawInput;
+}
+
+// ── stdin entry point (backwards-compatible) ────────────────────
+if (require.main === module) {
+ let data = '';
+ process.stdin.setEncoding('utf8');
+
+ process.stdin.on('data', (chunk) => {
+ if (data.length < MAX_STDIN) {
+ const remaining = MAX_STDIN - data.length;
+ data += chunk.substring(0, remaining);
+ }
+ });
+
+ process.stdin.on('end', () => {
+ const result = run(data);
+ process.stdout.write(result);
+ process.exit(0);
+ });
+}
+
+module.exports = { run };
diff --git a/scripts/hooks/quality-gate.js b/scripts/hooks/quality-gate.js
index a6f180f0a..aee94b278 100755
--- a/scripts/hooks/quality-gate.js
+++ b/scripts/hooks/quality-gate.js
@@ -5,6 +5,11 @@
* Runs lightweight quality checks after file edits.
* - Targets one file when file_path is provided
* - Falls back to no-op when language/tooling is unavailable
+ *
+ * For JS/TS files with Biome, this hook is skipped because
+ * post-edit-format.js already runs `biome check --write`.
+ * This hook still handles .json/.md files for Biome, and all
+ * Prettier / Go / Python checks.
*/
'use strict';
@@ -13,10 +18,15 @@ const fs = require('fs');
const path = require('path');
const { spawnSync } = require('child_process');
+const {
+ findProjectRoot,
+ detectFormatter,
+ resolveFormatterBin,
+} = require('../lib/resolve-formatter');
+
const MAX_STDIN = 1024 * 1024;
-let raw = '';
-function run(command, args, cwd = process.cwd()) {
+function exec(command, args, cwd = process.cwd()) {
return spawnSync(command, args, {
cwd,
encoding: 'utf8',
@@ -38,31 +48,42 @@ function maybeRunQualityGate(filePath) {
const strict = String(process.env.ECC_QUALITY_GATE_STRICT || '').toLowerCase() === 'true';
if (['.ts', '.tsx', '.js', '.jsx', '.json', '.md'].includes(ext)) {
- // Prefer biome if present
- if (fs.existsSync(path.join(process.cwd(), 'biome.json')) || fs.existsSync(path.join(process.cwd(), 'biome.jsonc'))) {
- const args = ['biome', 'check', filePath];
+ const projectRoot = findProjectRoot(path.dirname(path.resolve(filePath)));
+ const formatter = detectFormatter(projectRoot);
+
+ if (formatter === 'biome') {
+ // JS/TS already handled by post-edit-format via `biome check --write`
+ if (['.ts', '.tsx', '.js', '.jsx'].includes(ext)) {
+ return;
+ }
+
+ // .json / .md — still need quality gate
+ const resolved = resolveFormatterBin(projectRoot, 'biome');
+ const args = [...resolved.prefix, 'check', filePath];
if (fix) args.push('--write');
- const result = run('npx', args);
+ const result = exec(resolved.bin, args, projectRoot);
if (result.status !== 0 && strict) {
log(`[QualityGate] Biome check failed for ${filePath}`);
}
return;
}
- // Fallback to prettier when installed
- const prettierArgs = ['prettier', '--check', filePath];
- if (fix) {
- prettierArgs[1] = '--write';
- }
- const prettier = run('npx', prettierArgs);
- if (prettier.status !== 0 && strict) {
- log(`[QualityGate] Prettier check failed for ${filePath}`);
+ if (formatter === 'prettier') {
+ const resolved = resolveFormatterBin(projectRoot, 'prettier');
+ const args = [...resolved.prefix, fix ? '--write' : '--check', filePath];
+ const result = exec(resolved.bin, args, projectRoot);
+ if (result.status !== 0 && strict) {
+ log(`[QualityGate] Prettier check failed for ${filePath}`);
+ }
+ return;
}
+
+ // No formatter configured — skip
return;
}
if (ext === '.go' && fix) {
- run('gofmt', ['-w', filePath]);
+ exec('gofmt', ['-w', filePath]);
return;
}
@@ -70,29 +91,45 @@ function maybeRunQualityGate(filePath) {
const args = ['format'];
if (!fix) args.push('--check');
args.push(filePath);
- const r = run('ruff', args);
+ const r = exec('ruff', args);
if (r.status !== 0 && strict) {
log(`[QualityGate] Ruff check failed for ${filePath}`);
}
}
}
-process.stdin.setEncoding('utf8');
-process.stdin.on('data', chunk => {
- if (raw.length < MAX_STDIN) {
- const remaining = MAX_STDIN - raw.length;
- raw += chunk.substring(0, remaining);
- }
-});
-
-process.stdin.on('end', () => {
+/**
+ * Core logic — exported so run-with-flags.js can call directly.
+ *
+ * @param {string} rawInput - Raw JSON string from stdin
+ * @returns {string} The original input (pass-through)
+ */
+function run(rawInput) {
try {
- const input = JSON.parse(raw);
+ const input = JSON.parse(rawInput);
const filePath = String(input.tool_input?.file_path || '');
maybeRunQualityGate(filePath);
} catch {
// Ignore parse errors.
}
+ return rawInput;
+}
+
+// ── stdin entry point (backwards-compatible) ────────────────────
+if (require.main === module) {
+ let raw = '';
+ process.stdin.setEncoding('utf8');
+ process.stdin.on('data', (chunk) => {
+ if (raw.length < MAX_STDIN) {
+ const remaining = MAX_STDIN - raw.length;
+ raw += chunk.substring(0, remaining);
+ }
+ });
+
+ process.stdin.on('end', () => {
+ const result = run(raw);
+ process.stdout.write(result);
+ });
+}
- process.stdout.write(raw);
-});
+module.exports = { run };
diff --git a/tests/hooks/hooks.test.js b/tests/hooks/hooks.test.js
index a5ecaaa0d..81766ea2d 100644
--- a/tests/hooks/hooks.test.js
+++ b/tests/hooks/hooks.test.js
@@ -47,8 +47,8 @@ function runScript(scriptPath, input = '', env = {}) {
let stdout = '';
let stderr = '';
- proc.stdout.on('data', data => stdout += data);
- proc.stderr.on('data', data => stderr += data);
+ proc.stdout.on('data', data => (stdout += data));
+ proc.stderr.on('data', data => (stderr += data));
if (input) {
proc.stdin.write(input);
@@ -79,10 +79,12 @@ function createCommandShim(binDir, baseName, logFile) {
fs.mkdirSync(binDir, { recursive: true });
const shimJs = path.join(binDir, `${baseName}-shim.js`);
- fs.writeFileSync(shimJs, [
- 'const fs = require(\'fs\');',
- `fs.appendFileSync(${JSON.stringify(logFile)}, JSON.stringify({ bin: ${JSON.stringify(baseName)}, args: process.argv.slice(2), cwd: process.cwd() }) + '\\n');`
- ].join('\n'));
+ fs.writeFileSync(
+ shimJs,
+ ["const fs = require('fs');", `fs.appendFileSync(${JSON.stringify(logFile)}, JSON.stringify({ bin: ${JSON.stringify(baseName)}, args: process.argv.slice(2), cwd: process.cwd() }) + '\\n');`].join(
+ '\n'
+ )
+ );
if (process.platform === 'win32') {
const shimCmd = path.join(binDir, `${baseName}.cmd`);
@@ -98,7 +100,8 @@ function createCommandShim(binDir, baseName, logFile) {
function readCommandLog(logFile) {
if (!fs.existsSync(logFile)) return [];
- return fs.readFileSync(logFile, 'utf8')
+ return fs
+ .readFileSync(logFile, 'utf8')
.split('\n')
.filter(Boolean)
.map(line => {
@@ -112,8 +115,7 @@ function readCommandLog(logFile) {
}
function withPrependedPath(binDir, env = {}) {
- const pathKey = Object.keys(process.env).find(key => key.toLowerCase() === 'path')
- || (process.platform === 'win32' ? 'Path' : 'PATH');
+ const pathKey = Object.keys(process.env).find(key => key.toLowerCase() === 'path') || (process.platform === 'win32' ? 'Path' : 'PATH');
const currentPath = process.env[pathKey] || process.env.PATH || '';
const nextPath = `${binDir}${path.delimiter}${currentPath}`;
@@ -136,1658 +138,1951 @@ async function runTests() {
// session-start.js tests
console.log('session-start.js:');
- if (await asyncTest('runs without error', async () => {
- const result = await runScript(path.join(scriptsDir, 'session-start.js'));
- assert.strictEqual(result.code, 0, `Exit code should be 0, got ${result.code}`);
- })) passed++; else failed++;
-
- if (await asyncTest('outputs session info to stderr', async () => {
- const result = await runScript(path.join(scriptsDir, 'session-start.js'));
- assert.ok(
- result.stderr.includes('[SessionStart]') ||
- result.stderr.includes('Package manager'),
- 'Should output session info'
- );
- })) passed++; else failed++;
+ if (
+ await asyncTest('runs without error', async () => {
+ const result = await runScript(path.join(scriptsDir, 'session-start.js'));
+ assert.strictEqual(result.code, 0, `Exit code should be 0, got ${result.code}`);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('outputs session info to stderr', async () => {
+ const result = await runScript(path.join(scriptsDir, 'session-start.js'));
+ assert.ok(result.stderr.includes('[SessionStart]') || result.stderr.includes('Package manager'), 'Should output session info');
+ })
+ )
+ passed++;
+ else failed++;
// session-start.js edge cases
console.log('\nsession-start.js (edge cases):');
- if (await asyncTest('exits 0 even with isolated empty HOME', async () => {
- const isoHome = path.join(os.tmpdir(), `ecc-iso-start-${Date.now()}`);
- fs.mkdirSync(path.join(isoHome, '.claude', 'sessions'), { recursive: true });
- fs.mkdirSync(path.join(isoHome, '.claude', 'skills', 'learned'), { recursive: true });
- try {
- const result = await runScript(path.join(scriptsDir, 'session-start.js'), '', {
- HOME: isoHome, USERPROFILE: isoHome
- });
- assert.strictEqual(result.code, 0, `Exit code should be 0, got ${result.code}`);
- } finally {
- fs.rmSync(isoHome, { recursive: true, force: true });
- }
- })) passed++; else failed++;
-
- if (await asyncTest('reports package manager detection', async () => {
- const result = await runScript(path.join(scriptsDir, 'session-start.js'));
- assert.ok(
- result.stderr.includes('Package manager') || result.stderr.includes('[SessionStart]'),
- 'Should report package manager info'
- );
- })) passed++; else failed++;
-
- if (await asyncTest('skips template session content', async () => {
- const isoHome = path.join(os.tmpdir(), `ecc-tpl-start-${Date.now()}`);
- const sessionsDir = path.join(isoHome, '.claude', 'sessions');
- fs.mkdirSync(sessionsDir, { recursive: true });
- fs.mkdirSync(path.join(isoHome, '.claude', 'skills', 'learned'), { recursive: true });
-
- // Create a session file with template placeholder
- const sessionFile = path.join(sessionsDir, '2026-02-11-abcd1234-session.tmp');
- fs.writeFileSync(sessionFile, '## Current State\n\n[Session context goes here]\n');
-
- try {
- const result = await runScript(path.join(scriptsDir, 'session-start.js'), '', {
- HOME: isoHome, USERPROFILE: isoHome
- });
- assert.strictEqual(result.code, 0);
- // stdout should NOT contain the template content
- assert.ok(
- !result.stdout.includes('Previous session summary'),
- 'Should not inject template session content'
- );
- } finally {
- fs.rmSync(isoHome, { recursive: true, force: true });
- }
- })) passed++; else failed++;
+ if (
+ await asyncTest('exits 0 even with isolated empty HOME', async () => {
+ const isoHome = path.join(os.tmpdir(), `ecc-iso-start-${Date.now()}`);
+ fs.mkdirSync(path.join(isoHome, '.claude', 'sessions'), { recursive: true });
+ fs.mkdirSync(path.join(isoHome, '.claude', 'skills', 'learned'), { recursive: true });
+ try {
+ const result = await runScript(path.join(scriptsDir, 'session-start.js'), '', {
+ HOME: isoHome,
+ USERPROFILE: isoHome
+ });
+ assert.strictEqual(result.code, 0, `Exit code should be 0, got ${result.code}`);
+ } finally {
+ fs.rmSync(isoHome, { recursive: true, force: true });
+ }
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('reports package manager detection', async () => {
+ const result = await runScript(path.join(scriptsDir, 'session-start.js'));
+ assert.ok(result.stderr.includes('Package manager') || result.stderr.includes('[SessionStart]'), 'Should report package manager info');
+ })
+ )
+ passed++;
+ else failed++;
- if (await asyncTest('injects real session content', async () => {
- const isoHome = path.join(os.tmpdir(), `ecc-real-start-${Date.now()}`);
- const sessionsDir = path.join(isoHome, '.claude', 'sessions');
- fs.mkdirSync(sessionsDir, { recursive: true });
- fs.mkdirSync(path.join(isoHome, '.claude', 'skills', 'learned'), { recursive: true });
+ if (
+ await asyncTest('skips template session content', async () => {
+ const isoHome = path.join(os.tmpdir(), `ecc-tpl-start-${Date.now()}`);
+ const sessionsDir = path.join(isoHome, '.claude', 'sessions');
+ fs.mkdirSync(sessionsDir, { recursive: true });
+ fs.mkdirSync(path.join(isoHome, '.claude', 'skills', 'learned'), { recursive: true });
- // Create a real session file
- const sessionFile = path.join(sessionsDir, '2026-02-11-efgh5678-session.tmp');
- fs.writeFileSync(sessionFile, '# Real Session\n\nI worked on authentication refactor.\n');
+ // Create a session file with template placeholder
+ const sessionFile = path.join(sessionsDir, '2026-02-11-abcd1234-session.tmp');
+ fs.writeFileSync(sessionFile, '## Current State\n\n[Session context goes here]\n');
- try {
- const result = await runScript(path.join(scriptsDir, 'session-start.js'), '', {
- HOME: isoHome, USERPROFILE: isoHome
- });
- assert.strictEqual(result.code, 0);
- assert.ok(
- result.stdout.includes('Previous session summary'),
- 'Should inject real session content'
- );
- assert.ok(
- result.stdout.includes('authentication refactor'),
- 'Should include session content text'
- );
- } finally {
- fs.rmSync(isoHome, { recursive: true, force: true });
- }
- })) passed++; else failed++;
+ try {
+ const result = await runScript(path.join(scriptsDir, 'session-start.js'), '', {
+ HOME: isoHome,
+ USERPROFILE: isoHome
+ });
+ assert.strictEqual(result.code, 0);
+ // stdout should NOT contain the template content
+ assert.ok(!result.stdout.includes('Previous session summary'), 'Should not inject template session content');
+ } finally {
+ fs.rmSync(isoHome, { recursive: true, force: true });
+ }
+ })
+ )
+ passed++;
+ else failed++;
- if (await asyncTest('reports learned skills count', async () => {
- const isoHome = path.join(os.tmpdir(), `ecc-skills-start-${Date.now()}`);
- const learnedDir = path.join(isoHome, '.claude', 'skills', 'learned');
- fs.mkdirSync(learnedDir, { recursive: true });
- fs.mkdirSync(path.join(isoHome, '.claude', 'sessions'), { recursive: true });
+ if (
+ await asyncTest('injects real session content', async () => {
+ const isoHome = path.join(os.tmpdir(), `ecc-real-start-${Date.now()}`);
+ const sessionsDir = path.join(isoHome, '.claude', 'sessions');
+ fs.mkdirSync(sessionsDir, { recursive: true });
+ fs.mkdirSync(path.join(isoHome, '.claude', 'skills', 'learned'), { recursive: true });
- // Create learned skill files
- fs.writeFileSync(path.join(learnedDir, 'testing-patterns.md'), '# Testing');
- fs.writeFileSync(path.join(learnedDir, 'debugging.md'), '# Debugging');
+ // Create a real session file
+ const sessionFile = path.join(sessionsDir, '2026-02-11-efgh5678-session.tmp');
+ fs.writeFileSync(sessionFile, '# Real Session\n\nI worked on authentication refactor.\n');
- try {
- const result = await runScript(path.join(scriptsDir, 'session-start.js'), '', {
- HOME: isoHome, USERPROFILE: isoHome
- });
- assert.strictEqual(result.code, 0);
- assert.ok(
- result.stderr.includes('2 learned skill(s)'),
- `Should report 2 learned skills, stderr: ${result.stderr}`
- );
- } finally {
- fs.rmSync(isoHome, { recursive: true, force: true });
- }
- })) passed++; else failed++;
+ try {
+ const result = await runScript(path.join(scriptsDir, 'session-start.js'), '', {
+ HOME: isoHome,
+ USERPROFILE: isoHome
+ });
+ assert.strictEqual(result.code, 0);
+ assert.ok(result.stdout.includes('Previous session summary'), 'Should inject real session content');
+ assert.ok(result.stdout.includes('authentication refactor'), 'Should include session content text');
+ } finally {
+ fs.rmSync(isoHome, { recursive: true, force: true });
+ }
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('reports learned skills count', async () => {
+ const isoHome = path.join(os.tmpdir(), `ecc-skills-start-${Date.now()}`);
+ const learnedDir = path.join(isoHome, '.claude', 'skills', 'learned');
+ fs.mkdirSync(learnedDir, { recursive: true });
+ fs.mkdirSync(path.join(isoHome, '.claude', 'sessions'), { recursive: true });
+
+ // Create learned skill files
+ fs.writeFileSync(path.join(learnedDir, 'testing-patterns.md'), '# Testing');
+ fs.writeFileSync(path.join(learnedDir, 'debugging.md'), '# Debugging');
+
+ try {
+ const result = await runScript(path.join(scriptsDir, 'session-start.js'), '', {
+ HOME: isoHome,
+ USERPROFILE: isoHome
+ });
+ assert.strictEqual(result.code, 0);
+ assert.ok(result.stderr.includes('2 learned skill(s)'), `Should report 2 learned skills, stderr: ${result.stderr}`);
+ } finally {
+ fs.rmSync(isoHome, { recursive: true, force: true });
+ }
+ })
+ )
+ passed++;
+ else failed++;
// check-console-log.js tests
console.log('\ncheck-console-log.js:');
- if (await asyncTest('passes through stdin data to stdout', async () => {
- const stdinData = JSON.stringify({ tool_name: 'Write', tool_input: {} });
- const result = await runScript(path.join(scriptsDir, 'check-console-log.js'), stdinData);
- assert.strictEqual(result.code, 0);
- assert.ok(result.stdout.includes('tool_name'), 'Should pass through stdin data');
- })) passed++; else failed++;
-
- if (await asyncTest('exits 0 with empty stdin', async () => {
- const result = await runScript(path.join(scriptsDir, 'check-console-log.js'), '');
- assert.strictEqual(result.code, 0);
- })) passed++; else failed++;
-
- if (await asyncTest('handles invalid JSON stdin gracefully', async () => {
- const result = await runScript(path.join(scriptsDir, 'check-console-log.js'), 'not valid json');
- assert.strictEqual(result.code, 0, 'Should exit 0 on invalid JSON');
- // Should still pass through the data
- assert.ok(result.stdout.includes('not valid json'), 'Should pass through invalid data');
- })) passed++; else failed++;
+ if (
+ await asyncTest('passes through stdin data to stdout', async () => {
+ const stdinData = JSON.stringify({ tool_name: 'Write', tool_input: {} });
+ const result = await runScript(path.join(scriptsDir, 'check-console-log.js'), stdinData);
+ assert.strictEqual(result.code, 0);
+ assert.ok(result.stdout.includes('tool_name'), 'Should pass through stdin data');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('exits 0 with empty stdin', async () => {
+ const result = await runScript(path.join(scriptsDir, 'check-console-log.js'), '');
+ assert.strictEqual(result.code, 0);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('handles invalid JSON stdin gracefully', async () => {
+ const result = await runScript(path.join(scriptsDir, 'check-console-log.js'), 'not valid json');
+ assert.strictEqual(result.code, 0, 'Should exit 0 on invalid JSON');
+ // Should still pass through the data
+ assert.ok(result.stdout.includes('not valid json'), 'Should pass through invalid data');
+ })
+ )
+ passed++;
+ else failed++;
// session-end.js tests
console.log('\nsession-end.js:');
- if (await asyncTest('runs without error', async () => {
- const result = await runScript(path.join(scriptsDir, 'session-end.js'));
- assert.strictEqual(result.code, 0, `Exit code should be 0, got ${result.code}`);
- })) passed++; else failed++;
-
- if (await asyncTest('creates or updates session file', async () => {
- // Run the script
- await runScript(path.join(scriptsDir, 'session-end.js'));
-
- // Check if session file was created
- // Note: Without CLAUDE_SESSION_ID, falls back to project name (not 'default')
- // Use local time to match the script's getDateString() function
- const sessionsDir = path.join(os.homedir(), '.claude', 'sessions');
- const now = new Date();
- const today = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}`;
-
- // Get the expected session ID (project name fallback)
- const utils = require('../../scripts/lib/utils');
- const expectedId = utils.getSessionIdShort();
- const sessionFile = path.join(sessionsDir, `${today}-${expectedId}-session.tmp`);
-
- assert.ok(fs.existsSync(sessionFile), `Session file should exist: ${sessionFile}`);
- })) passed++; else failed++;
-
- if (await asyncTest('includes session ID in filename', async () => {
- const testSessionId = 'test-session-abc12345';
- const expectedShortId = 'abc12345'; // Last 8 chars
-
- // Run with custom session ID
- await runScript(path.join(scriptsDir, 'session-end.js'), '', {
- CLAUDE_SESSION_ID: testSessionId
- });
+ if (
+ await asyncTest('runs without error', async () => {
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'));
+ assert.strictEqual(result.code, 0, `Exit code should be 0, got ${result.code}`);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('creates or updates session file', async () => {
+ // Run the script
+ await runScript(path.join(scriptsDir, 'session-end.js'));
+
+ // Check if session file was created
+ // Note: Without CLAUDE_SESSION_ID, falls back to project name (not 'default')
+ // Use local time to match the script's getDateString() function
+ const sessionsDir = path.join(os.homedir(), '.claude', 'sessions');
+ const now = new Date();
+ const today = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}`;
+
+ // Get the expected session ID (project name fallback)
+ const utils = require('../../scripts/lib/utils');
+ const expectedId = utils.getSessionIdShort();
+ const sessionFile = path.join(sessionsDir, `${today}-${expectedId}-session.tmp`);
+
+ assert.ok(fs.existsSync(sessionFile), `Session file should exist: ${sessionFile}`);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('includes session ID in filename', async () => {
+ const testSessionId = 'test-session-abc12345';
+ const expectedShortId = 'abc12345'; // Last 8 chars
+
+ // Run with custom session ID
+ await runScript(path.join(scriptsDir, 'session-end.js'), '', {
+ CLAUDE_SESSION_ID: testSessionId
+ });
- // Check if session file was created with session ID
- // Use local time to match the script's getDateString() function
- const sessionsDir = path.join(os.homedir(), '.claude', 'sessions');
- const now = new Date();
- const today = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}`;
- const sessionFile = path.join(sessionsDir, `${today}-${expectedShortId}-session.tmp`);
+ // Check if session file was created with session ID
+ // Use local time to match the script's getDateString() function
+ const sessionsDir = path.join(os.homedir(), '.claude', 'sessions');
+ const now = new Date();
+ const today = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}`;
+ const sessionFile = path.join(sessionsDir, `${today}-${expectedShortId}-session.tmp`);
- assert.ok(fs.existsSync(sessionFile), `Session file should exist: ${sessionFile}`);
- })) passed++; else failed++;
+ assert.ok(fs.existsSync(sessionFile), `Session file should exist: ${sessionFile}`);
+ })
+ )
+ passed++;
+ else failed++;
// pre-compact.js tests
console.log('\npre-compact.js:');
- if (await asyncTest('runs without error', async () => {
- const result = await runScript(path.join(scriptsDir, 'pre-compact.js'));
- assert.strictEqual(result.code, 0, `Exit code should be 0, got ${result.code}`);
- })) passed++; else failed++;
-
- if (await asyncTest('outputs PreCompact message', async () => {
- const result = await runScript(path.join(scriptsDir, 'pre-compact.js'));
- assert.ok(result.stderr.includes('[PreCompact]'), 'Should output PreCompact message');
- })) passed++; else failed++;
-
- if (await asyncTest('creates compaction log', async () => {
- await runScript(path.join(scriptsDir, 'pre-compact.js'));
- const logFile = path.join(os.homedir(), '.claude', 'sessions', 'compaction-log.txt');
- assert.ok(fs.existsSync(logFile), 'Compaction log should exist');
- })) passed++; else failed++;
-
- if (await asyncTest('annotates active session file with compaction marker', async () => {
- const isoHome = path.join(os.tmpdir(), `ecc-compact-annotate-${Date.now()}`);
- const sessionsDir = path.join(isoHome, '.claude', 'sessions');
- fs.mkdirSync(sessionsDir, { recursive: true });
-
- // Create an active .tmp session file
- const sessionFile = path.join(sessionsDir, '2026-02-11-test-session.tmp');
- fs.writeFileSync(sessionFile, '# Session: 2026-02-11\n**Started:** 10:00\n');
-
- try {
- await runScript(path.join(scriptsDir, 'pre-compact.js'), '', {
- HOME: isoHome, USERPROFILE: isoHome
- });
+ if (
+ await asyncTest('runs without error', async () => {
+ const result = await runScript(path.join(scriptsDir, 'pre-compact.js'));
+ assert.strictEqual(result.code, 0, `Exit code should be 0, got ${result.code}`);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('outputs PreCompact message', async () => {
+ const result = await runScript(path.join(scriptsDir, 'pre-compact.js'));
+ assert.ok(result.stderr.includes('[PreCompact]'), 'Should output PreCompact message');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('creates compaction log', async () => {
+ await runScript(path.join(scriptsDir, 'pre-compact.js'));
+ const logFile = path.join(os.homedir(), '.claude', 'sessions', 'compaction-log.txt');
+ assert.ok(fs.existsSync(logFile), 'Compaction log should exist');
+ })
+ )
+ passed++;
+ else failed++;
- const content = fs.readFileSync(sessionFile, 'utf8');
- assert.ok(
- content.includes('Compaction occurred'),
- 'Should annotate the session file with compaction marker'
- );
- } finally {
- fs.rmSync(isoHome, { recursive: true, force: true });
- }
- })) passed++; else failed++;
+ if (
+ await asyncTest('annotates active session file with compaction marker', async () => {
+ const isoHome = path.join(os.tmpdir(), `ecc-compact-annotate-${Date.now()}`);
+ const sessionsDir = path.join(isoHome, '.claude', 'sessions');
+ fs.mkdirSync(sessionsDir, { recursive: true });
- if (await asyncTest('compaction log contains timestamp', async () => {
- const isoHome = path.join(os.tmpdir(), `ecc-compact-ts-${Date.now()}`);
- const sessionsDir = path.join(isoHome, '.claude', 'sessions');
- fs.mkdirSync(sessionsDir, { recursive: true });
+ // Create an active .tmp session file
+ const sessionFile = path.join(sessionsDir, '2026-02-11-test-session.tmp');
+ fs.writeFileSync(sessionFile, '# Session: 2026-02-11\n**Started:** 10:00\n');
- try {
- await runScript(path.join(scriptsDir, 'pre-compact.js'), '', {
- HOME: isoHome, USERPROFILE: isoHome
- });
+ try {
+ await runScript(path.join(scriptsDir, 'pre-compact.js'), '', {
+ HOME: isoHome,
+ USERPROFILE: isoHome
+ });
- const logFile = path.join(sessionsDir, 'compaction-log.txt');
- assert.ok(fs.existsSync(logFile), 'Compaction log should exist');
- const content = fs.readFileSync(logFile, 'utf8');
- // Should have a timestamp like [2026-02-11 14:30:00]
- assert.ok(
- /\[\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\]/.test(content),
- `Log should contain timestamped entry, got: ${content.substring(0, 100)}`
- );
- } finally {
- fs.rmSync(isoHome, { recursive: true, force: true });
- }
- })) passed++; else failed++;
+ const content = fs.readFileSync(sessionFile, 'utf8');
+ assert.ok(content.includes('Compaction occurred'), 'Should annotate the session file with compaction marker');
+ } finally {
+ fs.rmSync(isoHome, { recursive: true, force: true });
+ }
+ })
+ )
+ passed++;
+ else failed++;
- // suggest-compact.js tests
- console.log('\nsuggest-compact.js:');
+ if (
+ await asyncTest('compaction log contains timestamp', async () => {
+ const isoHome = path.join(os.tmpdir(), `ecc-compact-ts-${Date.now()}`);
+ const sessionsDir = path.join(isoHome, '.claude', 'sessions');
+ fs.mkdirSync(sessionsDir, { recursive: true });
- if (await asyncTest('runs without error', async () => {
- const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
- CLAUDE_SESSION_ID: 'test-session-' + Date.now()
- });
- assert.strictEqual(result.code, 0, `Exit code should be 0, got ${result.code}`);
- })) passed++; else failed++;
+ try {
+ await runScript(path.join(scriptsDir, 'pre-compact.js'), '', {
+ HOME: isoHome,
+ USERPROFILE: isoHome
+ });
- if (await asyncTest('increments counter on each call', async () => {
- const sessionId = 'test-counter-' + Date.now();
+ const logFile = path.join(sessionsDir, 'compaction-log.txt');
+ assert.ok(fs.existsSync(logFile), 'Compaction log should exist');
+ const content = fs.readFileSync(logFile, 'utf8');
+ // Should have a timestamp like [2026-02-11 14:30:00]
+ assert.ok(/\[\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\]/.test(content), `Log should contain timestamped entry, got: ${content.substring(0, 100)}`);
+ } finally {
+ fs.rmSync(isoHome, { recursive: true, force: true });
+ }
+ })
+ )
+ passed++;
+ else failed++;
- // Run multiple times
- for (let i = 0; i < 3; i++) {
- await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
- CLAUDE_SESSION_ID: sessionId
+ // suggest-compact.js tests
+ console.log('\nsuggest-compact.js:');
+
+ if (
+ await asyncTest('runs without error', async () => {
+ const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
+ CLAUDE_SESSION_ID: 'test-session-' + Date.now()
});
- }
+ assert.strictEqual(result.code, 0, `Exit code should be 0, got ${result.code}`);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('increments counter on each call', async () => {
+ const sessionId = 'test-counter-' + Date.now();
+
+ // Run multiple times
+ for (let i = 0; i < 3; i++) {
+ await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
+ CLAUDE_SESSION_ID: sessionId
+ });
+ }
- // Check counter file
- const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
- const count = parseInt(fs.readFileSync(counterFile, 'utf8').trim(), 10);
- assert.strictEqual(count, 3, `Counter should be 3, got ${count}`);
+ // Check counter file
+ const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
+ const count = parseInt(fs.readFileSync(counterFile, 'utf8').trim(), 10);
+ assert.strictEqual(count, 3, `Counter should be 3, got ${count}`);
- // Cleanup
- fs.unlinkSync(counterFile);
- })) passed++; else failed++;
+ // Cleanup
+ fs.unlinkSync(counterFile);
+ })
+ )
+ passed++;
+ else failed++;
- if (await asyncTest('suggests compact at threshold', async () => {
- const sessionId = 'test-threshold-' + Date.now();
- const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
+ if (
+ await asyncTest('suggests compact at threshold', async () => {
+ const sessionId = 'test-threshold-' + Date.now();
+ const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
- // Set counter to threshold - 1
- fs.writeFileSync(counterFile, '49');
+ // Set counter to threshold - 1
+ fs.writeFileSync(counterFile, '49');
- const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
- CLAUDE_SESSION_ID: sessionId,
- COMPACT_THRESHOLD: '50'
- });
+ const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
+ CLAUDE_SESSION_ID: sessionId,
+ COMPACT_THRESHOLD: '50'
+ });
- assert.ok(
- result.stderr.includes('50 tool calls reached'),
- 'Should suggest compact at threshold'
- );
+ assert.ok(result.stderr.includes('50 tool calls reached'), 'Should suggest compact at threshold');
- // Cleanup
- fs.unlinkSync(counterFile);
- })) passed++; else failed++;
+ // Cleanup
+ fs.unlinkSync(counterFile);
+ })
+ )
+ passed++;
+ else failed++;
- if (await asyncTest('does not suggest below threshold', async () => {
- const sessionId = 'test-below-' + Date.now();
- const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
+ if (
+ await asyncTest('does not suggest below threshold', async () => {
+ const sessionId = 'test-below-' + Date.now();
+ const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
- fs.writeFileSync(counterFile, '10');
+ fs.writeFileSync(counterFile, '10');
- const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
- CLAUDE_SESSION_ID: sessionId,
- COMPACT_THRESHOLD: '50'
- });
+ const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
+ CLAUDE_SESSION_ID: sessionId,
+ COMPACT_THRESHOLD: '50'
+ });
- assert.ok(
- !result.stderr.includes('tool calls'),
- 'Should not suggest compact below threshold'
- );
+ assert.ok(!result.stderr.includes('tool calls'), 'Should not suggest compact below threshold');
- fs.unlinkSync(counterFile);
- })) passed++; else failed++;
+ fs.unlinkSync(counterFile);
+ })
+ )
+ passed++;
+ else failed++;
- if (await asyncTest('suggests at regular intervals after threshold', async () => {
- const sessionId = 'test-interval-' + Date.now();
- const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
+ if (
+ await asyncTest('suggests at regular intervals after threshold', async () => {
+ const sessionId = 'test-interval-' + Date.now();
+ const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
- // Set counter to 74 (next will be 75, which is >50 and 75%25==0)
- fs.writeFileSync(counterFile, '74');
+ // Set counter to 74 (next will be 75, which is >50 and 75%25==0)
+ fs.writeFileSync(counterFile, '74');
- const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
- CLAUDE_SESSION_ID: sessionId,
- COMPACT_THRESHOLD: '50'
- });
+ const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
+ CLAUDE_SESSION_ID: sessionId,
+ COMPACT_THRESHOLD: '50'
+ });
- assert.ok(
- result.stderr.includes('75 tool calls'),
- 'Should suggest at 25-call intervals after threshold'
- );
+ assert.ok(result.stderr.includes('75 tool calls'), 'Should suggest at 25-call intervals after threshold');
- fs.unlinkSync(counterFile);
- })) passed++; else failed++;
+ fs.unlinkSync(counterFile);
+ })
+ )
+ passed++;
+ else failed++;
- if (await asyncTest('handles corrupted counter file', async () => {
- const sessionId = 'test-corrupt-' + Date.now();
- const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
+ if (
+ await asyncTest('handles corrupted counter file', async () => {
+ const sessionId = 'test-corrupt-' + Date.now();
+ const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
- fs.writeFileSync(counterFile, 'not-a-number');
+ fs.writeFileSync(counterFile, 'not-a-number');
- const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
- CLAUDE_SESSION_ID: sessionId
- });
+ const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
+ CLAUDE_SESSION_ID: sessionId
+ });
- assert.strictEqual(result.code, 0, 'Should handle corrupted counter gracefully');
+ assert.strictEqual(result.code, 0, 'Should handle corrupted counter gracefully');
- // Counter should be reset to 1
- const newCount = parseInt(fs.readFileSync(counterFile, 'utf8').trim(), 10);
- assert.strictEqual(newCount, 1, 'Should reset counter to 1 on corrupt data');
+ // Counter should be reset to 1
+ const newCount = parseInt(fs.readFileSync(counterFile, 'utf8').trim(), 10);
+ assert.strictEqual(newCount, 1, 'Should reset counter to 1 on corrupt data');
- fs.unlinkSync(counterFile);
- })) passed++; else failed++;
+ fs.unlinkSync(counterFile);
+ })
+ )
+ passed++;
+ else failed++;
- if (await asyncTest('uses default session ID when no env var', async () => {
- const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
- CLAUDE_SESSION_ID: '' // Empty, should use 'default'
- });
+ if (
+ await asyncTest('uses default session ID when no env var', async () => {
+ const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
+ CLAUDE_SESSION_ID: '' // Empty, should use 'default'
+ });
- assert.strictEqual(result.code, 0, 'Should work with default session ID');
+ assert.strictEqual(result.code, 0, 'Should work with default session ID');
- // Cleanup the default counter file
- const counterFile = path.join(os.tmpdir(), 'claude-tool-count-default');
- if (fs.existsSync(counterFile)) fs.unlinkSync(counterFile);
- })) passed++; else failed++;
+ // Cleanup the default counter file
+ const counterFile = path.join(os.tmpdir(), 'claude-tool-count-default');
+ if (fs.existsSync(counterFile)) fs.unlinkSync(counterFile);
+ })
+ )
+ passed++;
+ else failed++;
- if (await asyncTest('validates threshold bounds', async () => {
- const sessionId = 'test-bounds-' + Date.now();
- const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
+ if (
+ await asyncTest('validates threshold bounds', async () => {
+ const sessionId = 'test-bounds-' + Date.now();
+ const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
- // Invalid threshold should fall back to 50
- fs.writeFileSync(counterFile, '49');
+ // Invalid threshold should fall back to 50
+ fs.writeFileSync(counterFile, '49');
- const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
- CLAUDE_SESSION_ID: sessionId,
- COMPACT_THRESHOLD: '-5' // Invalid: negative
- });
+ const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
+ CLAUDE_SESSION_ID: sessionId,
+ COMPACT_THRESHOLD: '-5' // Invalid: negative
+ });
- assert.ok(
- result.stderr.includes('50 tool calls'),
- 'Should use default threshold (50) for invalid value'
- );
+ assert.ok(result.stderr.includes('50 tool calls'), 'Should use default threshold (50) for invalid value');
- fs.unlinkSync(counterFile);
- })) passed++; else failed++;
+ fs.unlinkSync(counterFile);
+ })
+ )
+ passed++;
+ else failed++;
// evaluate-session.js tests
console.log('\nevaluate-session.js:');
- if (await asyncTest('runs without error when no transcript', async () => {
- const result = await runScript(path.join(scriptsDir, 'evaluate-session.js'));
- assert.strictEqual(result.code, 0, `Exit code should be 0, got ${result.code}`);
- })) passed++; else failed++;
+ if (
+ await asyncTest('runs without error when no transcript', async () => {
+ const result = await runScript(path.join(scriptsDir, 'evaluate-session.js'));
+ assert.strictEqual(result.code, 0, `Exit code should be 0, got ${result.code}`);
+ })
+ )
+ passed++;
+ else failed++;
- if (await asyncTest('skips short sessions', async () => {
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
+ if (
+ await asyncTest('skips short sessions', async () => {
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
- // Create a short transcript (less than 10 user messages)
- const transcript = Array(5).fill('{"type":"user","content":"test"}\n').join('');
- fs.writeFileSync(transcriptPath, transcript);
+ // Create a short transcript (less than 10 user messages)
+ const transcript = Array(5).fill('{"type":"user","content":"test"}\n').join('');
+ fs.writeFileSync(transcriptPath, transcript);
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(path.join(scriptsDir, 'evaluate-session.js'), stdinJson);
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(path.join(scriptsDir, 'evaluate-session.js'), stdinJson);
- assert.ok(
- result.stderr.includes('Session too short'),
- 'Should indicate session is too short'
- );
+ assert.ok(result.stderr.includes('Session too short'), 'Should indicate session is too short');
- cleanupTestDir(testDir);
- })) passed++; else failed++;
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
- if (await asyncTest('processes sessions with enough messages', async () => {
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
+ if (
+ await asyncTest('processes sessions with enough messages', async () => {
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
- // Create a longer transcript (more than 10 user messages)
- const transcript = Array(15).fill('{"type":"user","content":"test"}\n').join('');
- fs.writeFileSync(transcriptPath, transcript);
+ // Create a longer transcript (more than 10 user messages)
+ const transcript = Array(15).fill('{"type":"user","content":"test"}\n').join('');
+ fs.writeFileSync(transcriptPath, transcript);
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(path.join(scriptsDir, 'evaluate-session.js'), stdinJson);
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(path.join(scriptsDir, 'evaluate-session.js'), stdinJson);
- assert.ok(
- result.stderr.includes('15 messages'),
- 'Should report message count'
- );
+ assert.ok(result.stderr.includes('15 messages'), 'Should report message count');
- cleanupTestDir(testDir);
- })) passed++; else failed++;
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
// evaluate-session.js: whitespace tolerance regression test
- if (await asyncTest('counts user messages with whitespace in JSON (regression)', async () => {
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
-
- // Create transcript with whitespace around colons (pretty-printed style)
- const lines = [];
- for (let i = 0; i < 15; i++) {
- lines.push('{ "type" : "user", "content": "message ' + i + '" }');
- }
- fs.writeFileSync(transcriptPath, lines.join('\n'));
+ if (
+ await asyncTest('counts user messages with whitespace in JSON (regression)', async () => {
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
+
+ // Create transcript with whitespace around colons (pretty-printed style)
+ const lines = [];
+ for (let i = 0; i < 15; i++) {
+ lines.push('{ "type" : "user", "content": "message ' + i + '" }');
+ }
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(path.join(scriptsDir, 'evaluate-session.js'), stdinJson);
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(path.join(scriptsDir, 'evaluate-session.js'), stdinJson);
- assert.ok(
- result.stderr.includes('15 messages'),
- 'Should count user messages with whitespace in JSON, got: ' + result.stderr.trim()
- );
+ assert.ok(result.stderr.includes('15 messages'), 'Should count user messages with whitespace in JSON, got: ' + result.stderr.trim());
- cleanupTestDir(testDir);
- })) passed++; else failed++;
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
// session-end.js: content array with null elements regression test
- if (await asyncTest('handles transcript with null content array elements (regression)', async () => {
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
-
- // Create transcript with null elements in content array
- const lines = [
- '{"type":"user","content":[null,{"text":"hello"},null,{"text":"world"}]}',
- '{"type":"user","content":"simple string message"}',
- '{"type":"user","content":[{"text":"normal"},{"text":"array"}]}',
- '{"type":"tool_use","tool_name":"Edit","tool_input":{"file_path":"/test.js"}}',
- ];
- fs.writeFileSync(transcriptPath, lines.join('\n'));
-
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson);
-
- // Should not crash (exit 0)
- assert.strictEqual(result.code, 0, 'Should handle null content elements without crash');
- })) passed++; else failed++;
+ if (
+ await asyncTest('handles transcript with null content array elements (regression)', async () => {
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
+
+ // Create transcript with null elements in content array
+ const lines = [
+ '{"type":"user","content":[null,{"text":"hello"},null,{"text":"world"}]}',
+ '{"type":"user","content":"simple string message"}',
+ '{"type":"user","content":[{"text":"normal"},{"text":"array"}]}',
+ '{"type":"tool_use","tool_name":"Edit","tool_input":{"file_path":"/test.js"}}'
+ ];
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
+
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson);
+
+ // Should not crash (exit 0)
+ assert.strictEqual(result.code, 0, 'Should handle null content elements without crash');
+ })
+ )
+ passed++;
+ else failed++;
// post-edit-console-warn.js tests
console.log('\npost-edit-console-warn.js:');
- if (await asyncTest('warns about console.log in JS files', async () => {
- const testDir = createTestDir();
- const testFile = path.join(testDir, 'test.js');
- fs.writeFileSync(testFile, 'const x = 1;\nconsole.log(x);\nreturn x;');
+ if (
+ await asyncTest('warns about console.log in JS files', async () => {
+ const testDir = createTestDir();
+ const testFile = path.join(testDir, 'test.js');
+ fs.writeFileSync(testFile, 'const x = 1;\nconsole.log(x);\nreturn x;');
- const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), stdinJson);
+ const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), stdinJson);
+
+ assert.ok(result.stderr.includes('console.log'), 'Should warn about console.log');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('does not warn for non-JS files', async () => {
+ const testDir = createTestDir();
+ const testFile = path.join(testDir, 'test.md');
+ fs.writeFileSync(testFile, 'Use console.log for debugging');
+
+ const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), stdinJson);
+
+ assert.ok(!result.stderr.includes('console.log'), 'Should not warn for non-JS files');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
- assert.ok(result.stderr.includes('console.log'), 'Should warn about console.log');
- cleanupTestDir(testDir);
- })) passed++; else failed++;
+ if (
+ await asyncTest('does not warn for clean JS files', async () => {
+ const testDir = createTestDir();
+ const testFile = path.join(testDir, 'clean.ts');
+ fs.writeFileSync(testFile, 'const x = 1;\nreturn x;');
- if (await asyncTest('does not warn for non-JS files', async () => {
- const testDir = createTestDir();
- const testFile = path.join(testDir, 'test.md');
- fs.writeFileSync(testFile, 'Use console.log for debugging');
+ const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), stdinJson);
- const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), stdinJson);
+ assert.ok(!result.stderr.includes('WARNING'), 'Should not warn for clean files');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
- assert.ok(!result.stderr.includes('console.log'), 'Should not warn for non-JS files');
- cleanupTestDir(testDir);
- })) passed++; else failed++;
+ if (
+ await asyncTest('handles missing file gracefully', async () => {
+ const stdinJson = JSON.stringify({ tool_input: { file_path: '/nonexistent/file.ts' } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), stdinJson);
- if (await asyncTest('does not warn for clean JS files', async () => {
- const testDir = createTestDir();
- const testFile = path.join(testDir, 'clean.ts');
- fs.writeFileSync(testFile, 'const x = 1;\nreturn x;');
+ assert.strictEqual(result.code, 0, 'Should not crash on missing file');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('limits console.log output to 5 matches', async () => {
+ const testDir = createTestDir();
+ const testFile = path.join(testDir, 'many-logs.js');
+ // Create a file with 8 console.log statements
+ const lines = [];
+ for (let i = 1; i <= 8; i++) {
+ lines.push(`console.log('debug ${i}');`);
+ }
+ fs.writeFileSync(testFile, lines.join('\n'));
+
+ const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), stdinJson);
+
+ assert.ok(result.stderr.includes('console.log'), 'Should warn about console.log');
+ // Count how many "debug N" lines appear in stderr (the line-number output)
+ const debugLines = result.stderr.split('\n').filter(l => /^\d+:/.test(l.trim()));
+ assert.ok(debugLines.length <= 5, `Should show at most 5 matches, got ${debugLines.length}`);
+ // Should include debug 1 but not debug 8 (sliced)
+ assert.ok(result.stderr.includes('debug 1'), 'Should include first match');
+ assert.ok(!result.stderr.includes('debug 8'), 'Should not include 8th match');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
- const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), stdinJson);
+ if (
+ await asyncTest('ignores console.warn and console.error (only flags console.log)', async () => {
+ const testDir = createTestDir();
+ const testFile = path.join(testDir, 'other-console.ts');
+ fs.writeFileSync(testFile, ['console.warn("this is a warning");', 'console.error("this is an error");', 'console.debug("this is debug");', 'console.info("this is info");'].join('\n'));
- assert.ok(!result.stderr.includes('WARNING'), 'Should not warn for clean files');
- cleanupTestDir(testDir);
- })) passed++; else failed++;
+ const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), stdinJson);
- if (await asyncTest('handles missing file gracefully', async () => {
- const stdinJson = JSON.stringify({ tool_input: { file_path: '/nonexistent/file.ts' } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), stdinJson);
+ assert.ok(!result.stderr.includes('WARNING'), 'Should NOT warn about console.warn/error/debug/info');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
- assert.strictEqual(result.code, 0, 'Should not crash on missing file');
- })) passed++; else failed++;
+ if (
+ await asyncTest('passes through original data on stdout', async () => {
+ const stdinJson = JSON.stringify({ tool_input: { file_path: '/test.py' } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), stdinJson);
- if (await asyncTest('limits console.log output to 5 matches', async () => {
- const testDir = createTestDir();
- const testFile = path.join(testDir, 'many-logs.js');
- // Create a file with 8 console.log statements
- const lines = [];
- for (let i = 1; i <= 8; i++) {
- lines.push(`console.log('debug ${i}');`);
- }
- fs.writeFileSync(testFile, lines.join('\n'));
-
- const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), stdinJson);
-
- assert.ok(result.stderr.includes('console.log'), 'Should warn about console.log');
- // Count how many "debug N" lines appear in stderr (the line-number output)
- const debugLines = result.stderr.split('\n').filter(l => /^\d+:/.test(l.trim()));
- assert.ok(debugLines.length <= 5, `Should show at most 5 matches, got ${debugLines.length}`);
- // Should include debug 1 but not debug 8 (sliced)
- assert.ok(result.stderr.includes('debug 1'), 'Should include first match');
- assert.ok(!result.stderr.includes('debug 8'), 'Should not include 8th match');
- cleanupTestDir(testDir);
- })) passed++; else failed++;
-
- if (await asyncTest('ignores console.warn and console.error (only flags console.log)', async () => {
- const testDir = createTestDir();
- const testFile = path.join(testDir, 'other-console.ts');
- fs.writeFileSync(testFile, [
- 'console.warn("this is a warning");',
- 'console.error("this is an error");',
- 'console.debug("this is debug");',
- 'console.info("this is info");',
- ].join('\n'));
-
- const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), stdinJson);
-
- assert.ok(!result.stderr.includes('WARNING'), 'Should NOT warn about console.warn/error/debug/info');
- cleanupTestDir(testDir);
- })) passed++; else failed++;
-
- if (await asyncTest('passes through original data on stdout', async () => {
- const stdinJson = JSON.stringify({ tool_input: { file_path: '/test.py' } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), stdinJson);
-
- assert.ok(result.stdout.includes('tool_input'), 'Should pass through stdin data');
- })) passed++; else failed++;
+ assert.ok(result.stdout.includes('tool_input'), 'Should pass through stdin data');
+ })
+ )
+ passed++;
+ else failed++;
// post-edit-format.js tests
console.log('\npost-edit-format.js:');
- if (await asyncTest('runs without error on empty stdin', async () => {
- const result = await runScript(path.join(scriptsDir, 'post-edit-format.js'));
- assert.strictEqual(result.code, 0, 'Should exit 0 on empty stdin');
- })) passed++; else failed++;
-
- if (await asyncTest('skips non-JS/TS files', async () => {
- const stdinJson = JSON.stringify({ tool_input: { file_path: '/test.py' } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-format.js'), stdinJson);
- assert.strictEqual(result.code, 0, 'Should exit 0 for non-JS files');
- assert.ok(result.stdout.includes('tool_input'), 'Should pass through stdin data');
- })) passed++; else failed++;
-
- if (await asyncTest('passes through data for invalid JSON', async () => {
- const result = await runScript(path.join(scriptsDir, 'post-edit-format.js'), 'not json');
- assert.strictEqual(result.code, 0, 'Should exit 0 for invalid JSON');
- })) passed++; else failed++;
-
- if (await asyncTest('handles null tool_input gracefully', async () => {
- const stdinJson = JSON.stringify({ tool_input: null });
- const result = await runScript(path.join(scriptsDir, 'post-edit-format.js'), stdinJson);
- assert.strictEqual(result.code, 0, 'Should exit 0 for null tool_input');
- assert.ok(result.stdout.includes('tool_input'), 'Should pass through data');
- })) passed++; else failed++;
-
- if (await asyncTest('handles missing file_path in tool_input', async () => {
- const stdinJson = JSON.stringify({ tool_input: {} });
- const result = await runScript(path.join(scriptsDir, 'post-edit-format.js'), stdinJson);
- assert.strictEqual(result.code, 0, 'Should exit 0 for missing file_path');
- assert.ok(result.stdout.includes('tool_input'), 'Should pass through data');
- })) passed++; else failed++;
-
- if (await asyncTest('exits 0 and passes data when prettier is unavailable', async () => {
- const stdinJson = JSON.stringify({ tool_input: { file_path: '/nonexistent/path/file.ts' } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-format.js'), stdinJson);
- assert.strictEqual(result.code, 0, 'Should exit 0 even when prettier fails');
- assert.ok(result.stdout.includes('tool_input'), 'Should pass through original data');
- })) passed++; else failed++;
-
- if (await asyncTest('finds formatter config in parent dirs without package.json', async () => {
- const testDir = createTestDir();
- const rootDir = path.join(testDir, 'config-only-repo');
- const nestedDir = path.join(rootDir, 'src', 'nested');
- const filePath = path.join(nestedDir, 'component.ts');
- const binDir = path.join(testDir, 'bin');
- const logFile = path.join(testDir, 'formatter.log');
-
- fs.mkdirSync(nestedDir, { recursive: true });
- fs.writeFileSync(path.join(rootDir, '.prettierrc'), '{}');
- fs.writeFileSync(filePath, 'export const value = 1;\n');
- createCommandShim(binDir, 'npx', logFile);
-
- const stdinJson = JSON.stringify({ tool_input: { file_path: filePath } });
- const result = await runScript(
- path.join(scriptsDir, 'post-edit-format.js'),
- stdinJson,
- withPrependedPath(binDir)
- );
-
- assert.strictEqual(result.code, 0, 'Should exit 0 for config-only repo');
- const logEntries = readCommandLog(logFile);
- assert.strictEqual(logEntries.length, 1, 'Should invoke formatter once');
- assert.strictEqual(
- fs.realpathSync(logEntries[0].cwd),
- fs.realpathSync(rootDir),
- 'Should run formatter from config root'
- );
- assert.deepStrictEqual(
- logEntries[0].args,
- ['prettier', '--write', filePath],
- 'Should use the formatter on the nested file'
- );
- cleanupTestDir(testDir);
- })) passed++; else failed++;
-
- if (await asyncTest('respects CLAUDE_PACKAGE_MANAGER for formatter fallback runner', async () => {
- const testDir = createTestDir();
- const rootDir = path.join(testDir, 'pnpm-repo');
- const filePath = path.join(rootDir, 'index.ts');
- const binDir = path.join(testDir, 'bin');
- const logFile = path.join(testDir, 'pnpm.log');
-
- fs.mkdirSync(rootDir, { recursive: true });
- fs.writeFileSync(path.join(rootDir, '.prettierrc'), '{}');
- fs.writeFileSync(filePath, 'export const value = 1;\n');
- createCommandShim(binDir, 'pnpm', logFile);
-
- const stdinJson = JSON.stringify({ tool_input: { file_path: filePath } });
- const result = await runScript(
- path.join(scriptsDir, 'post-edit-format.js'),
- stdinJson,
- withPrependedPath(binDir, { CLAUDE_PACKAGE_MANAGER: 'pnpm' })
- );
-
- assert.strictEqual(result.code, 0, 'Should exit 0 when pnpm fallback is used');
- const logEntries = readCommandLog(logFile);
- assert.strictEqual(logEntries.length, 1, 'Should invoke pnpm fallback runner once');
- assert.strictEqual(logEntries[0].bin, 'pnpm', 'Should use pnpm runner');
- assert.deepStrictEqual(
- logEntries[0].args,
- ['dlx', 'prettier', '--write', filePath],
- 'Should use pnpm dlx for fallback formatter execution'
- );
- cleanupTestDir(testDir);
- })) passed++; else failed++;
-
- if (await asyncTest('respects project package-manager config for formatter fallback runner', async () => {
- const testDir = createTestDir();
- const rootDir = path.join(testDir, 'bun-repo');
- const filePath = path.join(rootDir, 'index.ts');
- const binDir = path.join(testDir, 'bin');
- const logFile = path.join(testDir, 'bun.log');
-
- fs.mkdirSync(path.join(rootDir, '.claude'), { recursive: true });
- fs.writeFileSync(path.join(rootDir, '.claude', 'package-manager.json'), JSON.stringify({ packageManager: 'bun' }));
- fs.writeFileSync(path.join(rootDir, '.prettierrc'), '{}');
- fs.writeFileSync(filePath, 'export const value = 1;\n');
- createCommandShim(binDir, 'bunx', logFile);
-
- const stdinJson = JSON.stringify({ tool_input: { file_path: filePath } });
- const result = await runScript(
- path.join(scriptsDir, 'post-edit-format.js'),
- stdinJson,
- withPrependedPath(binDir)
- );
-
- assert.strictEqual(result.code, 0, 'Should exit 0 when project config selects bun');
- const logEntries = readCommandLog(logFile);
- assert.strictEqual(logEntries.length, 1, 'Should invoke bunx fallback runner once');
- assert.strictEqual(logEntries[0].bin, 'bunx', 'Should use bunx runner');
- assert.deepStrictEqual(
- logEntries[0].args,
- ['prettier', '--write', filePath],
- 'Should use bunx for fallback formatter execution'
- );
- cleanupTestDir(testDir);
- })) passed++; else failed++;
+ if (
+ await asyncTest('runs without error on empty stdin', async () => {
+ const result = await runScript(path.join(scriptsDir, 'post-edit-format.js'));
+ assert.strictEqual(result.code, 0, 'Should exit 0 on empty stdin');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('skips non-JS/TS files', async () => {
+ const stdinJson = JSON.stringify({ tool_input: { file_path: '/test.py' } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-format.js'), stdinJson);
+ assert.strictEqual(result.code, 0, 'Should exit 0 for non-JS files');
+ assert.ok(result.stdout.includes('tool_input'), 'Should pass through stdin data');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('passes through data for invalid JSON', async () => {
+ const result = await runScript(path.join(scriptsDir, 'post-edit-format.js'), 'not json');
+ assert.strictEqual(result.code, 0, 'Should exit 0 for invalid JSON');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('handles null tool_input gracefully', async () => {
+ const stdinJson = JSON.stringify({ tool_input: null });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-format.js'), stdinJson);
+ assert.strictEqual(result.code, 0, 'Should exit 0 for null tool_input');
+ assert.ok(result.stdout.includes('tool_input'), 'Should pass through data');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('handles missing file_path in tool_input', async () => {
+ const stdinJson = JSON.stringify({ tool_input: {} });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-format.js'), stdinJson);
+ assert.strictEqual(result.code, 0, 'Should exit 0 for missing file_path');
+ assert.ok(result.stdout.includes('tool_input'), 'Should pass through data');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('exits 0 and passes data when prettier is unavailable', async () => {
+ const stdinJson = JSON.stringify({ tool_input: { file_path: '/nonexistent/path/file.ts' } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-format.js'), stdinJson);
+ assert.strictEqual(result.code, 0, 'Should exit 0 even when prettier fails');
+ assert.ok(result.stdout.includes('tool_input'), 'Should pass through original data');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('finds formatter config in parent dirs without package.json', async () => {
+ const testDir = createTestDir();
+ const rootDir = path.join(testDir, 'config-only-repo');
+ const nestedDir = path.join(rootDir, 'src', 'nested');
+ const filePath = path.join(nestedDir, 'component.ts');
+ const binDir = path.join(testDir, 'bin');
+ const logFile = path.join(testDir, 'formatter.log');
+
+ fs.mkdirSync(nestedDir, { recursive: true });
+ fs.writeFileSync(path.join(rootDir, '.prettierrc'), '{}');
+ fs.writeFileSync(filePath, 'export const value = 1;\n');
+ createCommandShim(binDir, 'npx', logFile);
+
+ const stdinJson = JSON.stringify({ tool_input: { file_path: filePath } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-format.js'), stdinJson, withPrependedPath(binDir));
+
+ assert.strictEqual(result.code, 0, 'Should exit 0 for config-only repo');
+ const logEntries = readCommandLog(logFile);
+ assert.strictEqual(logEntries.length, 1, 'Should invoke formatter once');
+ assert.strictEqual(fs.realpathSync(logEntries[0].cwd), fs.realpathSync(rootDir), 'Should run formatter from config root');
+ assert.deepStrictEqual(logEntries[0].args, ['prettier', '--write', filePath], 'Should use the formatter on the nested file');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('respects CLAUDE_PACKAGE_MANAGER for formatter fallback runner', async () => {
+ const testDir = createTestDir();
+ const rootDir = path.join(testDir, 'pnpm-repo');
+ const filePath = path.join(rootDir, 'index.ts');
+ const binDir = path.join(testDir, 'bin');
+ const logFile = path.join(testDir, 'pnpm.log');
+
+ fs.mkdirSync(rootDir, { recursive: true });
+ fs.writeFileSync(path.join(rootDir, '.prettierrc'), '{}');
+ fs.writeFileSync(filePath, 'export const value = 1;\n');
+ createCommandShim(binDir, 'pnpm', logFile);
+
+ const stdinJson = JSON.stringify({ tool_input: { file_path: filePath } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-format.js'), stdinJson, withPrependedPath(binDir, { CLAUDE_PACKAGE_MANAGER: 'pnpm' }));
+
+ assert.strictEqual(result.code, 0, 'Should exit 0 when pnpm fallback is used');
+ const logEntries = readCommandLog(logFile);
+ assert.strictEqual(logEntries.length, 1, 'Should invoke pnpm fallback runner once');
+ assert.strictEqual(logEntries[0].bin, 'pnpm', 'Should use pnpm runner');
+ assert.deepStrictEqual(logEntries[0].args, ['dlx', 'prettier', '--write', filePath], 'Should use pnpm dlx for fallback formatter execution');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('respects project package-manager config for formatter fallback runner', async () => {
+ const testDir = createTestDir();
+ const rootDir = path.join(testDir, 'bun-repo');
+ const filePath = path.join(rootDir, 'index.ts');
+ const binDir = path.join(testDir, 'bin');
+ const logFile = path.join(testDir, 'bun.log');
+
+ fs.mkdirSync(path.join(rootDir, '.claude'), { recursive: true });
+ fs.writeFileSync(path.join(rootDir, '.claude', 'package-manager.json'), JSON.stringify({ packageManager: 'bun' }));
+ fs.writeFileSync(path.join(rootDir, '.prettierrc'), '{}');
+ fs.writeFileSync(filePath, 'export const value = 1;\n');
+ createCommandShim(binDir, 'bunx', logFile);
+
+ const stdinJson = JSON.stringify({ tool_input: { file_path: filePath } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-format.js'), stdinJson, withPrependedPath(binDir));
+
+ assert.strictEqual(result.code, 0, 'Should exit 0 when project config selects bun');
+ const logEntries = readCommandLog(logFile);
+ assert.strictEqual(logEntries.length, 1, 'Should invoke bunx fallback runner once');
+ assert.strictEqual(logEntries[0].bin, 'bunx', 'Should use bunx runner');
+ assert.deepStrictEqual(logEntries[0].args, ['prettier', '--write', filePath], 'Should use bunx for fallback formatter execution');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
console.log('\npre-bash-dev-server-block.js:');
- if (await asyncTest('allows non-dev commands whose heredoc text mentions npm run dev', async () => {
- const command = [
- 'gh pr create --title "fix: docs" --body "$(cat <<\'EOF\'',
- '## Test plan',
- '- run npm run dev to verify the site starts',
- 'EOF',
- ')"'
- ].join('\n');
- const stdinJson = JSON.stringify({ tool_input: { command } });
- const result = await runScript(path.join(scriptsDir, 'pre-bash-dev-server-block.js'), stdinJson);
-
- assert.strictEqual(result.code, 0, 'Non-dev commands should pass through');
- assert.strictEqual(result.stdout, stdinJson, 'Should preserve original input');
- assert.ok(!result.stderr.includes('BLOCKED'), 'Should not emit a block message');
- })) passed++; else failed++;
-
- if (await asyncTest('blocks bare npm run dev outside tmux on non-Windows platforms', async () => {
- const stdinJson = JSON.stringify({ tool_input: { command: 'npm run dev' } });
- const result = await runScript(path.join(scriptsDir, 'pre-bash-dev-server-block.js'), stdinJson);
-
- if (process.platform === 'win32') {
- assert.strictEqual(result.code, 0, 'Windows path should pass through');
- assert.strictEqual(result.stdout, stdinJson, 'Windows path should preserve original input');
- } else {
- assert.strictEqual(result.code, 2, 'Unix path should block bare dev servers');
- assert.ok(result.stderr.includes('BLOCKED'), 'Should explain why the command was blocked');
- }
- })) passed++; else failed++;
-
- if (await asyncTest('blocks env-wrapped npm run dev outside tmux on non-Windows platforms', async () => {
- const stdinJson = JSON.stringify({ tool_input: { command: '/usr/bin/env npm run dev' } });
- const result = await runScript(path.join(scriptsDir, 'pre-bash-dev-server-block.js'), stdinJson);
-
- if (process.platform === 'win32') {
- assert.strictEqual(result.code, 0, 'Windows path should pass through');
- assert.strictEqual(result.stdout, stdinJson, 'Windows path should preserve original input');
- } else {
- assert.strictEqual(result.code, 2, 'Unix path should block wrapped dev servers');
- assert.ok(result.stderr.includes('BLOCKED'), 'Should explain why the command was blocked');
- }
- })) passed++; else failed++;
-
- if (await asyncTest('blocks nohup-wrapped npm run dev outside tmux on non-Windows platforms', async () => {
- const stdinJson = JSON.stringify({ tool_input: { command: 'nohup npm run dev >/tmp/dev.log 2>&1 &' } });
- const result = await runScript(path.join(scriptsDir, 'pre-bash-dev-server-block.js'), stdinJson);
-
- if (process.platform === 'win32') {
- assert.strictEqual(result.code, 0, 'Windows path should pass through');
- assert.strictEqual(result.stdout, stdinJson, 'Windows path should preserve original input');
- } else {
- assert.strictEqual(result.code, 2, 'Unix path should block wrapped dev servers');
- assert.ok(result.stderr.includes('BLOCKED'), 'Should explain why the command was blocked');
- }
- })) passed++; else failed++;
+ if (
+ await asyncTest('allows non-dev commands whose heredoc text mentions npm run dev', async () => {
+ const command = ['gh pr create --title "fix: docs" --body "$(cat <<\'EOF\'', '## Test plan', '- run npm run dev to verify the site starts', 'EOF', ')"'].join('\n');
+ const stdinJson = JSON.stringify({ tool_input: { command } });
+ const result = await runScript(path.join(scriptsDir, 'pre-bash-dev-server-block.js'), stdinJson);
+
+ assert.strictEqual(result.code, 0, 'Non-dev commands should pass through');
+ assert.strictEqual(result.stdout, stdinJson, 'Should preserve original input');
+ assert.ok(!result.stderr.includes('BLOCKED'), 'Should not emit a block message');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('blocks bare npm run dev outside tmux on non-Windows platforms', async () => {
+ const stdinJson = JSON.stringify({ tool_input: { command: 'npm run dev' } });
+ const result = await runScript(path.join(scriptsDir, 'pre-bash-dev-server-block.js'), stdinJson);
+
+ if (process.platform === 'win32') {
+ assert.strictEqual(result.code, 0, 'Windows path should pass through');
+ assert.strictEqual(result.stdout, stdinJson, 'Windows path should preserve original input');
+ } else {
+ assert.strictEqual(result.code, 2, 'Unix path should block bare dev servers');
+ assert.ok(result.stderr.includes('BLOCKED'), 'Should explain why the command was blocked');
+ }
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('blocks env-wrapped npm run dev outside tmux on non-Windows platforms', async () => {
+ const stdinJson = JSON.stringify({ tool_input: { command: '/usr/bin/env npm run dev' } });
+ const result = await runScript(path.join(scriptsDir, 'pre-bash-dev-server-block.js'), stdinJson);
+
+ if (process.platform === 'win32') {
+ assert.strictEqual(result.code, 0, 'Windows path should pass through');
+ assert.strictEqual(result.stdout, stdinJson, 'Windows path should preserve original input');
+ } else {
+ assert.strictEqual(result.code, 2, 'Unix path should block wrapped dev servers');
+ assert.ok(result.stderr.includes('BLOCKED'), 'Should explain why the command was blocked');
+ }
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('blocks nohup-wrapped npm run dev outside tmux on non-Windows platforms', async () => {
+ const stdinJson = JSON.stringify({ tool_input: { command: 'nohup npm run dev >/tmp/dev.log 2>&1 &' } });
+ const result = await runScript(path.join(scriptsDir, 'pre-bash-dev-server-block.js'), stdinJson);
+
+ if (process.platform === 'win32') {
+ assert.strictEqual(result.code, 0, 'Windows path should pass through');
+ assert.strictEqual(result.stdout, stdinJson, 'Windows path should preserve original input');
+ } else {
+ assert.strictEqual(result.code, 2, 'Unix path should block wrapped dev servers');
+ assert.ok(result.stderr.includes('BLOCKED'), 'Should explain why the command was blocked');
+ }
+ })
+ )
+ passed++;
+ else failed++;
// post-edit-typecheck.js tests
console.log('\npost-edit-typecheck.js:');
- if (await asyncTest('runs without error on empty stdin', async () => {
- const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'));
- assert.strictEqual(result.code, 0, 'Should exit 0 on empty stdin');
- })) passed++; else failed++;
-
- if (await asyncTest('skips non-TypeScript files', async () => {
- const stdinJson = JSON.stringify({ tool_input: { file_path: '/test.js' } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), stdinJson);
- assert.strictEqual(result.code, 0, 'Should exit 0 for non-TS files');
- assert.ok(result.stdout.includes('tool_input'), 'Should pass through stdin data');
- })) passed++; else failed++;
-
- if (await asyncTest('handles nonexistent TS file gracefully', async () => {
- const stdinJson = JSON.stringify({ tool_input: { file_path: '/nonexistent/file.ts' } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), stdinJson);
- assert.strictEqual(result.code, 0, 'Should exit 0 for missing file');
- })) passed++; else failed++;
-
- if (await asyncTest('handles TS file with no tsconfig gracefully', async () => {
- const testDir = createTestDir();
- const testFile = path.join(testDir, 'test.ts');
- fs.writeFileSync(testFile, 'const x: number = 1;');
-
- const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), stdinJson);
- assert.strictEqual(result.code, 0, 'Should exit 0 when no tsconfig found');
- cleanupTestDir(testDir);
- })) passed++; else failed++;
-
- if (await asyncTest('stops tsconfig walk at max depth (20)', async () => {
- // Create a deeply nested directory (>20 levels) with no tsconfig anywhere
- const testDir = createTestDir();
- let deepDir = testDir;
- for (let i = 0; i < 25; i++) {
- deepDir = path.join(deepDir, `d${i}`);
- }
- fs.mkdirSync(deepDir, { recursive: true });
- const testFile = path.join(deepDir, 'deep.ts');
- fs.writeFileSync(testFile, 'const x: number = 1;');
-
- const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
- const startTime = Date.now();
- const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), stdinJson);
- const elapsed = Date.now() - startTime;
-
- assert.strictEqual(result.code, 0, 'Should not hang at depth limit');
- assert.ok(elapsed < 5000, `Should complete quickly at depth limit, took ${elapsed}ms`);
- cleanupTestDir(testDir);
- })) passed++; else failed++;
-
- if (await asyncTest('passes through stdin data on stdout (post-edit-typecheck)', async () => {
- const testDir = createTestDir();
- const testFile = path.join(testDir, 'test.ts');
- fs.writeFileSync(testFile, 'const x: number = 1;');
-
- const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), stdinJson);
- assert.strictEqual(result.code, 0);
- assert.ok(result.stdout.includes('tool_input'), 'Should pass through stdin data on stdout');
- cleanupTestDir(testDir);
- })) passed++; else failed++;
-
- // session-end.js extractSessionSummary tests
- console.log('\nsession-end.js (extractSessionSummary):');
-
- if (await asyncTest('extracts user messages from transcript', async () => {
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
-
- const lines = [
- '{"type":"user","content":"Fix the login bug"}',
- '{"type":"assistant","content":"I will fix it"}',
- '{"type":"user","content":"Also add tests"}',
- ];
- fs.writeFileSync(transcriptPath, lines.join('\n'));
-
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson);
- assert.strictEqual(result.code, 0);
- cleanupTestDir(testDir);
- })) passed++; else failed++;
-
- if (await asyncTest('handles transcript with array content fields', async () => {
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
-
- const lines = [
- '{"type":"user","content":[{"text":"Part 1"},{"text":"Part 2"}]}',
- '{"type":"user","content":"Simple message"}',
- ];
- fs.writeFileSync(transcriptPath, lines.join('\n'));
-
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson);
- assert.strictEqual(result.code, 0, 'Should handle array content without crash');
- cleanupTestDir(testDir);
- })) passed++; else failed++;
-
- if (await asyncTest('extracts tool names and file paths from transcript', async () => {
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
-
- const lines = [
- '{"type":"user","content":"Edit the file"}',
- '{"type":"tool_use","tool_name":"Edit","tool_input":{"file_path":"/src/main.ts"}}',
- '{"type":"tool_use","tool_name":"Read","tool_input":{"file_path":"/src/utils.ts"}}',
- '{"type":"tool_use","tool_name":"Write","tool_input":{"file_path":"/src/new.ts"}}',
- ];
- fs.writeFileSync(transcriptPath, lines.join('\n'));
-
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson);
- assert.strictEqual(result.code, 0);
- // Session file should contain summary with tools used
- assert.ok(
- result.stderr.includes('Created session file') || result.stderr.includes('Updated session file'),
- 'Should create/update session file'
- );
- cleanupTestDir(testDir);
- })) passed++; else failed++;
-
- if (await asyncTest('handles transcript with malformed JSON lines', async () => {
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
-
- const lines = [
- '{"type":"user","content":"Valid message"}',
- 'NOT VALID JSON',
- '{"broken json',
- '{"type":"user","content":"Another valid"}',
- ];
- fs.writeFileSync(transcriptPath, lines.join('\n'));
-
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson);
- assert.strictEqual(result.code, 0, 'Should skip malformed lines gracefully');
- assert.ok(
- result.stderr.includes('unparseable') || result.stderr.includes('Skipped'),
- `Should report parse errors, got: ${result.stderr.substring(0, 200)}`
- );
- cleanupTestDir(testDir);
- })) passed++; else failed++;
-
- if (await asyncTest('handles empty transcript (no user messages)', async () => {
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
-
- // Only tool_use entries, no user messages
- const lines = [
- '{"type":"tool_use","tool_name":"Read","tool_input":{}}',
- '{"type":"assistant","content":"done"}',
- ];
- fs.writeFileSync(transcriptPath, lines.join('\n'));
-
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson);
- assert.strictEqual(result.code, 0, 'Should handle transcript with no user messages');
- cleanupTestDir(testDir);
- })) passed++; else failed++;
-
- if (await asyncTest('truncates long user messages to 200 chars', async () => {
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
-
- const longMsg = 'x'.repeat(500);
- const lines = [
- `{"type":"user","content":"${longMsg}"}`,
- ];
- fs.writeFileSync(transcriptPath, lines.join('\n'));
-
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson);
- assert.strictEqual(result.code, 0, 'Should handle and truncate long messages');
- cleanupTestDir(testDir);
- })) passed++; else failed++;
-
- if (await asyncTest('uses CLAUDE_TRANSCRIPT_PATH env var as fallback', async () => {
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
-
- const lines = [
- '{"type":"user","content":"Fallback test message"}',
- ];
- fs.writeFileSync(transcriptPath, lines.join('\n'));
-
- // Send invalid JSON to stdin so it falls back to env var
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), 'not json', {
- CLAUDE_TRANSCRIPT_PATH: transcriptPath
- });
- assert.strictEqual(result.code, 0, 'Should use env var fallback');
- cleanupTestDir(testDir);
- })) passed++; else failed++;
-
- if (await asyncTest('escapes backticks in user messages in session file', async () => {
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
-
- // User messages with backticks that could break markdown
- const lines = [
- '{"type":"user","content":"Fix the `handleAuth` function in `auth.ts`"}',
- '{"type":"user","content":"Run `npm test` to verify"}',
- ];
- fs.writeFileSync(transcriptPath, lines.join('\n'));
-
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
- HOME: testDir
- });
- assert.strictEqual(result.code, 0, 'Should handle backticks without crash');
-
- // Find the session file in the temp HOME
- const claudeDir = path.join(testDir, '.claude', 'sessions');
- if (fs.existsSync(claudeDir)) {
- const files = fs.readdirSync(claudeDir).filter(f => f.endsWith('.tmp'));
- if (files.length > 0) {
- const content = fs.readFileSync(path.join(claudeDir, files[0]), 'utf8');
- // Backticks should be escaped in the output
- assert.ok(content.includes('\\`'), 'Should escape backticks in session file');
- assert.ok(!content.includes('`handleAuth`'), 'Raw backticks should be escaped');
- }
- }
- cleanupTestDir(testDir);
- })) passed++; else failed++;
-
- if (await asyncTest('session file contains tools used and files modified', async () => {
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
-
- const lines = [
- '{"type":"user","content":"Edit the config"}',
- '{"type":"tool_use","tool_name":"Edit","tool_input":{"file_path":"/src/config.ts"}}',
- '{"type":"tool_use","tool_name":"Read","tool_input":{"file_path":"/src/utils.ts"}}',
- '{"type":"tool_use","tool_name":"Write","tool_input":{"file_path":"/src/new-file.ts"}}',
- ];
- fs.writeFileSync(transcriptPath, lines.join('\n'));
-
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
- HOME: testDir
- });
- assert.strictEqual(result.code, 0);
-
- const claudeDir = path.join(testDir, '.claude', 'sessions');
- if (fs.existsSync(claudeDir)) {
- const files = fs.readdirSync(claudeDir).filter(f => f.endsWith('.tmp'));
- if (files.length > 0) {
- const content = fs.readFileSync(path.join(claudeDir, files[0]), 'utf8');
- // Should contain files modified (Edit and Write, not Read)
- assert.ok(content.includes('/src/config.ts'), 'Should list edited file');
- assert.ok(content.includes('/src/new-file.ts'), 'Should list written file');
- // Should contain tools used
- assert.ok(content.includes('Edit'), 'Should list Edit tool');
- assert.ok(content.includes('Read'), 'Should list Read tool');
- }
- }
- cleanupTestDir(testDir);
- })) passed++; else failed++;
-
- if (await asyncTest('omits Tools Used and Files Modified sections when empty', async () => {
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
-
- // Only user messages, no tool_use entries
- const lines = [
- '{"type":"user","content":"Just chatting"}',
- '{"type":"user","content":"No tools used at all"}',
- ];
- fs.writeFileSync(transcriptPath, lines.join('\n'));
-
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
- HOME: testDir
- });
- assert.strictEqual(result.code, 0);
-
- const claudeDir = path.join(testDir, '.claude', 'sessions');
- if (fs.existsSync(claudeDir)) {
- const files = fs.readdirSync(claudeDir).filter(f => f.endsWith('.tmp'));
- if (files.length > 0) {
- const content = fs.readFileSync(path.join(claudeDir, files[0]), 'utf8');
- assert.ok(content.includes('### Tasks'), 'Should have Tasks section');
- assert.ok(!content.includes('### Files Modified'), 'Should NOT have Files Modified when empty');
- assert.ok(!content.includes('### Tools Used'), 'Should NOT have Tools Used when empty');
- assert.ok(content.includes('Total user messages: 2'), 'Should show correct message count');
+ if (
+ await asyncTest('runs without error on empty stdin', async () => {
+ const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'));
+ assert.strictEqual(result.code, 0, 'Should exit 0 on empty stdin');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('skips non-TypeScript files', async () => {
+ const stdinJson = JSON.stringify({ tool_input: { file_path: '/test.js' } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), stdinJson);
+ assert.strictEqual(result.code, 0, 'Should exit 0 for non-TS files');
+ assert.ok(result.stdout.includes('tool_input'), 'Should pass through stdin data');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('handles nonexistent TS file gracefully', async () => {
+ const stdinJson = JSON.stringify({ tool_input: { file_path: '/nonexistent/file.ts' } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), stdinJson);
+ assert.strictEqual(result.code, 0, 'Should exit 0 for missing file');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('handles TS file with no tsconfig gracefully', async () => {
+ const testDir = createTestDir();
+ const testFile = path.join(testDir, 'test.ts');
+ fs.writeFileSync(testFile, 'const x: number = 1;');
+
+ const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), stdinJson);
+ assert.strictEqual(result.code, 0, 'Should exit 0 when no tsconfig found');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('stops tsconfig walk at max depth (20)', async () => {
+ // Create a deeply nested directory (>20 levels) with no tsconfig anywhere
+ const testDir = createTestDir();
+ let deepDir = testDir;
+ for (let i = 0; i < 25; i++) {
+ deepDir = path.join(deepDir, `d${i}`);
}
- }
- cleanupTestDir(testDir);
- })) passed++; else failed++;
+ fs.mkdirSync(deepDir, { recursive: true });
+ const testFile = path.join(deepDir, 'deep.ts');
+ fs.writeFileSync(testFile, 'const x: number = 1;');
- if (await asyncTest('slices user messages to last 10', async () => {
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
+ const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
+ const startTime = Date.now();
+ const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), stdinJson);
+ const elapsed = Date.now() - startTime;
- // 15 user messages — should keep only last 10
- const lines = [];
- for (let i = 1; i <= 15; i++) {
- lines.push(`{"type":"user","content":"UserMsg_${i}"}`);
- }
- fs.writeFileSync(transcriptPath, lines.join('\n'));
+ assert.strictEqual(result.code, 0, 'Should not hang at depth limit');
+ assert.ok(elapsed < 5000, `Should complete quickly at depth limit, took ${elapsed}ms`);
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('passes through stdin data on stdout (post-edit-typecheck)', async () => {
+ const testDir = createTestDir();
+ const testFile = path.join(testDir, 'test.ts');
+ fs.writeFileSync(testFile, 'const x: number = 1;');
+
+ const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), stdinJson);
+ assert.strictEqual(result.code, 0);
+ assert.ok(result.stdout.includes('tool_input'), 'Should pass through stdin data on stdout');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
- HOME: testDir
- });
- assert.strictEqual(result.code, 0);
-
- const claudeDir = path.join(testDir, '.claude', 'sessions');
- if (fs.existsSync(claudeDir)) {
- const files = fs.readdirSync(claudeDir).filter(f => f.endsWith('.tmp'));
- if (files.length > 0) {
- const content = fs.readFileSync(path.join(claudeDir, files[0]), 'utf8');
- // Should NOT contain first 5 messages (sliced to last 10)
- assert.ok(!content.includes('UserMsg_1\n'), 'Should not include first message (sliced)');
- assert.ok(!content.includes('UserMsg_5\n'), 'Should not include 5th message (sliced)');
- // Should contain messages 6-15
- assert.ok(content.includes('UserMsg_6'), 'Should include 6th message');
- assert.ok(content.includes('UserMsg_15'), 'Should include last message');
- assert.ok(content.includes('Total user messages: 15'), 'Should show total of 15');
- }
- }
- cleanupTestDir(testDir);
- })) passed++; else failed++;
+ // session-end.js extractSessionSummary tests
+ console.log('\nsession-end.js (extractSessionSummary):');
- if (await asyncTest('slices tools to first 20', async () => {
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
+ if (
+ await asyncTest('extracts user messages from transcript', async () => {
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
- // 25 unique tools — should keep only first 20
- const lines = ['{"type":"user","content":"Do stuff"}'];
- for (let i = 1; i <= 25; i++) {
- lines.push(`{"type":"tool_use","tool_name":"Tool${i}","tool_input":{}}`);
- }
- fs.writeFileSync(transcriptPath, lines.join('\n'));
+ const lines = ['{"type":"user","content":"Fix the login bug"}', '{"type":"assistant","content":"I will fix it"}', '{"type":"user","content":"Also add tests"}'];
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
- HOME: testDir
- });
- assert.strictEqual(result.code, 0);
-
- const claudeDir = path.join(testDir, '.claude', 'sessions');
- if (fs.existsSync(claudeDir)) {
- const files = fs.readdirSync(claudeDir).filter(f => f.endsWith('.tmp'));
- if (files.length > 0) {
- const content = fs.readFileSync(path.join(claudeDir, files[0]), 'utf8');
- // Should contain Tool1 through Tool20
- assert.ok(content.includes('Tool1'), 'Should include Tool1');
- assert.ok(content.includes('Tool20'), 'Should include Tool20');
- // Should NOT contain Tool21-25 (sliced)
- assert.ok(!content.includes('Tool21'), 'Should not include Tool21 (sliced to 20)');
- assert.ok(!content.includes('Tool25'), 'Should not include Tool25 (sliced to 20)');
- }
- }
- cleanupTestDir(testDir);
- })) passed++; else failed++;
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson);
+ assert.strictEqual(result.code, 0);
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
- if (await asyncTest('slices files modified to first 30', async () => {
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
+ if (
+ await asyncTest('handles transcript with array content fields', async () => {
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
- // 35 unique files via Edit — should keep only first 30
- const lines = ['{"type":"user","content":"Edit all the things"}'];
- for (let i = 1; i <= 35; i++) {
- lines.push(`{"type":"tool_use","tool_name":"Edit","tool_input":{"file_path":"/src/file${i}.ts"}}`);
- }
- fs.writeFileSync(transcriptPath, lines.join('\n'));
+ const lines = ['{"type":"user","content":[{"text":"Part 1"},{"text":"Part 2"}]}', '{"type":"user","content":"Simple message"}'];
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
- HOME: testDir
- });
- assert.strictEqual(result.code, 0);
-
- const claudeDir = path.join(testDir, '.claude', 'sessions');
- if (fs.existsSync(claudeDir)) {
- const files = fs.readdirSync(claudeDir).filter(f => f.endsWith('.tmp'));
- if (files.length > 0) {
- const content = fs.readFileSync(path.join(claudeDir, files[0]), 'utf8');
- // Should contain file1 through file30
- assert.ok(content.includes('/src/file1.ts'), 'Should include file1');
- assert.ok(content.includes('/src/file30.ts'), 'Should include file30');
- // Should NOT contain file31-35 (sliced)
- assert.ok(!content.includes('/src/file31.ts'), 'Should not include file31 (sliced to 30)');
- assert.ok(!content.includes('/src/file35.ts'), 'Should not include file35 (sliced to 30)');
- }
- }
- cleanupTestDir(testDir);
- })) passed++; else failed++;
-
- if (await asyncTest('parses Claude Code JSONL format (entry.message.content)', async () => {
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
-
- // Claude Code v2.1.41+ JSONL format: user messages nested in entry.message
- const lines = [
- '{"type":"user","message":{"role":"user","content":"Fix the build error"}}',
- '{"type":"user","message":{"role":"user","content":[{"type":"text","text":"Also update tests"}]}}',
- ];
- fs.writeFileSync(transcriptPath, lines.join('\n'));
-
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
- HOME: testDir
- });
- assert.strictEqual(result.code, 0);
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson);
+ assert.strictEqual(result.code, 0, 'Should handle array content without crash');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('extracts tool names and file paths from transcript', async () => {
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
+
+ const lines = [
+ '{"type":"user","content":"Edit the file"}',
+ '{"type":"tool_use","tool_name":"Edit","tool_input":{"file_path":"/src/main.ts"}}',
+ '{"type":"tool_use","tool_name":"Read","tool_input":{"file_path":"/src/utils.ts"}}',
+ '{"type":"tool_use","tool_name":"Write","tool_input":{"file_path":"/src/new.ts"}}'
+ ];
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
+
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson);
+ assert.strictEqual(result.code, 0);
+ // Session file should contain summary with tools used
+ assert.ok(result.stderr.includes('Created session file') || result.stderr.includes('Updated session file'), 'Should create/update session file');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('handles transcript with malformed JSON lines', async () => {
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
+
+ const lines = ['{"type":"user","content":"Valid message"}', 'NOT VALID JSON', '{"broken json', '{"type":"user","content":"Another valid"}'];
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
+
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson);
+ assert.strictEqual(result.code, 0, 'Should skip malformed lines gracefully');
+ assert.ok(result.stderr.includes('unparseable') || result.stderr.includes('Skipped'), `Should report parse errors, got: ${result.stderr.substring(0, 200)}`);
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('handles empty transcript (no user messages)', async () => {
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
+
+ // Only tool_use entries, no user messages
+ const lines = ['{"type":"tool_use","tool_name":"Read","tool_input":{}}', '{"type":"assistant","content":"done"}'];
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
+
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson);
+ assert.strictEqual(result.code, 0, 'Should handle transcript with no user messages');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('truncates long user messages to 200 chars', async () => {
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
+
+ const longMsg = 'x'.repeat(500);
+ const lines = [`{"type":"user","content":"${longMsg}"}`];
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
+
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson);
+ assert.strictEqual(result.code, 0, 'Should handle and truncate long messages');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
- const claudeDir = path.join(testDir, '.claude', 'sessions');
- if (fs.existsSync(claudeDir)) {
- const files = fs.readdirSync(claudeDir).filter(f => f.endsWith('.tmp'));
- if (files.length > 0) {
- const content = fs.readFileSync(path.join(claudeDir, files[0]), 'utf8');
- assert.ok(content.includes('Fix the build error'), 'Should extract string content from message');
- assert.ok(content.includes('Also update tests'), 'Should extract array content from message');
- }
- }
- cleanupTestDir(testDir);
- })) passed++; else failed++;
-
- if (await asyncTest('extracts tool_use from assistant message content blocks', async () => {
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
-
- // Claude Code JSONL: tool uses nested in assistant message content array
- const lines = [
- '{"type":"user","content":"Edit the config"}',
- JSON.stringify({
- type: 'assistant',
- message: {
- role: 'assistant',
- content: [
- { type: 'text', text: 'I will edit the file.' },
- { type: 'tool_use', name: 'Edit', input: { file_path: '/src/app.ts' } },
- { type: 'tool_use', name: 'Write', input: { file_path: '/src/new.ts' } },
- ]
- }
- }),
- ];
- fs.writeFileSync(transcriptPath, lines.join('\n'));
+ if (
+ await asyncTest('uses CLAUDE_TRANSCRIPT_PATH env var as fallback', async () => {
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
- HOME: testDir
- });
- assert.strictEqual(result.code, 0);
+ const lines = ['{"type":"user","content":"Fallback test message"}'];
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
- const claudeDir = path.join(testDir, '.claude', 'sessions');
- if (fs.existsSync(claudeDir)) {
- const files = fs.readdirSync(claudeDir).filter(f => f.endsWith('.tmp'));
- if (files.length > 0) {
- const content = fs.readFileSync(path.join(claudeDir, files[0]), 'utf8');
- assert.ok(content.includes('Edit'), 'Should extract Edit tool from content blocks');
- assert.ok(content.includes('/src/app.ts'), 'Should extract file path from Edit block');
- assert.ok(content.includes('/src/new.ts'), 'Should extract file path from Write block');
- }
- }
- cleanupTestDir(testDir);
- })) passed++; else failed++;
+ // Send invalid JSON to stdin so it falls back to env var
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), 'not json', {
+ CLAUDE_TRANSCRIPT_PATH: transcriptPath
+ });
+ assert.strictEqual(result.code, 0, 'Should use env var fallback');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
- // hooks.json validation
- console.log('\nhooks.json Validation:');
+ if (
+ await asyncTest('escapes backticks in user messages in session file', async () => {
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
- if (test('hooks.json is valid JSON', () => {
- const hooksPath = path.join(__dirname, '..', '..', 'hooks', 'hooks.json');
- const content = fs.readFileSync(hooksPath, 'utf8');
- JSON.parse(content); // Will throw if invalid
- })) passed++; else failed++;
-
- if (test('hooks.json has required event types', () => {
- const hooksPath = path.join(__dirname, '..', '..', 'hooks', 'hooks.json');
- const hooks = JSON.parse(fs.readFileSync(hooksPath, 'utf8'));
-
- assert.ok(hooks.hooks.PreToolUse, 'Should have PreToolUse hooks');
- assert.ok(hooks.hooks.PostToolUse, 'Should have PostToolUse hooks');
- assert.ok(hooks.hooks.SessionStart, 'Should have SessionStart hooks');
- assert.ok(hooks.hooks.SessionEnd, 'Should have SessionEnd hooks');
- assert.ok(hooks.hooks.Stop, 'Should have Stop hooks');
- assert.ok(hooks.hooks.PreCompact, 'Should have PreCompact hooks');
- })) passed++; else failed++;
-
- if (test('all hook commands use node or approved shell wrappers', () => {
- const hooksPath = path.join(__dirname, '..', '..', 'hooks', 'hooks.json');
- const hooks = JSON.parse(fs.readFileSync(hooksPath, 'utf8'));
-
- const checkHooks = (hookArray) => {
- for (const entry of hookArray) {
- for (const hook of entry.hooks) {
- if (hook.type === 'command') {
- const isNode = hook.command.startsWith('node');
- const isSkillScript = hook.command.includes('/skills/') && (
- /^(bash|sh)\s/.test(hook.command) ||
- hook.command.startsWith('${CLAUDE_PLUGIN_ROOT}/skills/')
- );
- const isHookShellWrapper = /^(bash|sh)\s+["']?\$\{CLAUDE_PLUGIN_ROOT\}\/scripts\/hooks\/run-with-flags-shell\.sh/.test(hook.command);
- const isSessionStartFallback = hook.command.startsWith('bash -lc') && hook.command.includes('run-with-flags.js');
- assert.ok(
- isNode || isSkillScript || isHookShellWrapper || isSessionStartFallback,
- `Hook command should use node or approved shell wrapper: ${hook.command.substring(0, 100)}...`
- );
- }
+ // User messages with backticks that could break markdown
+ const lines = ['{"type":"user","content":"Fix the `handleAuth` function in `auth.ts`"}', '{"type":"user","content":"Run `npm test` to verify"}'];
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
+
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
+ HOME: testDir
+ });
+ assert.strictEqual(result.code, 0, 'Should handle backticks without crash');
+
+ // Find the session file in the temp HOME
+ const claudeDir = path.join(testDir, '.claude', 'sessions');
+ if (fs.existsSync(claudeDir)) {
+ const files = fs.readdirSync(claudeDir).filter(f => f.endsWith('.tmp'));
+ if (files.length > 0) {
+ const content = fs.readFileSync(path.join(claudeDir, files[0]), 'utf8');
+ // Backticks should be escaped in the output
+ assert.ok(content.includes('\\`'), 'Should escape backticks in session file');
+ assert.ok(!content.includes('`handleAuth`'), 'Raw backticks should be escaped');
}
}
- };
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('session file contains tools used and files modified', async () => {
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
+
+ const lines = [
+ '{"type":"user","content":"Edit the config"}',
+ '{"type":"tool_use","tool_name":"Edit","tool_input":{"file_path":"/src/config.ts"}}',
+ '{"type":"tool_use","tool_name":"Read","tool_input":{"file_path":"/src/utils.ts"}}',
+ '{"type":"tool_use","tool_name":"Write","tool_input":{"file_path":"/src/new-file.ts"}}'
+ ];
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
+
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
+ HOME: testDir
+ });
+ assert.strictEqual(result.code, 0);
- for (const [, hookArray] of Object.entries(hooks.hooks)) {
- checkHooks(hookArray);
- }
- })) passed++; else failed++;
-
- if (test('script references use CLAUDE_PLUGIN_ROOT variable (except SessionStart fallback)', () => {
- const hooksPath = path.join(__dirname, '..', '..', 'hooks', 'hooks.json');
- const hooks = JSON.parse(fs.readFileSync(hooksPath, 'utf8'));
-
- const checkHooks = (hookArray) => {
- for (const entry of hookArray) {
- for (const hook of entry.hooks) {
- if (hook.type === 'command' && hook.command.includes('scripts/hooks/')) {
- // Check for the literal string "${CLAUDE_PLUGIN_ROOT}" in the command
- const isSessionStartFallback = hook.command.startsWith('bash -lc') && hook.command.includes('run-with-flags.js');
- const hasPluginRoot = hook.command.includes('${CLAUDE_PLUGIN_ROOT}') || isSessionStartFallback;
- assert.ok(
- hasPluginRoot,
- `Script paths should use CLAUDE_PLUGIN_ROOT: ${hook.command.substring(0, 80)}...`
- );
- }
+ const claudeDir = path.join(testDir, '.claude', 'sessions');
+ if (fs.existsSync(claudeDir)) {
+ const files = fs.readdirSync(claudeDir).filter(f => f.endsWith('.tmp'));
+ if (files.length > 0) {
+ const content = fs.readFileSync(path.join(claudeDir, files[0]), 'utf8');
+ // Should contain files modified (Edit and Write, not Read)
+ assert.ok(content.includes('/src/config.ts'), 'Should list edited file');
+ assert.ok(content.includes('/src/new-file.ts'), 'Should list written file');
+ // Should contain tools used
+ assert.ok(content.includes('Edit'), 'Should list Edit tool');
+ assert.ok(content.includes('Read'), 'Should list Read tool');
}
}
- };
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
- for (const [, hookArray] of Object.entries(hooks.hooks)) {
- checkHooks(hookArray);
- }
- })) passed++; else failed++;
+ if (
+ await asyncTest('omits Tools Used and Files Modified sections when empty', async () => {
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
- // plugin.json validation
- console.log('\nplugin.json Validation:');
-
- if (test('plugin.json does NOT have explicit hooks declaration', () => {
- // Claude Code automatically loads hooks/hooks.json by convention.
- // Explicitly declaring it in plugin.json causes a duplicate detection error.
- // See: https://github.com/affaan-m/everything-claude-code/issues/103
- const pluginPath = path.join(__dirname, '..', '..', '.claude-plugin', 'plugin.json');
- const plugin = JSON.parse(fs.readFileSync(pluginPath, 'utf8'));
-
- assert.ok(
- !plugin.hooks,
- 'plugin.json should NOT have "hooks" field - Claude Code auto-loads hooks/hooks.json'
- );
- })) passed++; else failed++;
-
- // ─── evaluate-session.js tests ───
- console.log('\nevaluate-session.js:');
-
- if (await asyncTest('skips when no transcript_path in stdin', async () => {
- const result = await runScript(path.join(scriptsDir, 'evaluate-session.js'), '{}');
- assert.strictEqual(result.code, 0, 'Should exit 0 (non-blocking)');
- })) passed++; else failed++;
-
- if (await asyncTest('skips when transcript file does not exist', async () => {
- const stdinJson = JSON.stringify({ transcript_path: '/tmp/nonexistent-transcript-12345.jsonl' });
- const result = await runScript(path.join(scriptsDir, 'evaluate-session.js'), stdinJson);
- assert.strictEqual(result.code, 0, 'Should exit 0 when file missing');
- })) passed++; else failed++;
-
- if (await asyncTest('skips short sessions (< 10 user messages)', async () => {
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'short.jsonl');
- // Only 3 user messages — below the default threshold of 10
- const lines = [
- '{"type":"user","content":"msg1"}',
- '{"type":"user","content":"msg2"}',
- '{"type":"user","content":"msg3"}',
- ];
- fs.writeFileSync(transcriptPath, lines.join('\n'));
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(path.join(scriptsDir, 'evaluate-session.js'), stdinJson);
- assert.strictEqual(result.code, 0);
- assert.ok(result.stderr.includes('too short'), 'Should log "too short" message');
- cleanupTestDir(testDir);
- })) passed++; else failed++;
-
- if (await asyncTest('evaluates long sessions (>= 10 user messages)', async () => {
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'long.jsonl');
- // 12 user messages — above the default threshold
- const lines = [];
- for (let i = 0; i < 12; i++) {
- lines.push(`{"type":"user","content":"message ${i}"}`);
- }
- fs.writeFileSync(transcriptPath, lines.join('\n'));
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(path.join(scriptsDir, 'evaluate-session.js'), stdinJson);
- assert.strictEqual(result.code, 0);
- assert.ok(result.stderr.includes('12 messages'), 'Should report message count');
- assert.ok(result.stderr.includes('evaluate'), 'Should signal evaluation');
- cleanupTestDir(testDir);
- })) passed++; else failed++;
-
- if (await asyncTest('handles malformed stdin JSON (falls back to env var)', async () => {
- const result = await runScript(
- path.join(scriptsDir, 'evaluate-session.js'),
- 'not json at all',
- { CLAUDE_TRANSCRIPT_PATH: '' }
- );
- // No valid transcript path from either source → exit 0
- assert.strictEqual(result.code, 0);
- })) passed++; else failed++;
+ // Only user messages, no tool_use entries
+ const lines = ['{"type":"user","content":"Just chatting"}', '{"type":"user","content":"No tools used at all"}'];
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
- // ─── suggest-compact.js tests ───
- console.log('\nsuggest-compact.js:');
-
- if (await asyncTest('increments tool counter on each invocation', async () => {
- const sessionId = `test-counter-${Date.now()}`;
- const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
- try {
- // First invocation → count = 1
- await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
- CLAUDE_SESSION_ID: sessionId
- });
- let val = parseInt(fs.readFileSync(counterFile, 'utf8').trim(), 10);
- assert.strictEqual(val, 1, 'First call should write count 1');
-
- // Second invocation → count = 2
- await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
- CLAUDE_SESSION_ID: sessionId
- });
- val = parseInt(fs.readFileSync(counterFile, 'utf8').trim(), 10);
- assert.strictEqual(val, 2, 'Second call should write count 2');
- } finally {
- try { fs.unlinkSync(counterFile); } catch { /* ignore */ }
- }
- })) passed++; else failed++;
-
- if (await asyncTest('suggests compact at exact threshold', async () => {
- const sessionId = `test-threshold-${Date.now()}`;
- const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
- try {
- // Pre-seed counter at threshold - 1 so next call hits threshold
- fs.writeFileSync(counterFile, '4');
- const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
- CLAUDE_SESSION_ID: sessionId,
- COMPACT_THRESHOLD: '5'
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
+ HOME: testDir
});
assert.strictEqual(result.code, 0);
- assert.ok(result.stderr.includes('5 tool calls reached'), 'Should suggest compact at threshold');
- } finally {
- try { fs.unlinkSync(counterFile); } catch { /* ignore */ }
- }
- })) passed++; else failed++;
-
- if (await asyncTest('suggests at periodic intervals after threshold', async () => {
- const sessionId = `test-periodic-${Date.now()}`;
- const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
- try {
- // Pre-seed at 29 so next call = 30 (threshold 5 + 25 = 30)
- // (30 - 5) % 25 === 0 → should trigger periodic suggestion
- fs.writeFileSync(counterFile, '29');
- const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
- CLAUDE_SESSION_ID: sessionId,
- COMPACT_THRESHOLD: '5'
+
+ const claudeDir = path.join(testDir, '.claude', 'sessions');
+ if (fs.existsSync(claudeDir)) {
+ const files = fs.readdirSync(claudeDir).filter(f => f.endsWith('.tmp'));
+ if (files.length > 0) {
+ const content = fs.readFileSync(path.join(claudeDir, files[0]), 'utf8');
+ assert.ok(content.includes('### Tasks'), 'Should have Tasks section');
+ assert.ok(!content.includes('### Files Modified'), 'Should NOT have Files Modified when empty');
+ assert.ok(!content.includes('### Tools Used'), 'Should NOT have Tools Used when empty');
+ assert.ok(content.includes('Total user messages: 2'), 'Should show correct message count');
+ }
+ }
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('slices user messages to last 10', async () => {
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
+
+ // 15 user messages — should keep only last 10
+ const lines = [];
+ for (let i = 1; i <= 15; i++) {
+ lines.push(`{"type":"user","content":"UserMsg_${i}"}`);
+ }
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
+
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
+ HOME: testDir
});
assert.strictEqual(result.code, 0);
- assert.ok(result.stderr.includes('30 tool calls'), 'Should suggest at threshold + 25n intervals');
- } finally {
- try { fs.unlinkSync(counterFile); } catch { /* ignore */ }
- }
- })) passed++; else failed++;
- if (await asyncTest('does not suggest below threshold', async () => {
- const sessionId = `test-below-${Date.now()}`;
- const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
- try {
- fs.writeFileSync(counterFile, '2');
- const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
- CLAUDE_SESSION_ID: sessionId,
- COMPACT_THRESHOLD: '50'
+ const claudeDir = path.join(testDir, '.claude', 'sessions');
+ if (fs.existsSync(claudeDir)) {
+ const files = fs.readdirSync(claudeDir).filter(f => f.endsWith('.tmp'));
+ if (files.length > 0) {
+ const content = fs.readFileSync(path.join(claudeDir, files[0]), 'utf8');
+ // Should NOT contain first 5 messages (sliced to last 10)
+ assert.ok(!content.includes('UserMsg_1\n'), 'Should not include first message (sliced)');
+ assert.ok(!content.includes('UserMsg_5\n'), 'Should not include 5th message (sliced)');
+ // Should contain messages 6-15
+ assert.ok(content.includes('UserMsg_6'), 'Should include 6th message');
+ assert.ok(content.includes('UserMsg_15'), 'Should include last message');
+ assert.ok(content.includes('Total user messages: 15'), 'Should show total of 15');
+ }
+ }
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('slices tools to first 20', async () => {
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
+
+ // 25 unique tools — should keep only first 20
+ const lines = ['{"type":"user","content":"Do stuff"}'];
+ for (let i = 1; i <= 25; i++) {
+ lines.push(`{"type":"tool_use","tool_name":"Tool${i}","tool_input":{}}`);
+ }
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
+
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
+ HOME: testDir
});
assert.strictEqual(result.code, 0);
- assert.ok(!result.stderr.includes('tool calls reached'), 'Should not suggest below threshold');
- assert.ok(!result.stderr.includes('checkpoint'), 'Should not suggest checkpoint');
- } finally {
- try { fs.unlinkSync(counterFile); } catch { /* ignore */ }
- }
- })) passed++; else failed++;
-
- if (await asyncTest('resets counter when file contains huge overflow number', async () => {
- const sessionId = `test-overflow-${Date.now()}`;
- const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
- try {
- // Write a value that passes Number.isFinite() but exceeds 1000000 clamp
- fs.writeFileSync(counterFile, '999999999999');
- const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
- CLAUDE_SESSION_ID: sessionId
+
+ const claudeDir = path.join(testDir, '.claude', 'sessions');
+ if (fs.existsSync(claudeDir)) {
+ const files = fs.readdirSync(claudeDir).filter(f => f.endsWith('.tmp'));
+ if (files.length > 0) {
+ const content = fs.readFileSync(path.join(claudeDir, files[0]), 'utf8');
+ // Should contain Tool1 through Tool20
+ assert.ok(content.includes('Tool1'), 'Should include Tool1');
+ assert.ok(content.includes('Tool20'), 'Should include Tool20');
+ // Should NOT contain Tool21-25 (sliced)
+ assert.ok(!content.includes('Tool21'), 'Should not include Tool21 (sliced to 20)');
+ assert.ok(!content.includes('Tool25'), 'Should not include Tool25 (sliced to 20)');
+ }
+ }
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('slices files modified to first 30', async () => {
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
+
+ // 35 unique files via Edit — should keep only first 30
+ const lines = ['{"type":"user","content":"Edit all the things"}'];
+ for (let i = 1; i <= 35; i++) {
+ lines.push(`{"type":"tool_use","tool_name":"Edit","tool_input":{"file_path":"/src/file${i}.ts"}}`);
+ }
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
+
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
+ HOME: testDir
});
assert.strictEqual(result.code, 0);
- // Should reset to 1 because 999999999999 > 1000000
- const newCount = parseInt(fs.readFileSync(counterFile, 'utf8').trim(), 10);
- assert.strictEqual(newCount, 1, 'Should reset to 1 on overflow value');
- } finally {
- try { fs.unlinkSync(counterFile); } catch { /* ignore */ }
- }
- })) passed++; else failed++;
- if (await asyncTest('resets counter when file contains negative number', async () => {
- const sessionId = `test-negative-${Date.now()}`;
- const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
- try {
- fs.writeFileSync(counterFile, '-42');
- const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
- CLAUDE_SESSION_ID: sessionId
+ const claudeDir = path.join(testDir, '.claude', 'sessions');
+ if (fs.existsSync(claudeDir)) {
+ const files = fs.readdirSync(claudeDir).filter(f => f.endsWith('.tmp'));
+ if (files.length > 0) {
+ const content = fs.readFileSync(path.join(claudeDir, files[0]), 'utf8');
+ // Should contain file1 through file30
+ assert.ok(content.includes('/src/file1.ts'), 'Should include file1');
+ assert.ok(content.includes('/src/file30.ts'), 'Should include file30');
+ // Should NOT contain file31-35 (sliced)
+ assert.ok(!content.includes('/src/file31.ts'), 'Should not include file31 (sliced to 30)');
+ assert.ok(!content.includes('/src/file35.ts'), 'Should not include file35 (sliced to 30)');
+ }
+ }
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('parses Claude Code JSONL format (entry.message.content)', async () => {
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
+
+ // Claude Code v2.1.41+ JSONL format: user messages nested in entry.message
+ const lines = ['{"type":"user","message":{"role":"user","content":"Fix the build error"}}', '{"type":"user","message":{"role":"user","content":[{"type":"text","text":"Also update tests"}]}}'];
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
+
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
+ HOME: testDir
});
assert.strictEqual(result.code, 0);
- const newCount = parseInt(fs.readFileSync(counterFile, 'utf8').trim(), 10);
- assert.strictEqual(newCount, 1, 'Should reset to 1 on negative value');
- } finally {
- try { fs.unlinkSync(counterFile); } catch { /* ignore */ }
- }
- })) passed++; else failed++;
- if (await asyncTest('handles COMPACT_THRESHOLD of zero (falls back to 50)', async () => {
- const sessionId = `test-zero-thresh-${Date.now()}`;
- const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
- try {
- fs.writeFileSync(counterFile, '49');
- const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
- CLAUDE_SESSION_ID: sessionId,
- COMPACT_THRESHOLD: '0'
+ const claudeDir = path.join(testDir, '.claude', 'sessions');
+ if (fs.existsSync(claudeDir)) {
+ const files = fs.readdirSync(claudeDir).filter(f => f.endsWith('.tmp'));
+ if (files.length > 0) {
+ const content = fs.readFileSync(path.join(claudeDir, files[0]), 'utf8');
+ assert.ok(content.includes('Fix the build error'), 'Should extract string content from message');
+ assert.ok(content.includes('Also update tests'), 'Should extract array content from message');
+ }
+ }
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('extracts tool_use from assistant message content blocks', async () => {
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
+
+ // Claude Code JSONL: tool uses nested in assistant message content array
+ const lines = [
+ '{"type":"user","content":"Edit the config"}',
+ JSON.stringify({
+ type: 'assistant',
+ message: {
+ role: 'assistant',
+ content: [
+ { type: 'text', text: 'I will edit the file.' },
+ { type: 'tool_use', name: 'Edit', input: { file_path: '/src/app.ts' } },
+ { type: 'tool_use', name: 'Write', input: { file_path: '/src/new.ts' } }
+ ]
+ }
+ })
+ ];
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
+
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
+ HOME: testDir
});
assert.strictEqual(result.code, 0);
- assert.ok(result.stderr.includes('50 tool calls reached'), 'Zero threshold should fall back to 50');
- } finally {
- try { fs.unlinkSync(counterFile); } catch { /* ignore */ }
- }
- })) passed++; else failed++;
- if (await asyncTest('handles invalid COMPACT_THRESHOLD (falls back to 50)', async () => {
- const sessionId = `test-invalid-thresh-${Date.now()}`;
- const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
- try {
- // Pre-seed at 49 so next call = 50 (the fallback default)
- fs.writeFileSync(counterFile, '49');
- const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
- CLAUDE_SESSION_ID: sessionId,
- COMPACT_THRESHOLD: 'not-a-number'
- });
+ const claudeDir = path.join(testDir, '.claude', 'sessions');
+ if (fs.existsSync(claudeDir)) {
+ const files = fs.readdirSync(claudeDir).filter(f => f.endsWith('.tmp'));
+ if (files.length > 0) {
+ const content = fs.readFileSync(path.join(claudeDir, files[0]), 'utf8');
+ assert.ok(content.includes('Edit'), 'Should extract Edit tool from content blocks');
+ assert.ok(content.includes('/src/app.ts'), 'Should extract file path from Edit block');
+ assert.ok(content.includes('/src/new.ts'), 'Should extract file path from Write block');
+ }
+ }
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
+
+ // hooks.json validation
+ console.log('\nhooks.json Validation:');
+
+ if (
+ test('hooks.json is valid JSON', () => {
+ const hooksPath = path.join(__dirname, '..', '..', 'hooks', 'hooks.json');
+ const content = fs.readFileSync(hooksPath, 'utf8');
+ JSON.parse(content); // Will throw if invalid
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ test('hooks.json has required event types', () => {
+ const hooksPath = path.join(__dirname, '..', '..', 'hooks', 'hooks.json');
+ const hooks = JSON.parse(fs.readFileSync(hooksPath, 'utf8'));
+
+ assert.ok(hooks.hooks.PreToolUse, 'Should have PreToolUse hooks');
+ assert.ok(hooks.hooks.PostToolUse, 'Should have PostToolUse hooks');
+ assert.ok(hooks.hooks.SessionStart, 'Should have SessionStart hooks');
+ assert.ok(hooks.hooks.SessionEnd, 'Should have SessionEnd hooks');
+ assert.ok(hooks.hooks.Stop, 'Should have Stop hooks');
+ assert.ok(hooks.hooks.PreCompact, 'Should have PreCompact hooks');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ test('all hook commands use node or approved shell wrappers', () => {
+ const hooksPath = path.join(__dirname, '..', '..', 'hooks', 'hooks.json');
+ const hooks = JSON.parse(fs.readFileSync(hooksPath, 'utf8'));
+
+ const checkHooks = hookArray => {
+ for (const entry of hookArray) {
+ for (const hook of entry.hooks) {
+ if (hook.type === 'command') {
+ const isNode = hook.command.startsWith('node');
+ const isSkillScript = hook.command.includes('/skills/') && (/^(bash|sh)\s/.test(hook.command) || hook.command.startsWith('${CLAUDE_PLUGIN_ROOT}/skills/'));
+ const isHookShellWrapper = /^(bash|sh)\s+["']?\$\{CLAUDE_PLUGIN_ROOT\}\/scripts\/hooks\/run-with-flags-shell\.sh/.test(hook.command);
+ const isSessionStartFallback = hook.command.startsWith('bash -lc') && hook.command.includes('run-with-flags.js');
+ assert.ok(isNode || isSkillScript || isHookShellWrapper || isSessionStartFallback, `Hook command should use node or approved shell wrapper: ${hook.command.substring(0, 100)}...`);
+ }
+ }
+ }
+ };
+
+ for (const [, hookArray] of Object.entries(hooks.hooks)) {
+ checkHooks(hookArray);
+ }
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ test('script references use CLAUDE_PLUGIN_ROOT variable (except SessionStart fallback)', () => {
+ const hooksPath = path.join(__dirname, '..', '..', 'hooks', 'hooks.json');
+ const hooks = JSON.parse(fs.readFileSync(hooksPath, 'utf8'));
+
+ const checkHooks = hookArray => {
+ for (const entry of hookArray) {
+ for (const hook of entry.hooks) {
+ if (hook.type === 'command' && hook.command.includes('scripts/hooks/')) {
+ // Check for the literal string "${CLAUDE_PLUGIN_ROOT}" in the command
+ const isSessionStartFallback = hook.command.startsWith('bash -lc') && hook.command.includes('run-with-flags.js');
+ const hasPluginRoot = hook.command.includes('${CLAUDE_PLUGIN_ROOT}') || isSessionStartFallback;
+ assert.ok(hasPluginRoot, `Script paths should use CLAUDE_PLUGIN_ROOT: ${hook.command.substring(0, 80)}...`);
+ }
+ }
+ }
+ };
+
+ for (const [, hookArray] of Object.entries(hooks.hooks)) {
+ checkHooks(hookArray);
+ }
+ })
+ )
+ passed++;
+ else failed++;
+
+ // plugin.json validation
+ console.log('\nplugin.json Validation:');
+
+ if (
+ test('plugin.json does NOT have explicit hooks declaration', () => {
+ // Claude Code automatically loads hooks/hooks.json by convention.
+ // Explicitly declaring it in plugin.json causes a duplicate detection error.
+ // See: https://github.com/affaan-m/everything-claude-code/issues/103
+ const pluginPath = path.join(__dirname, '..', '..', '.claude-plugin', 'plugin.json');
+ const plugin = JSON.parse(fs.readFileSync(pluginPath, 'utf8'));
+
+ assert.ok(!plugin.hooks, 'plugin.json should NOT have "hooks" field - Claude Code auto-loads hooks/hooks.json');
+ })
+ )
+ passed++;
+ else failed++;
+
+ // ─── evaluate-session.js tests ───
+ console.log('\nevaluate-session.js:');
+
+ if (
+ await asyncTest('skips when no transcript_path in stdin', async () => {
+ const result = await runScript(path.join(scriptsDir, 'evaluate-session.js'), '{}');
+ assert.strictEqual(result.code, 0, 'Should exit 0 (non-blocking)');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('skips when transcript file does not exist', async () => {
+ const stdinJson = JSON.stringify({ transcript_path: '/tmp/nonexistent-transcript-12345.jsonl' });
+ const result = await runScript(path.join(scriptsDir, 'evaluate-session.js'), stdinJson);
+ assert.strictEqual(result.code, 0, 'Should exit 0 when file missing');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('skips short sessions (< 10 user messages)', async () => {
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'short.jsonl');
+ // Only 3 user messages — below the default threshold of 10
+ const lines = ['{"type":"user","content":"msg1"}', '{"type":"user","content":"msg2"}', '{"type":"user","content":"msg3"}'];
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(path.join(scriptsDir, 'evaluate-session.js'), stdinJson);
assert.strictEqual(result.code, 0);
- assert.ok(result.stderr.includes('50 tool calls reached'), 'Should use default threshold of 50');
- } finally {
- try { fs.unlinkSync(counterFile); } catch { /* ignore */ }
- }
- })) passed++; else failed++;
+ assert.ok(result.stderr.includes('too short'), 'Should log "too short" message');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('evaluates long sessions (>= 10 user messages)', async () => {
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'long.jsonl');
+ // 12 user messages — above the default threshold
+ const lines = [];
+ for (let i = 0; i < 12; i++) {
+ lines.push(`{"type":"user","content":"message ${i}"}`);
+ }
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(path.join(scriptsDir, 'evaluate-session.js'), stdinJson);
+ assert.strictEqual(result.code, 0);
+ assert.ok(result.stderr.includes('12 messages'), 'Should report message count');
+ assert.ok(result.stderr.includes('evaluate'), 'Should signal evaluation');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('handles malformed stdin JSON (falls back to env var)', async () => {
+ const result = await runScript(path.join(scriptsDir, 'evaluate-session.js'), 'not json at all', { CLAUDE_TRANSCRIPT_PATH: '' });
+ // No valid transcript path from either source → exit 0
+ assert.strictEqual(result.code, 0);
+ })
+ )
+ passed++;
+ else failed++;
+
+ // ─── suggest-compact.js tests ───
+ console.log('\nsuggest-compact.js:');
+
+ if (
+ await asyncTest('increments tool counter on each invocation', async () => {
+ const sessionId = `test-counter-${Date.now()}`;
+ const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
+ try {
+ // First invocation → count = 1
+ await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
+ CLAUDE_SESSION_ID: sessionId
+ });
+ let val = parseInt(fs.readFileSync(counterFile, 'utf8').trim(), 10);
+ assert.strictEqual(val, 1, 'First call should write count 1');
+
+ // Second invocation → count = 2
+ await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
+ CLAUDE_SESSION_ID: sessionId
+ });
+ val = parseInt(fs.readFileSync(counterFile, 'utf8').trim(), 10);
+ assert.strictEqual(val, 2, 'Second call should write count 2');
+ } finally {
+ try {
+ fs.unlinkSync(counterFile);
+ } catch {
+ /* ignore */
+ }
+ }
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('suggests compact at exact threshold', async () => {
+ const sessionId = `test-threshold-${Date.now()}`;
+ const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
+ try {
+ // Pre-seed counter at threshold - 1 so next call hits threshold
+ fs.writeFileSync(counterFile, '4');
+ const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
+ CLAUDE_SESSION_ID: sessionId,
+ COMPACT_THRESHOLD: '5'
+ });
+ assert.strictEqual(result.code, 0);
+ assert.ok(result.stderr.includes('5 tool calls reached'), 'Should suggest compact at threshold');
+ } finally {
+ try {
+ fs.unlinkSync(counterFile);
+ } catch {
+ /* ignore */
+ }
+ }
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('suggests at periodic intervals after threshold', async () => {
+ const sessionId = `test-periodic-${Date.now()}`;
+ const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
+ try {
+ // Pre-seed at 29 so next call = 30 (threshold 5 + 25 = 30)
+ // (30 - 5) % 25 === 0 → should trigger periodic suggestion
+ fs.writeFileSync(counterFile, '29');
+ const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
+ CLAUDE_SESSION_ID: sessionId,
+ COMPACT_THRESHOLD: '5'
+ });
+ assert.strictEqual(result.code, 0);
+ assert.ok(result.stderr.includes('30 tool calls'), 'Should suggest at threshold + 25n intervals');
+ } finally {
+ try {
+ fs.unlinkSync(counterFile);
+ } catch {
+ /* ignore */
+ }
+ }
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('does not suggest below threshold', async () => {
+ const sessionId = `test-below-${Date.now()}`;
+ const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
+ try {
+ fs.writeFileSync(counterFile, '2');
+ const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
+ CLAUDE_SESSION_ID: sessionId,
+ COMPACT_THRESHOLD: '50'
+ });
+ assert.strictEqual(result.code, 0);
+ assert.ok(!result.stderr.includes('tool calls reached'), 'Should not suggest below threshold');
+ assert.ok(!result.stderr.includes('checkpoint'), 'Should not suggest checkpoint');
+ } finally {
+ try {
+ fs.unlinkSync(counterFile);
+ } catch {
+ /* ignore */
+ }
+ }
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('resets counter when file contains huge overflow number', async () => {
+ const sessionId = `test-overflow-${Date.now()}`;
+ const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
+ try {
+ // Write a value that passes Number.isFinite() but exceeds 1000000 clamp
+ fs.writeFileSync(counterFile, '999999999999');
+ const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
+ CLAUDE_SESSION_ID: sessionId
+ });
+ assert.strictEqual(result.code, 0);
+ // Should reset to 1 because 999999999999 > 1000000
+ const newCount = parseInt(fs.readFileSync(counterFile, 'utf8').trim(), 10);
+ assert.strictEqual(newCount, 1, 'Should reset to 1 on overflow value');
+ } finally {
+ try {
+ fs.unlinkSync(counterFile);
+ } catch {
+ /* ignore */
+ }
+ }
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('resets counter when file contains negative number', async () => {
+ const sessionId = `test-negative-${Date.now()}`;
+ const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
+ try {
+ fs.writeFileSync(counterFile, '-42');
+ const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
+ CLAUDE_SESSION_ID: sessionId
+ });
+ assert.strictEqual(result.code, 0);
+ const newCount = parseInt(fs.readFileSync(counterFile, 'utf8').trim(), 10);
+ assert.strictEqual(newCount, 1, 'Should reset to 1 on negative value');
+ } finally {
+ try {
+ fs.unlinkSync(counterFile);
+ } catch {
+ /* ignore */
+ }
+ }
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('handles COMPACT_THRESHOLD of zero (falls back to 50)', async () => {
+ const sessionId = `test-zero-thresh-${Date.now()}`;
+ const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
+ try {
+ fs.writeFileSync(counterFile, '49');
+ const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
+ CLAUDE_SESSION_ID: sessionId,
+ COMPACT_THRESHOLD: '0'
+ });
+ assert.strictEqual(result.code, 0);
+ assert.ok(result.stderr.includes('50 tool calls reached'), 'Zero threshold should fall back to 50');
+ } finally {
+ try {
+ fs.unlinkSync(counterFile);
+ } catch {
+ /* ignore */
+ }
+ }
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('handles invalid COMPACT_THRESHOLD (falls back to 50)', async () => {
+ const sessionId = `test-invalid-thresh-${Date.now()}`;
+ const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
+ try {
+ // Pre-seed at 49 so next call = 50 (the fallback default)
+ fs.writeFileSync(counterFile, '49');
+ const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
+ CLAUDE_SESSION_ID: sessionId,
+ COMPACT_THRESHOLD: 'not-a-number'
+ });
+ assert.strictEqual(result.code, 0);
+ assert.ok(result.stderr.includes('50 tool calls reached'), 'Should use default threshold of 50');
+ } finally {
+ try {
+ fs.unlinkSync(counterFile);
+ } catch {
+ /* ignore */
+ }
+ }
+ })
+ )
+ passed++;
+ else failed++;
// ─── Round 20 bug fix tests ───
console.log('\ncheck-console-log.js (exact pass-through):');
- if (await asyncTest('stdout is exact byte match of stdin (no trailing newline)', async () => {
- // Before the fix, console.log(data) added a trailing \n.
- // process.stdout.write(data) should preserve exact bytes.
- const stdinData = '{"tool":"test","value":42}';
- const result = await runScript(path.join(scriptsDir, 'check-console-log.js'), stdinData);
- assert.strictEqual(result.code, 0);
- // stdout should be exactly the input — no extra newline appended
- assert.strictEqual(result.stdout, stdinData, 'Should not append extra newline to output');
- })) passed++; else failed++;
-
- if (await asyncTest('preserves empty string stdin without adding newline', async () => {
- const result = await runScript(path.join(scriptsDir, 'check-console-log.js'), '');
- assert.strictEqual(result.code, 0);
- assert.strictEqual(result.stdout, '', 'Empty input should produce empty output');
- })) passed++; else failed++;
-
- if (await asyncTest('preserves data with embedded newlines exactly', async () => {
- const stdinData = 'line1\nline2\nline3';
- const result = await runScript(path.join(scriptsDir, 'check-console-log.js'), stdinData);
- assert.strictEqual(result.code, 0);
- assert.strictEqual(result.stdout, stdinData, 'Should preserve embedded newlines without adding extra');
- })) passed++; else failed++;
+ if (
+ await asyncTest('stdout is exact byte match of stdin (no trailing newline)', async () => {
+ // Before the fix, console.log(data) added a trailing \n.
+ // process.stdout.write(data) should preserve exact bytes.
+ const stdinData = '{"tool":"test","value":42}';
+ const result = await runScript(path.join(scriptsDir, 'check-console-log.js'), stdinData);
+ assert.strictEqual(result.code, 0);
+ // stdout should be exactly the input — no extra newline appended
+ assert.strictEqual(result.stdout, stdinData, 'Should not append extra newline to output');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('preserves empty string stdin without adding newline', async () => {
+ const result = await runScript(path.join(scriptsDir, 'check-console-log.js'), '');
+ assert.strictEqual(result.code, 0);
+ assert.strictEqual(result.stdout, '', 'Empty input should produce empty output');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('preserves data with embedded newlines exactly', async () => {
+ const stdinData = 'line1\nline2\nline3';
+ const result = await runScript(path.join(scriptsDir, 'check-console-log.js'), stdinData);
+ assert.strictEqual(result.code, 0);
+ assert.strictEqual(result.stdout, stdinData, 'Should preserve embedded newlines without adding extra');
+ })
+ )
+ passed++;
+ else failed++;
console.log('\npost-edit-format.js (security & extension tests):');
- if (await asyncTest('source code does not pass shell option to execFileSync (security)', async () => {
- const formatSource = fs.readFileSync(path.join(scriptsDir, 'post-edit-format.js'), 'utf8');
- // Strip comments to avoid matching "shell: true" in comment text
- const codeOnly = formatSource.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
- assert.ok(
- !/execFileSync\([^)]*shell\s*:/.test(codeOnly),
- 'post-edit-format.js should not pass shell option to execFileSync'
- );
- assert.ok(
- codeOnly.includes("process.platform === 'win32' && cmd.bin.endsWith('.cmd')"),
- 'Windows shell execution must stay gated to .cmd shims'
- );
- assert.ok(formatSource.includes('npx.cmd'), 'Should use npx.cmd for Windows cross-platform safety');
- })) passed++; else failed++;
-
- if (await asyncTest('matches .tsx extension for formatting', async () => {
- const stdinJson = JSON.stringify({ tool_input: { file_path: '/nonexistent/component.tsx' } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-format.js'), stdinJson);
- assert.strictEqual(result.code, 0);
- // Should attempt to format (will fail silently since file doesn't exist, but should pass through)
- assert.ok(result.stdout.includes('component.tsx'), 'Should pass through data for .tsx files');
- })) passed++; else failed++;
-
- if (await asyncTest('matches .jsx extension for formatting', async () => {
- const stdinJson = JSON.stringify({ tool_input: { file_path: '/nonexistent/component.jsx' } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-format.js'), stdinJson);
- assert.strictEqual(result.code, 0);
- assert.ok(result.stdout.includes('component.jsx'), 'Should pass through data for .jsx files');
- })) passed++; else failed++;
+ if (
+ await asyncTest('source code does not pass shell option to execFileSync (security)', async () => {
+ const formatSource = fs.readFileSync(path.join(scriptsDir, 'post-edit-format.js'), 'utf8');
+ // Strip comments to avoid matching "shell: true" in comment text
+ const codeOnly = formatSource.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+ assert.ok(!codeOnly.includes('shell:'), 'post-edit-format.js should not pass shell option in code');
+ // npx.cmd handling moved to shared resolve-formatter.js — verify it uses the shared module
+ const resolverSource = fs.readFileSync(path.join(scriptsDir, '..', 'lib', 'resolve-formatter.js'), 'utf8');
+ assert.ok(resolverSource.includes('npx.cmd'), 'resolve-formatter.js should use npx.cmd for Windows cross-platform safety');
+ assert.ok(formatSource.includes('resolveFormatterBin'), 'post-edit-format.js should use shared resolveFormatterBin');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('matches .tsx extension for formatting', async () => {
+ const stdinJson = JSON.stringify({ tool_input: { file_path: '/nonexistent/component.tsx' } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-format.js'), stdinJson);
+ assert.strictEqual(result.code, 0);
+ // Should attempt to format (will fail silently since file doesn't exist, but should pass through)
+ assert.ok(result.stdout.includes('component.tsx'), 'Should pass through data for .tsx files');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('matches .jsx extension for formatting', async () => {
+ const stdinJson = JSON.stringify({ tool_input: { file_path: '/nonexistent/component.jsx' } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-format.js'), stdinJson);
+ assert.strictEqual(result.code, 0);
+ assert.ok(result.stdout.includes('component.jsx'), 'Should pass through data for .jsx files');
+ })
+ )
+ passed++;
+ else failed++;
console.log('\npost-edit-typecheck.js (security & extension tests):');
- if (await asyncTest('source code does not pass shell option to execFileSync (security)', async () => {
- const typecheckSource = fs.readFileSync(path.join(scriptsDir, 'post-edit-typecheck.js'), 'utf8');
- // Strip comments to avoid matching "shell: true" in comment text
- const codeOnly = typecheckSource.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
- assert.ok(!codeOnly.includes('shell:'), 'post-edit-typecheck.js should not pass shell option in code');
- assert.ok(typecheckSource.includes('npx.cmd'), 'Should use npx.cmd for Windows cross-platform safety');
- })) passed++; else failed++;
+ if (
+ await asyncTest('source code does not pass shell option to execFileSync (security)', async () => {
+ const typecheckSource = fs.readFileSync(path.join(scriptsDir, 'post-edit-typecheck.js'), 'utf8');
+ // Strip comments to avoid matching "shell: true" in comment text
+ const codeOnly = typecheckSource.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+ assert.ok(!codeOnly.includes('shell:'), 'post-edit-typecheck.js should not pass shell option in code');
+ assert.ok(typecheckSource.includes('npx.cmd'), 'Should use npx.cmd for Windows cross-platform safety');
+ })
+ )
+ passed++;
+ else failed++;
console.log('\nShell wrapper portability:');
- if (test('run-with-flags-shell resolves plugin root when CLAUDE_PLUGIN_ROOT is unset', () => {
- const wrapperSource = fs.readFileSync(path.join(scriptsDir, 'run-with-flags-shell.sh'), 'utf8');
- assert.ok(
- wrapperSource.includes('PLUGIN_ROOT="${CLAUDE_PLUGIN_ROOT:-'),
- 'Shell wrapper should derive PLUGIN_ROOT from its own script path'
- );
- })) passed++; else failed++;
-
- if (test('continuous-learning shell scripts use resolved Python command instead of hardcoded python3 invocations', () => {
- const observeSource = fs.readFileSync(path.join(__dirname, '..', '..', 'skills', 'continuous-learning-v2', 'hooks', 'observe.sh'), 'utf8');
- const startObserverSource = fs.readFileSync(path.join(__dirname, '..', '..', 'skills', 'continuous-learning-v2', 'agents', 'start-observer.sh'), 'utf8');
- const detectProjectSource = fs.readFileSync(path.join(__dirname, '..', '..', 'skills', 'continuous-learning-v2', 'scripts', 'detect-project.sh'), 'utf8');
-
- assert.ok(!/python3\s+-c/.test(observeSource), 'observe.sh should not invoke python3 directly');
- assert.ok(!/python3\s+-c/.test(startObserverSource), 'start-observer.sh should not invoke python3 directly');
- assert.ok(observeSource.includes('PYTHON_CMD'), 'observe.sh should resolve Python dynamically');
- assert.ok(startObserverSource.includes('CLV2_PYTHON_CMD'), 'start-observer.sh should reuse detected Python command');
- assert.ok(detectProjectSource.includes('_clv2_resolve_python_cmd'), 'detect-project.sh should provide shared Python resolution');
- })) passed++; else failed++;
-
- if (await asyncTest('detect-project exports the resolved Python command for downstream scripts', async () => {
- const detectProjectPath = path.join(__dirname, '..', '..', 'skills', 'continuous-learning-v2', 'scripts', 'detect-project.sh');
- const shellCommand = [
- `source "${detectProjectPath}" >/dev/null 2>&1`,
- 'printf "%s\\n" "${CLV2_PYTHON_CMD:-}"'
- ].join('; ');
-
- const shell = process.platform === 'win32' ? 'bash' : 'bash';
- const proc = spawn(shell, ['-lc', shellCommand], {
- env: process.env,
- stdio: ['ignore', 'pipe', 'pipe']
- });
-
- let stdout = '';
- let stderr = '';
- proc.stdout.on('data', data => stdout += data);
- proc.stderr.on('data', data => stderr += data);
-
- const code = await new Promise((resolve, reject) => {
- proc.on('close', resolve);
- proc.on('error', reject);
- });
+ if (
+ test('run-with-flags-shell resolves plugin root when CLAUDE_PLUGIN_ROOT is unset', () => {
+ const wrapperSource = fs.readFileSync(path.join(scriptsDir, 'run-with-flags-shell.sh'), 'utf8');
+ assert.ok(wrapperSource.includes('PLUGIN_ROOT="${CLAUDE_PLUGIN_ROOT:-'), 'Shell wrapper should derive PLUGIN_ROOT from its own script path');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ test('continuous-learning shell scripts use resolved Python command instead of hardcoded python3 invocations', () => {
+ const observeSource = fs.readFileSync(path.join(__dirname, '..', '..', 'skills', 'continuous-learning-v2', 'hooks', 'observe.sh'), 'utf8');
+ const startObserverSource = fs.readFileSync(path.join(__dirname, '..', '..', 'skills', 'continuous-learning-v2', 'agents', 'start-observer.sh'), 'utf8');
+ const detectProjectSource = fs.readFileSync(path.join(__dirname, '..', '..', 'skills', 'continuous-learning-v2', 'scripts', 'detect-project.sh'), 'utf8');
+
+ assert.ok(!/python3\s+-c/.test(observeSource), 'observe.sh should not invoke python3 directly');
+ assert.ok(!/python3\s+-c/.test(startObserverSource), 'start-observer.sh should not invoke python3 directly');
+ assert.ok(observeSource.includes('PYTHON_CMD'), 'observe.sh should resolve Python dynamically');
+ assert.ok(startObserverSource.includes('CLV2_PYTHON_CMD'), 'start-observer.sh should reuse detected Python command');
+ assert.ok(detectProjectSource.includes('_clv2_resolve_python_cmd'), 'detect-project.sh should provide shared Python resolution');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('detect-project exports the resolved Python command for downstream scripts', async () => {
+ const detectProjectPath = path.join(__dirname, '..', '..', 'skills', 'continuous-learning-v2', 'scripts', 'detect-project.sh');
+ const shellCommand = [`source "${detectProjectPath}" >/dev/null 2>&1`, 'printf "%s\\n" "${CLV2_PYTHON_CMD:-}"'].join('; ');
+
+ const shell = process.platform === 'win32' ? 'bash' : 'bash';
+ const proc = spawn(shell, ['-lc', shellCommand], {
+ env: process.env,
+ stdio: ['ignore', 'pipe', 'pipe']
+ });
- assert.strictEqual(code, 0, `detect-project.sh should source cleanly, stderr: ${stderr}`);
- assert.ok(stdout.trim().length > 0, 'CLV2_PYTHON_CMD should export a resolved interpreter path');
- })) passed++; else failed++;
+ let stdout = '';
+ let stderr = '';
+ proc.stdout.on('data', data => (stdout += data));
+ proc.stderr.on('data', data => (stderr += data));
- if (await asyncTest('matches .tsx extension for type checking', async () => {
- const testDir = createTestDir();
- const testFile = path.join(testDir, 'component.tsx');
- fs.writeFileSync(testFile, 'const x: number = 1;');
+ const code = await new Promise((resolve, reject) => {
+ proc.on('close', resolve);
+ proc.on('error', reject);
+ });
- const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), stdinJson);
- assert.strictEqual(result.code, 0);
- assert.ok(result.stdout.includes('tool_input'), 'Should pass through data for .tsx files');
- cleanupTestDir(testDir);
- })) passed++; else failed++;
+ assert.strictEqual(code, 0, `detect-project.sh should source cleanly, stderr: ${stderr}`);
+ assert.ok(stdout.trim().length > 0, 'CLV2_PYTHON_CMD should export a resolved interpreter path');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('matches .tsx extension for type checking', async () => {
+ const testDir = createTestDir();
+ const testFile = path.join(testDir, 'component.tsx');
+ fs.writeFileSync(testFile, 'const x: number = 1;');
+
+ const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), stdinJson);
+ assert.strictEqual(result.code, 0);
+ assert.ok(result.stdout.includes('tool_input'), 'Should pass through data for .tsx files');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
// ─── Round 23: Bug fixes & high-priority gap coverage ───
@@ -1798,1879 +2093,2242 @@ async function runTests() {
const wrapperScript = path.join(testDir, 'eval-wrapper.js');
let src = fs.readFileSync(path.join(scriptsDir, 'evaluate-session.js'), 'utf8');
// Patch require to use absolute path (the temp dir doesn't have ../lib/utils)
- src = src.replace(
- /require\('\.\.\/lib\/utils'\)/,
- `require(${JSON.stringify(realUtilsPath)})`
- );
+ src = src.replace(/require\('\.\.\/lib\/utils'\)/, `require(${JSON.stringify(realUtilsPath)})`);
// Patch config file path to point to our test config
- src = src.replace(
- /const configFile = path\.join\(scriptDir.*?config\.json'\);/,
- `const configFile = ${JSON.stringify(configPath)};`
- );
+ src = src.replace(/const configFile = path\.join\(scriptDir.*?config\.json'\);/, `const configFile = ${JSON.stringify(configPath)};`);
fs.writeFileSync(wrapperScript, src);
return wrapperScript;
}
console.log('\nRound 23: evaluate-session.js (config & nullish coalescing):');
- if (await asyncTest('respects min_session_length=0 from config (nullish coalescing)', async () => {
- // This tests the ?? fix: min_session_length=0 should mean "evaluate ALL sessions"
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'short.jsonl');
- // Only 2 user messages — normally below the default threshold of 10
- const lines = [
- '{"type":"user","content":"msg1"}',
- '{"type":"user","content":"msg2"}',
- ];
- fs.writeFileSync(transcriptPath, lines.join('\n'));
-
- // Create a config file with min_session_length=0
- const skillsDir = path.join(testDir, 'skills', 'continuous-learning');
- fs.mkdirSync(skillsDir, { recursive: true });
- const configPath = path.join(skillsDir, 'config.json');
- fs.writeFileSync(configPath, JSON.stringify({
- min_session_length: 0,
- learned_skills_path: path.join(testDir, 'learned')
- }));
-
- const wrapperScript = createEvalWrapper(testDir, configPath);
-
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(wrapperScript, stdinJson, {
- HOME: testDir, USERPROFILE: testDir
- });
- assert.strictEqual(result.code, 0);
- // With min_session_length=0, even 2 messages should trigger evaluation
- assert.ok(
- result.stderr.includes('2 messages') && result.stderr.includes('evaluate'),
- 'Should evaluate session with min_session_length=0 (not skip as too short)'
- );
- cleanupTestDir(testDir);
- })) passed++; else failed++;
-
- if (await asyncTest('config with min_session_length=null falls back to default 10', async () => {
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'short.jsonl');
- // 5 messages — below default 10
- const lines = [];
- for (let i = 0; i < 5; i++) lines.push(`{"type":"user","content":"msg${i}"}`);
- fs.writeFileSync(transcriptPath, lines.join('\n'));
-
- const skillsDir = path.join(testDir, 'skills', 'continuous-learning');
- fs.mkdirSync(skillsDir, { recursive: true });
- const configPath = path.join(skillsDir, 'config.json');
- fs.writeFileSync(configPath, JSON.stringify({
- min_session_length: null,
- learned_skills_path: path.join(testDir, 'learned')
- }));
-
- const wrapperScript = createEvalWrapper(testDir, configPath);
-
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(wrapperScript, stdinJson, {
- HOME: testDir, USERPROFILE: testDir
- });
- assert.strictEqual(result.code, 0);
- // null ?? 10 === 10, so 5 messages should be "too short"
- assert.ok(result.stderr.includes('too short'), 'Should fall back to default 10 when null');
- cleanupTestDir(testDir);
- })) passed++; else failed++;
-
- if (await asyncTest('config with custom learned_skills_path creates directory', async () => {
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
- fs.writeFileSync(transcriptPath, '{"type":"user","content":"msg"}');
-
- const customLearnedDir = path.join(testDir, 'custom-learned-skills');
- const skillsDir = path.join(testDir, 'skills', 'continuous-learning');
- fs.mkdirSync(skillsDir, { recursive: true });
- const configPath = path.join(skillsDir, 'config.json');
- fs.writeFileSync(configPath, JSON.stringify({
- learned_skills_path: customLearnedDir
- }));
-
- const wrapperScript = createEvalWrapper(testDir, configPath);
-
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- await runScript(wrapperScript, stdinJson, {
- HOME: testDir, USERPROFILE: testDir
- });
- assert.ok(fs.existsSync(customLearnedDir), 'Should create custom learned skills directory');
- cleanupTestDir(testDir);
- })) passed++; else failed++;
-
- if (await asyncTest('handles invalid config JSON gracefully (uses defaults)', async () => {
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
- const lines = [];
- for (let i = 0; i < 5; i++) lines.push(`{"type":"user","content":"msg${i}"}`);
- fs.writeFileSync(transcriptPath, lines.join('\n'));
-
- const skillsDir = path.join(testDir, 'skills', 'continuous-learning');
- fs.mkdirSync(skillsDir, { recursive: true });
- const configPath = path.join(skillsDir, 'config.json');
- fs.writeFileSync(configPath, 'not valid json!!!');
-
- const wrapperScript = createEvalWrapper(testDir, configPath);
-
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(wrapperScript, stdinJson, {
- HOME: testDir, USERPROFILE: testDir
- });
- assert.strictEqual(result.code, 0);
- // Should log parse failure and fall back to default 10 → 5 msgs too short
- assert.ok(result.stderr.includes('too short'), 'Should use defaults when config is invalid JSON');
- cleanupTestDir(testDir);
- })) passed++; else failed++;
+ if (
+ await asyncTest('respects min_session_length=0 from config (nullish coalescing)', async () => {
+ // This tests the ?? fix: min_session_length=0 should mean "evaluate ALL sessions"
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'short.jsonl');
+ // Only 2 user messages — normally below the default threshold of 10
+ const lines = ['{"type":"user","content":"msg1"}', '{"type":"user","content":"msg2"}'];
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
+
+ // Create a config file with min_session_length=0
+ const skillsDir = path.join(testDir, 'skills', 'continuous-learning');
+ fs.mkdirSync(skillsDir, { recursive: true });
+ const configPath = path.join(skillsDir, 'config.json');
+ fs.writeFileSync(
+ configPath,
+ JSON.stringify({
+ min_session_length: 0,
+ learned_skills_path: path.join(testDir, 'learned')
+ })
+ );
+
+ const wrapperScript = createEvalWrapper(testDir, configPath);
+
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(wrapperScript, stdinJson, {
+ HOME: testDir,
+ USERPROFILE: testDir
+ });
+ assert.strictEqual(result.code, 0);
+ // With min_session_length=0, even 2 messages should trigger evaluation
+ assert.ok(result.stderr.includes('2 messages') && result.stderr.includes('evaluate'), 'Should evaluate session with min_session_length=0 (not skip as too short)');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('config with min_session_length=null falls back to default 10', async () => {
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'short.jsonl');
+ // 5 messages — below default 10
+ const lines = [];
+ for (let i = 0; i < 5; i++) lines.push(`{"type":"user","content":"msg${i}"}`);
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
+
+ const skillsDir = path.join(testDir, 'skills', 'continuous-learning');
+ fs.mkdirSync(skillsDir, { recursive: true });
+ const configPath = path.join(skillsDir, 'config.json');
+ fs.writeFileSync(
+ configPath,
+ JSON.stringify({
+ min_session_length: null,
+ learned_skills_path: path.join(testDir, 'learned')
+ })
+ );
+
+ const wrapperScript = createEvalWrapper(testDir, configPath);
+
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(wrapperScript, stdinJson, {
+ HOME: testDir,
+ USERPROFILE: testDir
+ });
+ assert.strictEqual(result.code, 0);
+ // null ?? 10 === 10, so 5 messages should be "too short"
+ assert.ok(result.stderr.includes('too short'), 'Should fall back to default 10 when null');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('config with custom learned_skills_path creates directory', async () => {
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
+ fs.writeFileSync(transcriptPath, '{"type":"user","content":"msg"}');
+
+ const customLearnedDir = path.join(testDir, 'custom-learned-skills');
+ const skillsDir = path.join(testDir, 'skills', 'continuous-learning');
+ fs.mkdirSync(skillsDir, { recursive: true });
+ const configPath = path.join(skillsDir, 'config.json');
+ fs.writeFileSync(
+ configPath,
+ JSON.stringify({
+ learned_skills_path: customLearnedDir
+ })
+ );
+
+ const wrapperScript = createEvalWrapper(testDir, configPath);
+
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ await runScript(wrapperScript, stdinJson, {
+ HOME: testDir,
+ USERPROFILE: testDir
+ });
+ assert.ok(fs.existsSync(customLearnedDir), 'Should create custom learned skills directory');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('handles invalid config JSON gracefully (uses defaults)', async () => {
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
+ const lines = [];
+ for (let i = 0; i < 5; i++) lines.push(`{"type":"user","content":"msg${i}"}`);
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
+
+ const skillsDir = path.join(testDir, 'skills', 'continuous-learning');
+ fs.mkdirSync(skillsDir, { recursive: true });
+ const configPath = path.join(skillsDir, 'config.json');
+ fs.writeFileSync(configPath, 'not valid json!!!');
+
+ const wrapperScript = createEvalWrapper(testDir, configPath);
+
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(wrapperScript, stdinJson, {
+ HOME: testDir,
+ USERPROFILE: testDir
+ });
+ assert.strictEqual(result.code, 0);
+ // Should log parse failure and fall back to default 10 → 5 msgs too short
+ assert.ok(result.stderr.includes('too short'), 'Should use defaults when config is invalid JSON');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
console.log('\nRound 23: session-end.js (update existing file path):');
- if (await asyncTest('updates Last Updated timestamp in existing session file', async () => {
- const testDir = createTestDir();
- const sessionsDir = path.join(testDir, '.claude', 'sessions');
- fs.mkdirSync(sessionsDir, { recursive: true });
+ if (
+ await asyncTest('updates Last Updated timestamp in existing session file', async () => {
+ const testDir = createTestDir();
+ const sessionsDir = path.join(testDir, '.claude', 'sessions');
+ fs.mkdirSync(sessionsDir, { recursive: true });
+
+ // Get the expected filename
+ const utils = require('../../scripts/lib/utils');
+ const today = utils.getDateString();
+
+ // Create a pre-existing session file with known timestamp
+ const shortId = 'update01';
+ const sessionFile = path.join(sessionsDir, `${today}-${shortId}-session.tmp`);
+ const originalContent = `# Session: ${today}\n**Date:** ${today}\n**Started:** 09:00\n**Last Updated:** 09:00\n\n---\n\n## Current State\n\n[Session context goes here]\n\n### Completed\n- [ ]\n\n### In Progress\n- [ ]\n\n### Notes for Next Session\n-\n\n### Context to Load\n\`\`\`\n[relevant files]\n\`\`\`\n`;
+ fs.writeFileSync(sessionFile, originalContent);
+
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), '', {
+ HOME: testDir,
+ USERPROFILE: testDir,
+ CLAUDE_SESSION_ID: `session-${shortId}`
+ });
+ assert.strictEqual(result.code, 0);
+
+ const updated = fs.readFileSync(sessionFile, 'utf8');
+ // The timestamp should have been updated (no longer 09:00)
+ assert.ok(updated.includes('**Last Updated:**'), 'Should still have Last Updated field');
+ assert.ok(result.stderr.includes('Updated session file'), 'Should log update');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('replaces blank template with summary when updating existing file', async () => {
+ const testDir = createTestDir();
+ const sessionsDir = path.join(testDir, '.claude', 'sessions');
+ fs.mkdirSync(sessionsDir, { recursive: true });
+
+ const utils = require('../../scripts/lib/utils');
+ const today = utils.getDateString();
+
+ const shortId = 'update02';
+ const sessionFile = path.join(sessionsDir, `${today}-${shortId}-session.tmp`);
+ // Pre-existing file with blank template
+ const originalContent = `# Session: ${today}\n**Date:** ${today}\n**Started:** 09:00\n**Last Updated:** 09:00\n\n---\n\n## Current State\n\n[Session context goes here]\n\n### Completed\n- [ ]\n\n### In Progress\n- [ ]\n\n### Notes for Next Session\n-\n\n### Context to Load\n\`\`\`\n[relevant files]\n\`\`\`\n`;
+ fs.writeFileSync(sessionFile, originalContent);
+
+ // Create a transcript with user messages
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
+ const lines = ['{"type":"user","content":"Fix auth bug"}', '{"type":"tool_use","tool_name":"Edit","tool_input":{"file_path":"/src/auth.ts"}}'];
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
+
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
+ HOME: testDir,
+ USERPROFILE: testDir,
+ CLAUDE_SESSION_ID: `session-${shortId}`
+ });
+ assert.strictEqual(result.code, 0);
+
+ const updated = fs.readFileSync(sessionFile, 'utf8');
+ // Should have replaced blank template with actual summary
+ assert.ok(!updated.includes('[Session context goes here]'), 'Should replace blank template');
+ assert.ok(updated.includes('Fix auth bug'), 'Should include user message in summary');
+ assert.ok(updated.includes('/src/auth.ts'), 'Should include modified file');
+ })
+ )
+ passed++;
+ else failed++;
- // Get the expected filename
- const utils = require('../../scripts/lib/utils');
- const today = utils.getDateString();
+ if (
+ await asyncTest('always updates session summary content on session end', async () => {
+ const testDir = createTestDir();
+ const sessionsDir = path.join(testDir, '.claude', 'sessions');
+ fs.mkdirSync(sessionsDir, { recursive: true });
- // Create a pre-existing session file with known timestamp
- const shortId = 'update01';
- const sessionFile = path.join(sessionsDir, `${today}-${shortId}-session.tmp`);
- const originalContent = `# Session: ${today}\n**Date:** ${today}\n**Started:** 09:00\n**Last Updated:** 09:00\n\n---\n\n## Current State\n\n[Session context goes here]\n\n### Completed\n- [ ]\n\n### In Progress\n- [ ]\n\n### Notes for Next Session\n-\n\n### Context to Load\n\`\`\`\n[relevant files]\n\`\`\`\n`;
- fs.writeFileSync(sessionFile, originalContent);
+ const utils = require('../../scripts/lib/utils');
+ const today = utils.getDateString();
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), '', {
- HOME: testDir, USERPROFILE: testDir,
- CLAUDE_SESSION_ID: `session-${shortId}`
- });
- assert.strictEqual(result.code, 0);
-
- const updated = fs.readFileSync(sessionFile, 'utf8');
- // The timestamp should have been updated (no longer 09:00)
- assert.ok(updated.includes('**Last Updated:**'), 'Should still have Last Updated field');
- assert.ok(result.stderr.includes('Updated session file'), 'Should log update');
- })) passed++; else failed++;
-
- if (await asyncTest('replaces blank template with summary when updating existing file', async () => {
- const testDir = createTestDir();
- const sessionsDir = path.join(testDir, '.claude', 'sessions');
- fs.mkdirSync(sessionsDir, { recursive: true });
-
- const utils = require('../../scripts/lib/utils');
- const today = utils.getDateString();
-
- const shortId = 'update02';
- const sessionFile = path.join(sessionsDir, `${today}-${shortId}-session.tmp`);
- // Pre-existing file with blank template
- const originalContent = `# Session: ${today}\n**Date:** ${today}\n**Started:** 09:00\n**Last Updated:** 09:00\n\n---\n\n## Current State\n\n[Session context goes here]\n\n### Completed\n- [ ]\n\n### In Progress\n- [ ]\n\n### Notes for Next Session\n-\n\n### Context to Load\n\`\`\`\n[relevant files]\n\`\`\`\n`;
- fs.writeFileSync(sessionFile, originalContent);
-
- // Create a transcript with user messages
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
- const lines = [
- '{"type":"user","content":"Fix auth bug"}',
- '{"type":"tool_use","tool_name":"Edit","tool_input":{"file_path":"/src/auth.ts"}}',
- ];
- fs.writeFileSync(transcriptPath, lines.join('\n'));
-
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
- HOME: testDir, USERPROFILE: testDir,
- CLAUDE_SESSION_ID: `session-${shortId}`
- });
- assert.strictEqual(result.code, 0);
-
- const updated = fs.readFileSync(sessionFile, 'utf8');
- // Should have replaced blank template with actual summary
- assert.ok(!updated.includes('[Session context goes here]'), 'Should replace blank template');
- assert.ok(updated.includes('Fix auth bug'), 'Should include user message in summary');
- assert.ok(updated.includes('/src/auth.ts'), 'Should include modified file');
- })) passed++; else failed++;
-
- if (await asyncTest('always updates session summary content on session end', async () => {
- const testDir = createTestDir();
- const sessionsDir = path.join(testDir, '.claude', 'sessions');
- fs.mkdirSync(sessionsDir, { recursive: true });
-
- const utils = require('../../scripts/lib/utils');
- const today = utils.getDateString();
-
- const shortId = 'update03';
- const sessionFile = path.join(sessionsDir, `${today}-${shortId}-session.tmp`);
- // Pre-existing file with already-filled summary
- const existingContent = `# Session: ${today}\n**Date:** ${today}\n**Started:** 08:00\n**Last Updated:** 08:30\n\n---\n\n## Session Summary\n\n### Tasks\n- Previous task from earlier\n`;
- fs.writeFileSync(sessionFile, existingContent);
-
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
- fs.writeFileSync(transcriptPath, '{"type":"user","content":"New task"}');
-
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
- HOME: testDir, USERPROFILE: testDir,
- CLAUDE_SESSION_ID: `session-${shortId}`
- });
- assert.strictEqual(result.code, 0);
+ const shortId = 'update03';
+ const sessionFile = path.join(sessionsDir, `${today}-${shortId}-session.tmp`);
+ // Pre-existing file with already-filled summary
+ const existingContent = `# Session: ${today}\n**Date:** ${today}\n**Started:** 08:00\n**Last Updated:** 08:30\n\n---\n\n## Session Summary\n\n### Tasks\n- Previous task from earlier\n`;
+ fs.writeFileSync(sessionFile, existingContent);
+
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
+ fs.writeFileSync(transcriptPath, '{"type":"user","content":"New task"}');
+
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
+ HOME: testDir,
+ USERPROFILE: testDir,
+ CLAUDE_SESSION_ID: `session-${shortId}`
+ });
+ assert.strictEqual(result.code, 0);
- const updated = fs.readFileSync(sessionFile, 'utf8');
- // Session summary should always be refreshed with current content (#317)
- assert.ok(updated.includes('## Session Summary'), 'Should have Session Summary section');
- assert.ok(updated.includes('# Session:'), 'Should preserve session header');
- })) passed++; else failed++;
+ const updated = fs.readFileSync(sessionFile, 'utf8');
+ // Session summary should always be refreshed with current content (#317)
+ assert.ok(updated.includes('## Session Summary'), 'Should have Session Summary section');
+ assert.ok(updated.includes('# Session:'), 'Should preserve session header');
+ })
+ )
+ passed++;
+ else failed++;
console.log('\nRound 23: pre-compact.js (glob specificity):');
- if (await asyncTest('only annotates *-session.tmp files, not other .tmp files', async () => {
- const isoHome = path.join(os.tmpdir(), `ecc-compact-glob-${Date.now()}`);
- const sessionsDir = path.join(isoHome, '.claude', 'sessions');
- fs.mkdirSync(sessionsDir, { recursive: true });
+ if (
+ await asyncTest('only annotates *-session.tmp files, not other .tmp files', async () => {
+ const isoHome = path.join(os.tmpdir(), `ecc-compact-glob-${Date.now()}`);
+ const sessionsDir = path.join(isoHome, '.claude', 'sessions');
+ fs.mkdirSync(sessionsDir, { recursive: true });
+
+ // Create a session .tmp file and a non-session .tmp file
+ const sessionFile = path.join(sessionsDir, '2026-02-11-abc-session.tmp');
+ const otherTmpFile = path.join(sessionsDir, 'other-data.tmp');
+ fs.writeFileSync(sessionFile, '# Session\n');
+ fs.writeFileSync(otherTmpFile, 'some other data\n');
+
+ try {
+ await runScript(path.join(scriptsDir, 'pre-compact.js'), '', {
+ HOME: isoHome,
+ USERPROFILE: isoHome
+ });
+
+ const sessionContent = fs.readFileSync(sessionFile, 'utf8');
+ const otherContent = fs.readFileSync(otherTmpFile, 'utf8');
- // Create a session .tmp file and a non-session .tmp file
- const sessionFile = path.join(sessionsDir, '2026-02-11-abc-session.tmp');
- const otherTmpFile = path.join(sessionsDir, 'other-data.tmp');
- fs.writeFileSync(sessionFile, '# Session\n');
- fs.writeFileSync(otherTmpFile, 'some other data\n');
+ assert.ok(sessionContent.includes('Compaction occurred'), 'Should annotate session file');
+ assert.strictEqual(otherContent, 'some other data\n', 'Should NOT annotate non-session .tmp file');
+ } finally {
+ fs.rmSync(isoHome, { recursive: true, force: true });
+ }
+ })
+ )
+ passed++;
+ else failed++;
- try {
- await runScript(path.join(scriptsDir, 'pre-compact.js'), '', {
- HOME: isoHome, USERPROFILE: isoHome
- });
+ if (
+ await asyncTest('handles no active session files gracefully', async () => {
+ const isoHome = path.join(os.tmpdir(), `ecc-compact-nosession-${Date.now()}`);
+ const sessionsDir = path.join(isoHome, '.claude', 'sessions');
+ fs.mkdirSync(sessionsDir, { recursive: true });
- const sessionContent = fs.readFileSync(sessionFile, 'utf8');
- const otherContent = fs.readFileSync(otherTmpFile, 'utf8');
+ try {
+ const result = await runScript(path.join(scriptsDir, 'pre-compact.js'), '', {
+ HOME: isoHome,
+ USERPROFILE: isoHome
+ });
+ assert.strictEqual(result.code, 0, 'Should exit 0 with no session files');
+ assert.ok(result.stderr.includes('[PreCompact]'), 'Should still log success');
+
+ // Compaction log should still be created
+ const logFile = path.join(sessionsDir, 'compaction-log.txt');
+ assert.ok(fs.existsSync(logFile), 'Should create compaction log even with no sessions');
+ } finally {
+ fs.rmSync(isoHome, { recursive: true, force: true });
+ }
+ })
+ )
+ passed++;
+ else failed++;
- assert.ok(sessionContent.includes('Compaction occurred'), 'Should annotate session file');
- assert.strictEqual(otherContent, 'some other data\n', 'Should NOT annotate non-session .tmp file');
- } finally {
- fs.rmSync(isoHome, { recursive: true, force: true });
- }
- })) passed++; else failed++;
+ console.log('\nRound 23: session-end.js (extractSessionSummary edge cases):');
- if (await asyncTest('handles no active session files gracefully', async () => {
- const isoHome = path.join(os.tmpdir(), `ecc-compact-nosession-${Date.now()}`);
- const sessionsDir = path.join(isoHome, '.claude', 'sessions');
- fs.mkdirSync(sessionsDir, { recursive: true });
+ if (
+ await asyncTest('handles transcript with only assistant messages (no user messages)', async () => {
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
+ // Only assistant messages — no user messages
+ const lines = ['{"type":"assistant","message":{"content":[{"type":"text","text":"response"}]}}', '{"type":"tool_use","tool_name":"Read","tool_input":{"file_path":"/src/app.ts"}}'];
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
- try {
- const result = await runScript(path.join(scriptsDir, 'pre-compact.js'), '', {
- HOME: isoHome, USERPROFILE: isoHome
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
+ HOME: testDir
});
- assert.strictEqual(result.code, 0, 'Should exit 0 with no session files');
- assert.ok(result.stderr.includes('[PreCompact]'), 'Should still log success');
-
- // Compaction log should still be created
- const logFile = path.join(sessionsDir, 'compaction-log.txt');
- assert.ok(fs.existsSync(logFile), 'Should create compaction log even with no sessions');
- } finally {
- fs.rmSync(isoHome, { recursive: true, force: true });
- }
- })) passed++; else failed++;
-
- console.log('\nRound 23: session-end.js (extractSessionSummary edge cases):');
-
- if (await asyncTest('handles transcript with only assistant messages (no user messages)', async () => {
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
- // Only assistant messages — no user messages
- const lines = [
- '{"type":"assistant","message":{"content":[{"type":"text","text":"response"}]}}',
- '{"type":"tool_use","tool_name":"Read","tool_input":{"file_path":"/src/app.ts"}}',
- ];
- fs.writeFileSync(transcriptPath, lines.join('\n'));
-
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
- HOME: testDir
- });
- assert.strictEqual(result.code, 0);
+ assert.strictEqual(result.code, 0);
- // With no user messages, extractSessionSummary returns null → blank template
- const claudeDir = path.join(testDir, '.claude', 'sessions');
- if (fs.existsSync(claudeDir)) {
- const files = fs.readdirSync(claudeDir).filter(f => f.endsWith('.tmp'));
- if (files.length > 0) {
- const content = fs.readFileSync(path.join(claudeDir, files[0]), 'utf8');
- assert.ok(content.includes('[Session context goes here]'), 'Should use blank template when no user messages');
- }
- }
- cleanupTestDir(testDir);
- })) passed++; else failed++;
-
- if (await asyncTest('extracts tool_use from assistant message content blocks', async () => {
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
- // Claude Code JSONL format: tool_use blocks inside assistant message content array
- const lines = [
- '{"type":"user","content":"Edit config"}',
- JSON.stringify({
- type: 'assistant',
- message: {
- content: [
- { type: 'text', text: 'I will edit the config.' },
- { type: 'tool_use', name: 'Edit', input: { file_path: '/src/config.ts' } },
- { type: 'tool_use', name: 'Write', input: { file_path: '/src/new.ts' } },
- ]
+ // With no user messages, extractSessionSummary returns null → blank template
+ const claudeDir = path.join(testDir, '.claude', 'sessions');
+ if (fs.existsSync(claudeDir)) {
+ const files = fs.readdirSync(claudeDir).filter(f => f.endsWith('.tmp'));
+ if (files.length > 0) {
+ const content = fs.readFileSync(path.join(claudeDir, files[0]), 'utf8');
+ assert.ok(content.includes('[Session context goes here]'), 'Should use blank template when no user messages');
}
- }),
- ];
- fs.writeFileSync(transcriptPath, lines.join('\n'));
+ }
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('extracts tool_use from assistant message content blocks', async () => {
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
+ // Claude Code JSONL format: tool_use blocks inside assistant message content array
+ const lines = [
+ '{"type":"user","content":"Edit config"}',
+ JSON.stringify({
+ type: 'assistant',
+ message: {
+ content: [
+ { type: 'text', text: 'I will edit the config.' },
+ { type: 'tool_use', name: 'Edit', input: { file_path: '/src/config.ts' } },
+ { type: 'tool_use', name: 'Write', input: { file_path: '/src/new.ts' } }
+ ]
+ }
+ })
+ ];
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
- HOME: testDir
- });
- assert.strictEqual(result.code, 0);
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
+ HOME: testDir
+ });
+ assert.strictEqual(result.code, 0);
- const claudeDir = path.join(testDir, '.claude', 'sessions');
- if (fs.existsSync(claudeDir)) {
- const files = fs.readdirSync(claudeDir).filter(f => f.endsWith('.tmp'));
- if (files.length > 0) {
- const content = fs.readFileSync(path.join(claudeDir, files[0]), 'utf8');
- assert.ok(content.includes('/src/config.ts'), 'Should extract file from nested tool_use block');
- assert.ok(content.includes('/src/new.ts'), 'Should extract Write file from nested block');
- assert.ok(content.includes('Edit'), 'Should list Edit in tools used');
+ const claudeDir = path.join(testDir, '.claude', 'sessions');
+ if (fs.existsSync(claudeDir)) {
+ const files = fs.readdirSync(claudeDir).filter(f => f.endsWith('.tmp'));
+ if (files.length > 0) {
+ const content = fs.readFileSync(path.join(claudeDir, files[0]), 'utf8');
+ assert.ok(content.includes('/src/config.ts'), 'Should extract file from nested tool_use block');
+ assert.ok(content.includes('/src/new.ts'), 'Should extract Write file from nested block');
+ assert.ok(content.includes('Edit'), 'Should list Edit in tools used');
+ }
}
- }
- cleanupTestDir(testDir);
- })) passed++; else failed++;
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
// ─── Round 24: suggest-compact interval fix, fd fallback, session-start maxAge ───
console.log('\nRound 24: suggest-compact.js (interval fix & fd fallback):');
- if (await asyncTest('periodic intervals are consistent with non-25-divisible threshold', async () => {
- // Regression test: with threshold=13, periodic suggestions should fire at 38, 63, 88...
- // (count - 13) % 25 === 0 → 38-13=25, 63-13=50, etc.
- const sessionId = `test-interval-fix-${Date.now()}`;
- const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
- try {
- // Pre-seed at 37 so next call = 38 (13 + 25 = 38)
- fs.writeFileSync(counterFile, '37');
- const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
- CLAUDE_SESSION_ID: sessionId,
- COMPACT_THRESHOLD: '13'
- });
- assert.strictEqual(result.code, 0);
- assert.ok(result.stderr.includes('38 tool calls'), 'Should suggest at threshold(13) + 25 = 38');
- } finally {
- try { fs.unlinkSync(counterFile); } catch { /* ignore */ }
- }
- })) passed++; else failed++;
-
- if (await asyncTest('does not suggest at old-style multiples that skip threshold offset', async () => {
- // With threshold=13, count=50 should NOT trigger (old behavior would: 50%25===0)
- // New behavior: (50-13)%25 = 37%25 = 12 → no suggestion
- const sessionId = `test-no-false-suggest-${Date.now()}`;
- const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
- try {
- fs.writeFileSync(counterFile, '49');
- const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
- CLAUDE_SESSION_ID: sessionId,
- COMPACT_THRESHOLD: '13'
- });
- assert.strictEqual(result.code, 0);
- assert.ok(!result.stderr.includes('checkpoint'), 'Should NOT suggest at count=50 with threshold=13');
- } finally {
- try { fs.unlinkSync(counterFile); } catch { /* ignore */ }
- }
- })) passed++; else failed++;
-
- if (await asyncTest('fd fallback: handles corrupted counter file gracefully', async () => {
- const sessionId = `test-corrupt-${Date.now()}`;
- const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
- try {
- // Write non-numeric data to trigger parseInt → NaN → reset to 1
- fs.writeFileSync(counterFile, 'corrupted data here!!!');
- const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
- CLAUDE_SESSION_ID: sessionId
- });
- assert.strictEqual(result.code, 0);
- const newCount = parseInt(fs.readFileSync(counterFile, 'utf8').trim(), 10);
- assert.strictEqual(newCount, 1, 'Should reset to 1 on corrupted file content');
- } finally {
- try { fs.unlinkSync(counterFile); } catch { /* ignore */ }
- }
- })) passed++; else failed++;
-
- if (await asyncTest('handles counter at exact 1000000 boundary', async () => {
- const sessionId = `test-boundary-${Date.now()}`;
- const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
- try {
- // 1000000 is the upper clamp boundary — should still increment
- fs.writeFileSync(counterFile, '1000000');
- const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
- CLAUDE_SESSION_ID: sessionId
- });
- assert.strictEqual(result.code, 0);
- const newCount = parseInt(fs.readFileSync(counterFile, 'utf8').trim(), 10);
- assert.strictEqual(newCount, 1000001, 'Should increment from exactly 1000000');
- } finally {
- try { fs.unlinkSync(counterFile); } catch { /* ignore */ }
- }
- })) passed++; else failed++;
+ if (
+ await asyncTest('periodic intervals are consistent with non-25-divisible threshold', async () => {
+ // Regression test: with threshold=13, periodic suggestions should fire at 38, 63, 88...
+ // (count - 13) % 25 === 0 → 38-13=25, 63-13=50, etc.
+ const sessionId = `test-interval-fix-${Date.now()}`;
+ const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
+ try {
+ // Pre-seed at 37 so next call = 38 (13 + 25 = 38)
+ fs.writeFileSync(counterFile, '37');
+ const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
+ CLAUDE_SESSION_ID: sessionId,
+ COMPACT_THRESHOLD: '13'
+ });
+ assert.strictEqual(result.code, 0);
+ assert.ok(result.stderr.includes('38 tool calls'), 'Should suggest at threshold(13) + 25 = 38');
+ } finally {
+ try {
+ fs.unlinkSync(counterFile);
+ } catch {
+ /* ignore */
+ }
+ }
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('does not suggest at old-style multiples that skip threshold offset', async () => {
+ // With threshold=13, count=50 should NOT trigger (old behavior would: 50%25===0)
+ // New behavior: (50-13)%25 = 37%25 = 12 → no suggestion
+ const sessionId = `test-no-false-suggest-${Date.now()}`;
+ const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
+ try {
+ fs.writeFileSync(counterFile, '49');
+ const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
+ CLAUDE_SESSION_ID: sessionId,
+ COMPACT_THRESHOLD: '13'
+ });
+ assert.strictEqual(result.code, 0);
+ assert.ok(!result.stderr.includes('checkpoint'), 'Should NOT suggest at count=50 with threshold=13');
+ } finally {
+ try {
+ fs.unlinkSync(counterFile);
+ } catch {
+ /* ignore */
+ }
+ }
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('fd fallback: handles corrupted counter file gracefully', async () => {
+ const sessionId = `test-corrupt-${Date.now()}`;
+ const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
+ try {
+ // Write non-numeric data to trigger parseInt → NaN → reset to 1
+ fs.writeFileSync(counterFile, 'corrupted data here!!!');
+ const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
+ CLAUDE_SESSION_ID: sessionId
+ });
+ assert.strictEqual(result.code, 0);
+ const newCount = parseInt(fs.readFileSync(counterFile, 'utf8').trim(), 10);
+ assert.strictEqual(newCount, 1, 'Should reset to 1 on corrupted file content');
+ } finally {
+ try {
+ fs.unlinkSync(counterFile);
+ } catch {
+ /* ignore */
+ }
+ }
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('handles counter at exact 1000000 boundary', async () => {
+ const sessionId = `test-boundary-${Date.now()}`;
+ const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
+ try {
+ // 1000000 is the upper clamp boundary — should still increment
+ fs.writeFileSync(counterFile, '1000000');
+ const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
+ CLAUDE_SESSION_ID: sessionId
+ });
+ assert.strictEqual(result.code, 0);
+ const newCount = parseInt(fs.readFileSync(counterFile, 'utf8').trim(), 10);
+ assert.strictEqual(newCount, 1000001, 'Should increment from exactly 1000000');
+ } finally {
+ try {
+ fs.unlinkSync(counterFile);
+ } catch {
+ /* ignore */
+ }
+ }
+ })
+ )
+ passed++;
+ else failed++;
console.log('\nRound 24: post-edit-format.js (edge cases):');
- if (await asyncTest('passes through malformed JSON unchanged', async () => {
- const malformedJson = '{"tool_input": {"file_path": "/test.ts"';
- const result = await runScript(path.join(scriptsDir, 'post-edit-format.js'), malformedJson);
- assert.strictEqual(result.code, 0);
- // Should pass through the malformed data unchanged
- assert.ok(result.stdout.includes(malformedJson), 'Should pass through malformed JSON');
- })) passed++; else failed++;
-
- if (await asyncTest('passes through data for non-JS/TS file extensions', async () => {
- const stdinJson = JSON.stringify({ tool_input: { file_path: '/path/to/file.py' } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-format.js'), stdinJson);
- assert.strictEqual(result.code, 0);
- assert.ok(result.stdout.includes('file.py'), 'Should pass through for .py files');
- })) passed++; else failed++;
+ if (
+ await asyncTest('passes through malformed JSON unchanged', async () => {
+ const malformedJson = '{"tool_input": {"file_path": "/test.ts"';
+ const result = await runScript(path.join(scriptsDir, 'post-edit-format.js'), malformedJson);
+ assert.strictEqual(result.code, 0);
+ // Should pass through the malformed data unchanged
+ assert.ok(result.stdout.includes(malformedJson), 'Should pass through malformed JSON');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('passes through data for non-JS/TS file extensions', async () => {
+ const stdinJson = JSON.stringify({ tool_input: { file_path: '/path/to/file.py' } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-format.js'), stdinJson);
+ assert.strictEqual(result.code, 0);
+ assert.ok(result.stdout.includes('file.py'), 'Should pass through for .py files');
+ })
+ )
+ passed++;
+ else failed++;
console.log('\nRound 24: post-edit-typecheck.js (edge cases):');
- if (await asyncTest('skips typecheck for non-existent file and still passes through', async () => {
- const stdinJson = JSON.stringify({ tool_input: { file_path: '/nonexistent/deep/file.ts' } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), stdinJson);
- assert.strictEqual(result.code, 0);
- assert.ok(result.stdout.includes('file.ts'), 'Should pass through for non-existent .ts file');
- })) passed++; else failed++;
-
- if (await asyncTest('passes through for non-TS extensions without running tsc', async () => {
- const stdinJson = JSON.stringify({ tool_input: { file_path: '/path/to/file.js' } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), stdinJson);
- assert.strictEqual(result.code, 0);
- assert.ok(result.stdout.includes('file.js'), 'Should pass through for .js file without running tsc');
- })) passed++; else failed++;
+ if (
+ await asyncTest('skips typecheck for non-existent file and still passes through', async () => {
+ const stdinJson = JSON.stringify({ tool_input: { file_path: '/nonexistent/deep/file.ts' } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), stdinJson);
+ assert.strictEqual(result.code, 0);
+ assert.ok(result.stdout.includes('file.ts'), 'Should pass through for non-existent .ts file');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('passes through for non-TS extensions without running tsc', async () => {
+ const stdinJson = JSON.stringify({ tool_input: { file_path: '/path/to/file.js' } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), stdinJson);
+ assert.strictEqual(result.code, 0);
+ assert.ok(result.stdout.includes('file.js'), 'Should pass through for .js file without running tsc');
+ })
+ )
+ passed++;
+ else failed++;
console.log('\nRound 24: session-start.js (edge cases):');
- if (await asyncTest('exits 0 with empty sessions directory (no recent sessions)', async () => {
- const isoHome = path.join(os.tmpdir(), `ecc-start-empty-${Date.now()}`);
- fs.mkdirSync(path.join(isoHome, '.claude', 'sessions'), { recursive: true });
- fs.mkdirSync(path.join(isoHome, '.claude', 'skills', 'learned'), { recursive: true });
- try {
- const result = await runScript(path.join(scriptsDir, 'session-start.js'), '', {
- HOME: isoHome, USERPROFILE: isoHome
- });
- assert.strictEqual(result.code, 0, 'Should exit 0 with no sessions');
- // Should NOT inject any previous session data (stdout should be empty or minimal)
- assert.ok(!result.stdout.includes('Previous session summary'), 'Should not inject when no sessions');
- } finally {
- fs.rmSync(isoHome, { recursive: true, force: true });
- }
- })) passed++; else failed++;
-
- if (await asyncTest('does not inject blank template session into context', async () => {
- const isoHome = path.join(os.tmpdir(), `ecc-start-blank-${Date.now()}`);
- const sessionsDir = path.join(isoHome, '.claude', 'sessions');
- fs.mkdirSync(sessionsDir, { recursive: true });
- fs.mkdirSync(path.join(isoHome, '.claude', 'skills', 'learned'), { recursive: true });
-
- // Create a session file with the blank template marker
- const today = new Date().toISOString().slice(0, 10);
- const sessionFile = path.join(sessionsDir, `${today}-blank-session.tmp`);
- fs.writeFileSync(sessionFile, '# Session\n[Session context goes here]\n');
+ if (
+ await asyncTest('exits 0 with empty sessions directory (no recent sessions)', async () => {
+ const isoHome = path.join(os.tmpdir(), `ecc-start-empty-${Date.now()}`);
+ fs.mkdirSync(path.join(isoHome, '.claude', 'sessions'), { recursive: true });
+ fs.mkdirSync(path.join(isoHome, '.claude', 'skills', 'learned'), { recursive: true });
+ try {
+ const result = await runScript(path.join(scriptsDir, 'session-start.js'), '', {
+ HOME: isoHome,
+ USERPROFILE: isoHome
+ });
+ assert.strictEqual(result.code, 0, 'Should exit 0 with no sessions');
+ // Should NOT inject any previous session data (stdout should be empty or minimal)
+ assert.ok(!result.stdout.includes('Previous session summary'), 'Should not inject when no sessions');
+ } finally {
+ fs.rmSync(isoHome, { recursive: true, force: true });
+ }
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('does not inject blank template session into context', async () => {
+ const isoHome = path.join(os.tmpdir(), `ecc-start-blank-${Date.now()}`);
+ const sessionsDir = path.join(isoHome, '.claude', 'sessions');
+ fs.mkdirSync(sessionsDir, { recursive: true });
+ fs.mkdirSync(path.join(isoHome, '.claude', 'skills', 'learned'), { recursive: true });
+
+ // Create a session file with the blank template marker
+ const today = new Date().toISOString().slice(0, 10);
+ const sessionFile = path.join(sessionsDir, `${today}-blank-session.tmp`);
+ fs.writeFileSync(sessionFile, '# Session\n[Session context goes here]\n');
- try {
- const result = await runScript(path.join(scriptsDir, 'session-start.js'), '', {
- HOME: isoHome, USERPROFILE: isoHome
- });
- assert.strictEqual(result.code, 0);
- // Should NOT inject blank template
- assert.ok(!result.stdout.includes('Previous session summary'), 'Should skip blank template sessions');
- } finally {
- fs.rmSync(isoHome, { recursive: true, force: true });
- }
- })) passed++; else failed++;
+ try {
+ const result = await runScript(path.join(scriptsDir, 'session-start.js'), '', {
+ HOME: isoHome,
+ USERPROFILE: isoHome
+ });
+ assert.strictEqual(result.code, 0);
+ // Should NOT inject blank template
+ assert.ok(!result.stdout.includes('Previous session summary'), 'Should skip blank template sessions');
+ } finally {
+ fs.rmSync(isoHome, { recursive: true, force: true });
+ }
+ })
+ )
+ passed++;
+ else failed++;
// ─── Round 25: post-edit-console-warn pass-through fix, check-console-log edge cases ───
console.log('\nRound 25: post-edit-console-warn.js (pass-through fix):');
- if (await asyncTest('stdout is exact byte match of stdin (no trailing newline)', async () => {
- // Regression test: console.log(data) was replaced with process.stdout.write(data)
- const stdinData = '{"tool_input":{"file_path":"/nonexistent/file.py"}}';
- const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), stdinData);
- assert.strictEqual(result.code, 0);
- assert.strictEqual(result.stdout, stdinData, 'stdout should exactly match stdin (no extra newline)');
- })) passed++; else failed++;
-
- if (await asyncTest('passes through malformed JSON unchanged without crash', async () => {
- const malformed = '{"tool_input": {"file_path": "/test.ts"';
- const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), malformed);
- assert.strictEqual(result.code, 0);
- assert.strictEqual(result.stdout, malformed, 'Should pass through malformed JSON exactly');
- })) passed++; else failed++;
-
- if (await asyncTest('handles missing file_path in tool_input gracefully', async () => {
- const stdinJson = JSON.stringify({ tool_input: {} });
- const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), stdinJson);
- assert.strictEqual(result.code, 0);
- assert.strictEqual(result.stdout, stdinJson, 'Should pass through with missing file_path');
- })) passed++; else failed++;
-
- if (await asyncTest('passes through when file does not exist (readFile returns null)', async () => {
- const stdinJson = JSON.stringify({ tool_input: { file_path: '/nonexistent/deep/file.ts' } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), stdinJson);
- assert.strictEqual(result.code, 0);
- assert.strictEqual(result.stdout, stdinJson, 'Should pass through exactly when file not found');
- })) passed++; else failed++;
+ if (
+ await asyncTest('stdout is exact byte match of stdin (no trailing newline)', async () => {
+ // Regression test: console.log(data) was replaced with process.stdout.write(data)
+ const stdinData = '{"tool_input":{"file_path":"/nonexistent/file.py"}}';
+ const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), stdinData);
+ assert.strictEqual(result.code, 0);
+ assert.strictEqual(result.stdout, stdinData, 'stdout should exactly match stdin (no extra newline)');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('passes through malformed JSON unchanged without crash', async () => {
+ const malformed = '{"tool_input": {"file_path": "/test.ts"';
+ const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), malformed);
+ assert.strictEqual(result.code, 0);
+ assert.strictEqual(result.stdout, malformed, 'Should pass through malformed JSON exactly');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('handles missing file_path in tool_input gracefully', async () => {
+ const stdinJson = JSON.stringify({ tool_input: {} });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), stdinJson);
+ assert.strictEqual(result.code, 0);
+ assert.strictEqual(result.stdout, stdinJson, 'Should pass through with missing file_path');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('passes through when file does not exist (readFile returns null)', async () => {
+ const stdinJson = JSON.stringify({ tool_input: { file_path: '/nonexistent/deep/file.ts' } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), stdinJson);
+ assert.strictEqual(result.code, 0);
+ assert.strictEqual(result.stdout, stdinJson, 'Should pass through exactly when file not found');
+ })
+ )
+ passed++;
+ else failed++;
console.log('\nRound 25: check-console-log.js (edge cases):');
- if (await asyncTest('source has expected exclusion patterns', async () => {
- // The EXCLUDED_PATTERNS array includes .test.ts, .spec.ts, etc.
- const source = fs.readFileSync(path.join(scriptsDir, 'check-console-log.js'), 'utf8');
- // Verify the exclusion patterns exist (regex escapes use \. so check for the pattern names)
- assert.ok(source.includes('EXCLUDED_PATTERNS'), 'Should have exclusion patterns array');
- assert.ok(/\.test\\\./.test(source), 'Should have test file exclusion pattern');
- assert.ok(/\.spec\\\./.test(source), 'Should have spec file exclusion pattern');
- assert.ok(source.includes('scripts'), 'Should exclude scripts/ directory');
- assert.ok(source.includes('__tests__'), 'Should exclude __tests__/ directory');
- assert.ok(source.includes('__mocks__'), 'Should exclude __mocks__/ directory');
- })) passed++; else failed++;
-
- if (await asyncTest('passes through data unchanged on non-git repo', async () => {
- // In a temp dir with no git repo, the hook should pass through data unchanged
- const testDir = createTestDir();
- const stdinData = '{"tool_input":"test"}';
- const result = await runScript(path.join(scriptsDir, 'check-console-log.js'), stdinData, {
- // Use a non-git directory as CWD
- HOME: testDir, USERPROFILE: testDir
- });
- // Note: We're still running from a git repo, so isGitRepo() may still return true.
- // This test verifies the script doesn't crash and passes through data.
- assert.strictEqual(result.code, 0);
- assert.ok(result.stdout.includes(stdinData), 'Should pass through data');
- cleanupTestDir(testDir);
- })) passed++; else failed++;
-
- if (await asyncTest('exits 0 even when no stdin is provided', async () => {
- const result = await runScript(path.join(scriptsDir, 'check-console-log.js'), '');
- assert.strictEqual(result.code, 0, 'Should exit 0 with empty stdin');
- })) passed++; else failed++;
+ if (
+ await asyncTest('source has expected exclusion patterns', async () => {
+ // The EXCLUDED_PATTERNS array includes .test.ts, .spec.ts, etc.
+ const source = fs.readFileSync(path.join(scriptsDir, 'check-console-log.js'), 'utf8');
+ // Verify the exclusion patterns exist (regex escapes use \. so check for the pattern names)
+ assert.ok(source.includes('EXCLUDED_PATTERNS'), 'Should have exclusion patterns array');
+ assert.ok(/\.test\\\./.test(source), 'Should have test file exclusion pattern');
+ assert.ok(/\.spec\\\./.test(source), 'Should have spec file exclusion pattern');
+ assert.ok(source.includes('scripts'), 'Should exclude scripts/ directory');
+ assert.ok(source.includes('__tests__'), 'Should exclude __tests__/ directory');
+ assert.ok(source.includes('__mocks__'), 'Should exclude __mocks__/ directory');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('passes through data unchanged on non-git repo', async () => {
+ // In a temp dir with no git repo, the hook should pass through data unchanged
+ const testDir = createTestDir();
+ const stdinData = '{"tool_input":"test"}';
+ const result = await runScript(path.join(scriptsDir, 'check-console-log.js'), stdinData, {
+ // Use a non-git directory as CWD
+ HOME: testDir,
+ USERPROFILE: testDir
+ });
+ // Note: We're still running from a git repo, so isGitRepo() may still return true.
+ // This test verifies the script doesn't crash and passes through data.
+ assert.strictEqual(result.code, 0);
+ assert.ok(result.stdout.includes(stdinData), 'Should pass through data');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('exits 0 even when no stdin is provided', async () => {
+ const result = await runScript(path.join(scriptsDir, 'check-console-log.js'), '');
+ assert.strictEqual(result.code, 0, 'Should exit 0 with empty stdin');
+ })
+ )
+ passed++;
+ else failed++;
// ── Round 29: post-edit-format.js cwd fix and process.exit(0) consistency ──
console.log('\nRound 29: post-edit-format.js (cwd and exit):');
- if (await asyncTest('source uses cwd based on file directory for npx', async () => {
- const formatSource = fs.readFileSync(path.join(scriptsDir, 'post-edit-format.js'), 'utf8');
- assert.ok(formatSource.includes('cwd:'), 'Should set cwd option for execFileSync');
- assert.ok(formatSource.includes('path.dirname'), 'cwd should use path.dirname of the file');
- assert.ok(formatSource.includes('path.resolve'), 'cwd should resolve the file path first');
- })) passed++; else failed++;
-
- if (await asyncTest('source calls process.exit(0) after writing output', async () => {
- const formatSource = fs.readFileSync(path.join(scriptsDir, 'post-edit-format.js'), 'utf8');
- assert.ok(formatSource.includes('process.exit(0)'), 'Should call process.exit(0) for clean termination');
- })) passed++; else failed++;
-
- if (await asyncTest('uses process.stdout.write instead of console.log for pass-through', async () => {
- const formatSource = fs.readFileSync(path.join(scriptsDir, 'post-edit-format.js'), 'utf8');
- assert.ok(formatSource.includes('process.stdout.write(data)'), 'Should use process.stdout.write to avoid trailing newline');
- // Verify no console.log(data) for pass-through (console.error for warnings is OK)
- const lines = formatSource.split('\n');
- const passThrough = lines.filter(l => /console\.log\(data\)/.test(l));
- assert.strictEqual(passThrough.length, 0, 'Should not use console.log(data) for pass-through');
- })) passed++; else failed++;
+ if (
+ await asyncTest('source uses cwd based on file directory for npx', async () => {
+ const formatSource = fs.readFileSync(path.join(scriptsDir, 'post-edit-format.js'), 'utf8');
+ assert.ok(formatSource.includes('cwd:'), 'Should set cwd option for execFileSync');
+ assert.ok(formatSource.includes('path.dirname'), 'cwd should use path.dirname of the file');
+ assert.ok(formatSource.includes('path.resolve'), 'cwd should resolve the file path first');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('source calls process.exit(0) after writing output', async () => {
+ const formatSource = fs.readFileSync(path.join(scriptsDir, 'post-edit-format.js'), 'utf8');
+ assert.ok(formatSource.includes('process.exit(0)'), 'Should call process.exit(0) for clean termination');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('uses process.stdout.write instead of console.log for pass-through', async () => {
+ const formatSource = fs.readFileSync(path.join(scriptsDir, 'post-edit-format.js'), 'utf8');
+ assert.ok(formatSource.includes('process.stdout.write(data)'), 'Should use process.stdout.write to avoid trailing newline');
+ // Verify no console.log(data) for pass-through (console.error for warnings is OK)
+ const lines = formatSource.split('\n');
+ const passThrough = lines.filter(l => /console\.log\(data\)/.test(l));
+ assert.strictEqual(passThrough.length, 0, 'Should not use console.log(data) for pass-through');
+ })
+ )
+ passed++;
+ else failed++;
console.log('\nRound 29: post-edit-typecheck.js (exit and pass-through):');
- if (await asyncTest('source calls process.exit(0) after writing output', async () => {
- const tcSource = fs.readFileSync(path.join(scriptsDir, 'post-edit-typecheck.js'), 'utf8');
- assert.ok(tcSource.includes('process.exit(0)'), 'Should call process.exit(0) for clean termination');
- })) passed++; else failed++;
-
- if (await asyncTest('uses process.stdout.write instead of console.log for pass-through', async () => {
- const tcSource = fs.readFileSync(path.join(scriptsDir, 'post-edit-typecheck.js'), 'utf8');
- assert.ok(tcSource.includes('process.stdout.write(data)'), 'Should use process.stdout.write');
- const lines = tcSource.split('\n');
- const passThrough = lines.filter(l => /console\.log\(data\)/.test(l));
- assert.strictEqual(passThrough.length, 0, 'Should not use console.log(data) for pass-through');
- })) passed++; else failed++;
-
- if (await asyncTest('exact stdout pass-through without trailing newline (typecheck)', async () => {
- const stdinJson = JSON.stringify({ tool_input: { file_path: '/nonexistent/file.py' } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), stdinJson);
- assert.strictEqual(result.code, 0);
- assert.strictEqual(result.stdout, stdinJson, 'stdout should exactly match stdin (no trailing newline)');
- })) passed++; else failed++;
-
- if (await asyncTest('exact stdout pass-through without trailing newline (format)', async () => {
- const stdinJson = JSON.stringify({ tool_input: { file_path: '/nonexistent/file.py' } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-format.js'), stdinJson);
- assert.strictEqual(result.code, 0);
- assert.strictEqual(result.stdout, stdinJson, 'stdout should exactly match stdin (no trailing newline)');
- })) passed++; else failed++;
+ if (
+ await asyncTest('source calls process.exit(0) after writing output', async () => {
+ const tcSource = fs.readFileSync(path.join(scriptsDir, 'post-edit-typecheck.js'), 'utf8');
+ assert.ok(tcSource.includes('process.exit(0)'), 'Should call process.exit(0) for clean termination');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('uses process.stdout.write instead of console.log for pass-through', async () => {
+ const tcSource = fs.readFileSync(path.join(scriptsDir, 'post-edit-typecheck.js'), 'utf8');
+ assert.ok(tcSource.includes('process.stdout.write(data)'), 'Should use process.stdout.write');
+ const lines = tcSource.split('\n');
+ const passThrough = lines.filter(l => /console\.log\(data\)/.test(l));
+ assert.strictEqual(passThrough.length, 0, 'Should not use console.log(data) for pass-through');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('exact stdout pass-through without trailing newline (typecheck)', async () => {
+ const stdinJson = JSON.stringify({ tool_input: { file_path: '/nonexistent/file.py' } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), stdinJson);
+ assert.strictEqual(result.code, 0);
+ assert.strictEqual(result.stdout, stdinJson, 'stdout should exactly match stdin (no trailing newline)');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('exact stdout pass-through without trailing newline (format)', async () => {
+ const stdinJson = JSON.stringify({ tool_input: { file_path: '/nonexistent/file.py' } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-format.js'), stdinJson);
+ assert.strictEqual(result.code, 0);
+ assert.strictEqual(result.stdout, stdinJson, 'stdout should exactly match stdin (no trailing newline)');
+ })
+ )
+ passed++;
+ else failed++;
console.log('\nRound 29: post-edit-console-warn.js (extension and exit):');
- if (await asyncTest('source calls process.exit(0) after writing output', async () => {
- const cwSource = fs.readFileSync(path.join(scriptsDir, 'post-edit-console-warn.js'), 'utf8');
- assert.ok(cwSource.includes('process.exit(0)'), 'Should call process.exit(0)');
- })) passed++; else failed++;
-
- if (await asyncTest('does NOT match .mts or .mjs extensions', async () => {
- const stdinMts = JSON.stringify({ tool_input: { file_path: '/some/file.mts' } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), stdinMts);
- assert.strictEqual(result.code, 0);
- // .mts is not in the regex /\.(ts|tsx|js|jsx)$/, so no console.log scan
- assert.strictEqual(result.stdout, stdinMts, 'Should pass through .mts without scanning');
- assert.ok(!result.stderr.includes('console.log'), 'Should NOT scan .mts files for console.log');
- })) passed++; else failed++;
-
- if (await asyncTest('does NOT match uppercase .TS extension', async () => {
- const stdinTS = JSON.stringify({ tool_input: { file_path: '/some/file.TS' } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), stdinTS);
- assert.strictEqual(result.code, 0);
- assert.strictEqual(result.stdout, stdinTS, 'Should pass through .TS without scanning');
- assert.ok(!result.stderr.includes('console.log'), 'Should NOT scan .TS (uppercase) files');
- })) passed++; else failed++;
-
- if (await asyncTest('detects console.log in commented-out code', async () => {
- const testDir = createTestDir();
- const testFile = path.join(testDir, 'commented.js');
- fs.writeFileSync(testFile, '// console.log("debug")\nconst x = 1;\n');
- const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), stdinJson);
- assert.strictEqual(result.code, 0);
- // The regex /console\.log/ matches even in comments — this is intentional
- assert.ok(result.stderr.includes('console.log'), 'Should detect console.log even in comments');
- cleanupTestDir(testDir);
- })) passed++; else failed++;
+ if (
+ await asyncTest('source calls process.exit(0) after writing output', async () => {
+ const cwSource = fs.readFileSync(path.join(scriptsDir, 'post-edit-console-warn.js'), 'utf8');
+ assert.ok(cwSource.includes('process.exit(0)'), 'Should call process.exit(0)');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('does NOT match .mts or .mjs extensions', async () => {
+ const stdinMts = JSON.stringify({ tool_input: { file_path: '/some/file.mts' } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), stdinMts);
+ assert.strictEqual(result.code, 0);
+ // .mts is not in the regex /\.(ts|tsx|js|jsx)$/, so no console.log scan
+ assert.strictEqual(result.stdout, stdinMts, 'Should pass through .mts without scanning');
+ assert.ok(!result.stderr.includes('console.log'), 'Should NOT scan .mts files for console.log');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('does NOT match uppercase .TS extension', async () => {
+ const stdinTS = JSON.stringify({ tool_input: { file_path: '/some/file.TS' } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), stdinTS);
+ assert.strictEqual(result.code, 0);
+ assert.strictEqual(result.stdout, stdinTS, 'Should pass through .TS without scanning');
+ assert.ok(!result.stderr.includes('console.log'), 'Should NOT scan .TS (uppercase) files');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('detects console.log in commented-out code', async () => {
+ const testDir = createTestDir();
+ const testFile = path.join(testDir, 'commented.js');
+ fs.writeFileSync(testFile, '// console.log("debug")\nconst x = 1;\n');
+ const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), stdinJson);
+ assert.strictEqual(result.code, 0);
+ // The regex /console\.log/ matches even in comments — this is intentional
+ assert.ok(result.stderr.includes('console.log'), 'Should detect console.log even in comments');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
console.log('\nRound 29: check-console-log.js (exclusion patterns and exit):');
- if (await asyncTest('source calls process.exit(0) after writing output', async () => {
- const clSource = fs.readFileSync(path.join(scriptsDir, 'check-console-log.js'), 'utf8');
- // Should have at least 2 process.exit(0) calls (early return + end)
- const exitCalls = clSource.match(/process\.exit\(0\)/g) || [];
- assert.ok(exitCalls.length >= 2, `Should have at least 2 process.exit(0) calls, found ${exitCalls.length}`);
- })) passed++; else failed++;
-
- if (await asyncTest('EXCLUDED_PATTERNS correctly excludes test files', async () => {
- // Test the patterns directly by reading the source and evaluating the regex
- const source = fs.readFileSync(path.join(scriptsDir, 'check-console-log.js'), 'utf8');
- // Verify the 6 exclusion patterns exist in the source (as regex literals with escapes)
- const expectedSubstrings = ['test', 'spec', 'config', 'scripts', '__tests__', '__mocks__'];
- for (const substr of expectedSubstrings) {
- assert.ok(source.includes(substr), `Should include pattern containing "${substr}"`);
- }
- // Verify the array name exists
- assert.ok(source.includes('EXCLUDED_PATTERNS'), 'Should have EXCLUDED_PATTERNS array');
- })) passed++; else failed++;
-
- if (await asyncTest('exclusion patterns match expected file paths', async () => {
- // Recreate the EXCLUDED_PATTERNS from the source and test them
- const EXCLUDED_PATTERNS = [
- /\.test\.[jt]sx?$/,
- /\.spec\.[jt]sx?$/,
- /\.config\.[jt]s$/,
- /scripts\//,
- /__tests__\//,
- /__mocks__\//,
- ];
- // These SHOULD be excluded
- const excluded = [
- 'src/utils.test.ts', 'src/utils.test.js', 'src/utils.test.tsx', 'src/utils.test.jsx',
- 'src/utils.spec.ts', 'src/utils.spec.js',
- 'src/utils.config.ts', 'src/utils.config.js',
- 'scripts/hooks/session-end.js',
- '__tests__/utils.ts',
- '__mocks__/api.ts',
- ];
- for (const f of excluded) {
- const matches = EXCLUDED_PATTERNS.some(p => p.test(f));
- assert.ok(matches, `Expected "${f}" to be excluded but it was not`);
- }
- // These should NOT be excluded
- const notExcluded = [
- 'src/utils.ts', 'src/main.tsx', 'src/app.js',
- 'src/test.component.ts', // "test" in name but not .test. pattern
- 'src/config.ts', // "config" in name but not .config. pattern
- ];
- for (const f of notExcluded) {
- const matches = EXCLUDED_PATTERNS.some(p => p.test(f));
- assert.ok(!matches, `Expected "${f}" to NOT be excluded but it was`);
- }
- })) passed++; else failed++;
+ if (
+ await asyncTest('source calls process.exit(0) after writing output', async () => {
+ const clSource = fs.readFileSync(path.join(scriptsDir, 'check-console-log.js'), 'utf8');
+ // Should have at least 2 process.exit(0) calls (early return + end)
+ const exitCalls = clSource.match(/process\.exit\(0\)/g) || [];
+ assert.ok(exitCalls.length >= 2, `Should have at least 2 process.exit(0) calls, found ${exitCalls.length}`);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('EXCLUDED_PATTERNS correctly excludes test files', async () => {
+ // Test the patterns directly by reading the source and evaluating the regex
+ const source = fs.readFileSync(path.join(scriptsDir, 'check-console-log.js'), 'utf8');
+ // Verify the 6 exclusion patterns exist in the source (as regex literals with escapes)
+ const expectedSubstrings = ['test', 'spec', 'config', 'scripts', '__tests__', '__mocks__'];
+ for (const substr of expectedSubstrings) {
+ assert.ok(source.includes(substr), `Should include pattern containing "${substr}"`);
+ }
+ // Verify the array name exists
+ assert.ok(source.includes('EXCLUDED_PATTERNS'), 'Should have EXCLUDED_PATTERNS array');
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('exclusion patterns match expected file paths', async () => {
+ // Recreate the EXCLUDED_PATTERNS from the source and test them
+ const EXCLUDED_PATTERNS = [/\.test\.[jt]sx?$/, /\.spec\.[jt]sx?$/, /\.config\.[jt]s$/, /scripts\//, /__tests__\//, /__mocks__\//];
+ // These SHOULD be excluded
+ const excluded = [
+ 'src/utils.test.ts',
+ 'src/utils.test.js',
+ 'src/utils.test.tsx',
+ 'src/utils.test.jsx',
+ 'src/utils.spec.ts',
+ 'src/utils.spec.js',
+ 'src/utils.config.ts',
+ 'src/utils.config.js',
+ 'scripts/hooks/session-end.js',
+ '__tests__/utils.ts',
+ '__mocks__/api.ts'
+ ];
+ for (const f of excluded) {
+ const matches = EXCLUDED_PATTERNS.some(p => p.test(f));
+ assert.ok(matches, `Expected "${f}" to be excluded but it was not`);
+ }
+ // These should NOT be excluded
+ const notExcluded = [
+ 'src/utils.ts',
+ 'src/main.tsx',
+ 'src/app.js',
+ 'src/test.component.ts', // "test" in name but not .test. pattern
+ 'src/config.ts' // "config" in name but not .config. pattern
+ ];
+ for (const f of notExcluded) {
+ const matches = EXCLUDED_PATTERNS.some(p => p.test(f));
+ assert.ok(!matches, `Expected "${f}" to NOT be excluded but it was`);
+ }
+ })
+ )
+ passed++;
+ else failed++;
console.log('\nRound 29: run-all.js test runner improvements:');
- if (await asyncTest('test runner uses spawnSync to capture stderr on success', async () => {
- const runAllSource = fs.readFileSync(path.join(__dirname, '..', 'run-all.js'), 'utf8');
- assert.ok(runAllSource.includes('spawnSync'), 'Should use spawnSync instead of execSync');
- assert.ok(!runAllSource.includes('execSync'), 'Should not use execSync');
- // Verify it shows stderr
- assert.ok(runAllSource.includes('stderr'), 'Should handle stderr output');
- })) passed++; else failed++;
+ if (
+ await asyncTest('test runner uses spawnSync to capture stderr on success', async () => {
+ const runAllSource = fs.readFileSync(path.join(__dirname, '..', 'run-all.js'), 'utf8');
+ assert.ok(runAllSource.includes('spawnSync'), 'Should use spawnSync instead of execSync');
+ assert.ok(!runAllSource.includes('execSync'), 'Should not use execSync');
+ // Verify it shows stderr
+ assert.ok(runAllSource.includes('stderr'), 'Should handle stderr output');
+ })
+ )
+ passed++;
+ else failed++;
// ── Round 32: post-edit-typecheck special characters & check-console-log ──
console.log('\nRound 32: post-edit-typecheck (special character paths):');
- if (await asyncTest('handles file path with spaces gracefully', async () => {
- const testDir = createTestDir();
- const testFile = path.join(testDir, 'my file.ts');
- fs.writeFileSync(testFile, 'const x: number = 1;');
-
- const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), stdinJson);
- assert.strictEqual(result.code, 0, 'Should handle spaces in path');
- assert.ok(result.stdout.includes('tool_input'), 'Should pass through data');
- cleanupTestDir(testDir);
- })) passed++; else failed++;
-
- if (await asyncTest('handles file path with shell metacharacters safely', async () => {
- const testDir = createTestDir();
- // File name with characters that could be dangerous in shell contexts
- const testFile = path.join(testDir, 'test$(echo).ts');
- fs.writeFileSync(testFile, 'const x: number = 1;');
-
- const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), stdinJson);
- assert.strictEqual(result.code, 0, 'Should not crash on shell metacharacters');
- // execFileSync prevents shell injection — just verify no crash
- assert.ok(result.stdout.includes('tool_input'), 'Should pass through data safely');
- cleanupTestDir(testDir);
- })) passed++; else failed++;
-
- if (await asyncTest('handles .tsx file extension', async () => {
- const testDir = createTestDir();
- const testFile = path.join(testDir, 'component.tsx');
- fs.writeFileSync(testFile, 'const App = () => <div>Hello</div>;');
-
- const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), stdinJson);
- assert.strictEqual(result.code, 0, 'Should handle .tsx files');
- assert.ok(result.stdout.includes('tool_input'), 'Should pass through data');
- cleanupTestDir(testDir);
- })) passed++; else failed++;
+ if (
+ await asyncTest('handles file path with spaces gracefully', async () => {
+ const testDir = createTestDir();
+ const testFile = path.join(testDir, 'my file.ts');
+ fs.writeFileSync(testFile, 'const x: number = 1;');
+
+ const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), stdinJson);
+ assert.strictEqual(result.code, 0, 'Should handle spaces in path');
+ assert.ok(result.stdout.includes('tool_input'), 'Should pass through data');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('handles file path with shell metacharacters safely', async () => {
+ const testDir = createTestDir();
+ // File name with characters that could be dangerous in shell contexts
+ const testFile = path.join(testDir, 'test$(echo).ts');
+ fs.writeFileSync(testFile, 'const x: number = 1;');
+
+ const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), stdinJson);
+ assert.strictEqual(result.code, 0, 'Should not crash on shell metacharacters');
+ // execFileSync prevents shell injection — just verify no crash
+ assert.ok(result.stdout.includes('tool_input'), 'Should pass through data safely');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('handles .tsx file extension', async () => {
+ const testDir = createTestDir();
+ const testFile = path.join(testDir, 'component.tsx');
+ fs.writeFileSync(testFile, 'const App = () => <div>Hello</div>;');
+
+ const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), stdinJson);
+ assert.strictEqual(result.code, 0, 'Should handle .tsx files');
+ assert.ok(result.stdout.includes('tool_input'), 'Should pass through data');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
console.log('\nRound 32: check-console-log (edge cases):');
- if (await asyncTest('passes through data when git commands fail', async () => {
- // Run from a non-git directory
- const testDir = createTestDir();
- const stdinData = JSON.stringify({ tool_name: 'Write', tool_input: {} });
- const result = await runScript(path.join(scriptsDir, 'check-console-log.js'), stdinData);
- assert.strictEqual(result.code, 0, 'Should exit 0');
- assert.ok(result.stdout.includes('tool_name'), 'Should pass through stdin');
- cleanupTestDir(testDir);
- })) passed++; else failed++;
-
- if (await asyncTest('handles very large stdin within limit', async () => {
- // Send just under the 1MB limit
- const largePayload = JSON.stringify({ tool_name: 'x'.repeat(500000) });
- const result = await runScript(path.join(scriptsDir, 'check-console-log.js'), largePayload);
- assert.strictEqual(result.code, 0, 'Should handle large stdin');
- })) passed++; else failed++;
+ if (
+ await asyncTest('passes through data when git commands fail', async () => {
+ // Run from a non-git directory
+ const testDir = createTestDir();
+ const stdinData = JSON.stringify({ tool_name: 'Write', tool_input: {} });
+ const result = await runScript(path.join(scriptsDir, 'check-console-log.js'), stdinData);
+ assert.strictEqual(result.code, 0, 'Should exit 0');
+ assert.ok(result.stdout.includes('tool_name'), 'Should pass through stdin');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('handles very large stdin within limit', async () => {
+ // Send just under the 1MB limit
+ const largePayload = JSON.stringify({ tool_name: 'x'.repeat(500000) });
+ const result = await runScript(path.join(scriptsDir, 'check-console-log.js'), largePayload);
+ assert.strictEqual(result.code, 0, 'Should handle large stdin');
+ })
+ )
+ passed++;
+ else failed++;
console.log('\nRound 32: post-edit-console-warn (additional edge cases):');
- if (await asyncTest('handles file with only console.error (no warning)', async () => {
- const testDir = createTestDir();
- const testFile = path.join(testDir, 'errors-only.ts');
- fs.writeFileSync(testFile, 'console.error("this is fine");\nconsole.warn("also fine");');
+ if (
+ await asyncTest('handles file with only console.error (no warning)', async () => {
+ const testDir = createTestDir();
+ const testFile = path.join(testDir, 'errors-only.ts');
+ fs.writeFileSync(testFile, 'console.error("this is fine");\nconsole.warn("also fine");');
- const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), stdinJson);
- assert.ok(!result.stderr.includes('WARNING'), 'Should NOT warn for console.error/warn only');
- cleanupTestDir(testDir);
- })) passed++; else failed++;
-
- if (await asyncTest('handles null tool_input gracefully', async () => {
- const stdinJson = JSON.stringify({ tool_input: null });
- const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), stdinJson);
- assert.strictEqual(result.code, 0, 'Should handle null tool_input');
- assert.ok(result.stdout.includes('tool_input'), 'Should pass through data');
- })) passed++; else failed++;
+ const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), stdinJson);
+ assert.ok(!result.stderr.includes('WARNING'), 'Should NOT warn for console.error/warn only');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('handles null tool_input gracefully', async () => {
+ const stdinJson = JSON.stringify({ tool_input: null });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), stdinJson);
+ assert.strictEqual(result.code, 0, 'Should handle null tool_input');
+ assert.ok(result.stdout.includes('tool_input'), 'Should pass through data');
+ })
+ )
+ passed++;
+ else failed++;
console.log('\nRound 32: session-end.js (empty transcript):');
- if (await asyncTest('handles completely empty transcript file', async () => {
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'empty.jsonl');
- fs.writeFileSync(transcriptPath, '');
-
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson);
- assert.strictEqual(result.code, 0, 'Should handle empty transcript');
- cleanupTestDir(testDir);
- })) passed++; else failed++;
-
- if (await asyncTest('handles transcript with only whitespace lines', async () => {
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'whitespace.jsonl');
- fs.writeFileSync(transcriptPath, ' \n\n \n');
+ if (
+ await asyncTest('handles completely empty transcript file', async () => {
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'empty.jsonl');
+ fs.writeFileSync(transcriptPath, '');
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson);
- assert.strictEqual(result.code, 0, 'Should handle whitespace-only transcript');
- cleanupTestDir(testDir);
- })) passed++; else failed++;
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson);
+ assert.strictEqual(result.code, 0, 'Should handle empty transcript');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('handles transcript with only whitespace lines', async () => {
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'whitespace.jsonl');
+ fs.writeFileSync(transcriptPath, ' \n\n \n');
+
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson);
+ assert.strictEqual(result.code, 0, 'Should handle whitespace-only transcript');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
// ── Round 38: evaluate-session.js tilde expansion & missing config ──
console.log('\nRound 38: evaluate-session.js (tilde expansion & missing config):');
- if (await asyncTest('expands ~ in learned_skills_path to home directory', async () => {
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
- // 1 user message — below threshold, but we only need to verify directory creation
- fs.writeFileSync(transcriptPath, '{"type":"user","content":"msg"}');
-
- const skillsDir = path.join(testDir, 'skills', 'continuous-learning');
- fs.mkdirSync(skillsDir, { recursive: true });
- const configPath = path.join(skillsDir, 'config.json');
- // Use ~ prefix — should expand to the HOME dir we set
- fs.writeFileSync(configPath, JSON.stringify({
- learned_skills_path: '~/test-tilde-skills'
- }));
-
- const wrapperScript = createEvalWrapper(testDir, configPath);
-
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(wrapperScript, stdinJson, {
- HOME: testDir, USERPROFILE: testDir
- });
- assert.strictEqual(result.code, 0);
- // ~ should expand to os.homedir() which during the script run is the real home
- // The script creates the directory via ensureDir — check that it attempted to
- // create a directory starting with the home dir, not a literal ~/
- // Verify the literal ~/test-tilde-skills was NOT created
- assert.ok(
- !fs.existsSync(path.join(testDir, '~', 'test-tilde-skills')),
- 'Should NOT create literal ~/test-tilde-skills directory'
- );
- cleanupTestDir(testDir);
- })) passed++; else failed++;
-
- if (await asyncTest('does NOT expand ~ in middle of learned_skills_path', async () => {
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
- fs.writeFileSync(transcriptPath, '{"type":"user","content":"msg"}');
-
- const midTildeDir = path.join(testDir, 'some~path', 'skills');
- const skillsDir = path.join(testDir, 'skills', 'continuous-learning');
- fs.mkdirSync(skillsDir, { recursive: true });
- const configPath = path.join(skillsDir, 'config.json');
- // Path with ~ in the middle — should NOT be expanded
- fs.writeFileSync(configPath, JSON.stringify({
- learned_skills_path: midTildeDir
- }));
-
- const wrapperScript = createEvalWrapper(testDir, configPath);
-
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(wrapperScript, stdinJson, {
- HOME: testDir, USERPROFILE: testDir
- });
- assert.strictEqual(result.code, 0);
- // The directory with ~ in the middle should be created as-is
- assert.ok(
- fs.existsSync(midTildeDir),
- 'Should create directory with ~ in middle of path unchanged'
- );
- cleanupTestDir(testDir);
- })) passed++; else failed++;
-
- if (await asyncTest('uses defaults when config file does not exist', async () => {
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
- // 5 user messages — below default threshold of 10
- const lines = [];
- for (let i = 0; i < 5; i++) lines.push(`{"type":"user","content":"msg${i}"}`);
- fs.writeFileSync(transcriptPath, lines.join('\n'));
-
- // Point config to a non-existent file
- const configPath = path.join(testDir, 'nonexistent', 'config.json');
- const wrapperScript = createEvalWrapper(testDir, configPath);
-
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(wrapperScript, stdinJson, {
- HOME: testDir, USERPROFILE: testDir
- });
- assert.strictEqual(result.code, 0);
- // With no config file, default min_session_length=10 applies
- // 5 messages should be "too short"
- assert.ok(
- result.stderr.includes('too short'),
- 'Should use default threshold (10) when config file missing'
- );
- // No error messages about missing config
- assert.ok(
- !result.stderr.includes('Failed to parse config'),
- 'Should NOT log config parse error for missing file'
- );
- cleanupTestDir(testDir);
- })) passed++; else failed++;
+ if (
+ await asyncTest('expands ~ in learned_skills_path to home directory', async () => {
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
+ // 1 user message — below threshold, but we only need to verify directory creation
+ fs.writeFileSync(transcriptPath, '{"type":"user","content":"msg"}');
+
+ const skillsDir = path.join(testDir, 'skills', 'continuous-learning');
+ fs.mkdirSync(skillsDir, { recursive: true });
+ const configPath = path.join(skillsDir, 'config.json');
+ // Use ~ prefix — should expand to the HOME dir we set
+ fs.writeFileSync(
+ configPath,
+ JSON.stringify({
+ learned_skills_path: '~/test-tilde-skills'
+ })
+ );
- // Round 41: pre-compact.js (multiple session files)
- console.log('\nRound 41: pre-compact.js (multiple session files):');
+ const wrapperScript = createEvalWrapper(testDir, configPath);
- if (await asyncTest('annotates only the newest session file when multiple exist', async () => {
- const isoHome = path.join(os.tmpdir(), `ecc-compact-multi-${Date.now()}`);
- const sessionsDir = path.join(isoHome, '.claude', 'sessions');
- fs.mkdirSync(sessionsDir, { recursive: true });
-
- // Create two session files with different mtimes
- const olderSession = path.join(sessionsDir, '2026-01-01-older-session.tmp');
- const newerSession = path.join(sessionsDir, '2026-02-11-newer-session.tmp');
- fs.writeFileSync(olderSession, '# Older Session\n');
- // Small delay to ensure different mtime
- const now = Date.now();
- fs.utimesSync(olderSession, new Date(now - 60000), new Date(now - 60000));
- fs.writeFileSync(newerSession, '# Newer Session\n');
-
- try {
- const result = await runScript(path.join(scriptsDir, 'pre-compact.js'), '', {
- HOME: isoHome, USERPROFILE: isoHome
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(wrapperScript, stdinJson, {
+ HOME: testDir,
+ USERPROFILE: testDir
});
assert.strictEqual(result.code, 0);
+ // ~ should expand to os.homedir() which during the script run is the real home
+ // The script creates the directory via ensureDir — check that it attempted to
+ // create a directory starting with the home dir, not a literal ~/
+ // Verify the literal ~/test-tilde-skills was NOT created
+ assert.ok(!fs.existsSync(path.join(testDir, '~', 'test-tilde-skills')), 'Should NOT create literal ~/test-tilde-skills directory');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('does NOT expand ~ in middle of learned_skills_path', async () => {
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
+ fs.writeFileSync(transcriptPath, '{"type":"user","content":"msg"}');
+
+ const midTildeDir = path.join(testDir, 'some~path', 'skills');
+ const skillsDir = path.join(testDir, 'skills', 'continuous-learning');
+ fs.mkdirSync(skillsDir, { recursive: true });
+ const configPath = path.join(skillsDir, 'config.json');
+ // Path with ~ in the middle — should NOT be expanded
+ fs.writeFileSync(
+ configPath,
+ JSON.stringify({
+ learned_skills_path: midTildeDir
+ })
+ );
- const newerContent = fs.readFileSync(newerSession, 'utf8');
- const olderContent = fs.readFileSync(olderSession, 'utf8');
+ const wrapperScript = createEvalWrapper(testDir, configPath);
- // findFiles sorts by mtime newest first, so sessions[0] is the newest
- assert.ok(
- newerContent.includes('Compaction occurred'),
- 'Should annotate the newest session file'
- );
- assert.strictEqual(
- olderContent,
- '# Older Session\n',
- 'Should NOT annotate older session files'
- );
- } finally {
- fs.rmSync(isoHome, { recursive: true, force: true });
- }
- })) passed++; else failed++;
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(wrapperScript, stdinJson, {
+ HOME: testDir,
+ USERPROFILE: testDir
+ });
+ assert.strictEqual(result.code, 0);
+ // The directory with ~ in the middle should be created as-is
+ assert.ok(fs.existsSync(midTildeDir), 'Should create directory with ~ in middle of path unchanged');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('uses defaults when config file does not exist', async () => {
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
+ // 5 user messages — below default threshold of 10
+ const lines = [];
+ for (let i = 0; i < 5; i++) lines.push(`{"type":"user","content":"msg${i}"}`);
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
+
+ // Point config to a non-existent file
+ const configPath = path.join(testDir, 'nonexistent', 'config.json');
+ const wrapperScript = createEvalWrapper(testDir, configPath);
+
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(wrapperScript, stdinJson, {
+ HOME: testDir,
+ USERPROFILE: testDir
+ });
+ assert.strictEqual(result.code, 0);
+ // With no config file, default min_session_length=10 applies
+ // 5 messages should be "too short"
+ assert.ok(result.stderr.includes('too short'), 'Should use default threshold (10) when config file missing');
+ // No error messages about missing config
+ assert.ok(!result.stderr.includes('Failed to parse config'), 'Should NOT log config parse error for missing file');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
+
+ // Round 41: pre-compact.js (multiple session files)
+ console.log('\nRound 41: pre-compact.js (multiple session files):');
+
+ if (
+ await asyncTest('annotates only the newest session file when multiple exist', async () => {
+ const isoHome = path.join(os.tmpdir(), `ecc-compact-multi-${Date.now()}`);
+ const sessionsDir = path.join(isoHome, '.claude', 'sessions');
+ fs.mkdirSync(sessionsDir, { recursive: true });
+
+ // Create two session files with different mtimes
+ const olderSession = path.join(sessionsDir, '2026-01-01-older-session.tmp');
+ const newerSession = path.join(sessionsDir, '2026-02-11-newer-session.tmp');
+ fs.writeFileSync(olderSession, '# Older Session\n');
+ // Small delay to ensure different mtime
+ const now = Date.now();
+ fs.utimesSync(olderSession, new Date(now - 60000), new Date(now - 60000));
+ fs.writeFileSync(newerSession, '# Newer Session\n');
+
+ try {
+ const result = await runScript(path.join(scriptsDir, 'pre-compact.js'), '', {
+ HOME: isoHome,
+ USERPROFILE: isoHome
+ });
+ assert.strictEqual(result.code, 0);
+
+ const newerContent = fs.readFileSync(newerSession, 'utf8');
+ const olderContent = fs.readFileSync(olderSession, 'utf8');
+
+ // findFiles sorts by mtime newest first, so sessions[0] is the newest
+ assert.ok(newerContent.includes('Compaction occurred'), 'Should annotate the newest session file');
+ assert.strictEqual(olderContent, '# Older Session\n', 'Should NOT annotate older session files');
+ } finally {
+ fs.rmSync(isoHome, { recursive: true, force: true });
+ }
+ })
+ )
+ passed++;
+ else failed++;
// Round 40: session-end.js (newline collapse in markdown list items)
console.log('\nRound 40: session-end.js (newline collapse):');
- if (await asyncTest('collapses newlines in user messages to single-line markdown items', async () => {
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
+ if (
+ await asyncTest('collapses newlines in user messages to single-line markdown items', async () => {
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
- // User message containing newlines that would break markdown list
- const lines = [
- JSON.stringify({ type: 'user', content: 'Please help me with:\n1. Task one\n2. Task two\n3. Task three' }),
- ];
- fs.writeFileSync(transcriptPath, lines.join('\n'));
+ // User message containing newlines that would break markdown list
+ const lines = [JSON.stringify({ type: 'user', content: 'Please help me with:\n1. Task one\n2. Task two\n3. Task three' })];
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
- HOME: testDir
- });
- assert.strictEqual(result.code, 0);
-
- // Find the session file and verify newlines were collapsed
- const claudeDir = path.join(testDir, '.claude', 'sessions');
- if (fs.existsSync(claudeDir)) {
- const files = fs.readdirSync(claudeDir).filter(f => f.endsWith('.tmp'));
- if (files.length > 0) {
- const content = fs.readFileSync(path.join(claudeDir, files[0]), 'utf8');
- // Each task should be a single-line markdown list item
- const taskLines = content.split('\n').filter(l => l.startsWith('- '));
- for (const line of taskLines) {
- assert.ok(
- !line.includes('\n'),
- 'Task list items should be single-line'
- );
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
+ HOME: testDir
+ });
+ assert.strictEqual(result.code, 0);
+
+ // Find the session file and verify newlines were collapsed
+ const claudeDir = path.join(testDir, '.claude', 'sessions');
+ if (fs.existsSync(claudeDir)) {
+ const files = fs.readdirSync(claudeDir).filter(f => f.endsWith('.tmp'));
+ if (files.length > 0) {
+ const content = fs.readFileSync(path.join(claudeDir, files[0]), 'utf8');
+ // Each task should be a single-line markdown list item
+ const taskLines = content.split('\n').filter(l => l.startsWith('- '));
+ for (const line of taskLines) {
+ assert.ok(!line.includes('\n'), 'Task list items should be single-line');
+ }
+ // Newlines should be replaced with spaces
+ assert.ok(content.includes('Please help me with: 1. Task one 2. Task two'), `Newlines should be collapsed to spaces, got: ${content.substring(0, 500)}`);
}
- // Newlines should be replaced with spaces
- assert.ok(
- content.includes('Please help me with: 1. Task one 2. Task two'),
- `Newlines should be collapsed to spaces, got: ${content.substring(0, 500)}`
- );
}
- }
- cleanupTestDir(testDir);
- })) passed++; else failed++;
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
// ── Round 44: session-start.js empty session file ──
console.log('\nRound 44: session-start.js (empty session file):');
- if (await asyncTest('does not inject empty session file content into context', async () => {
- const isoHome = path.join(os.tmpdir(), `ecc-start-empty-file-${Date.now()}`);
- const sessionsDir = path.join(isoHome, '.claude', 'sessions');
- fs.mkdirSync(sessionsDir, { recursive: true });
- fs.mkdirSync(path.join(isoHome, '.claude', 'skills', 'learned'), { recursive: true });
+ if (
+ await asyncTest('does not inject empty session file content into context', async () => {
+ const isoHome = path.join(os.tmpdir(), `ecc-start-empty-file-${Date.now()}`);
+ const sessionsDir = path.join(isoHome, '.claude', 'sessions');
+ fs.mkdirSync(sessionsDir, { recursive: true });
+ fs.mkdirSync(path.join(isoHome, '.claude', 'skills', 'learned'), { recursive: true });
- // Create a 0-byte session file (simulates truncated/corrupted write)
- const today = new Date().toISOString().slice(0, 10);
- const sessionFile = path.join(sessionsDir, `${today}-empty0000-session.tmp`);
- fs.writeFileSync(sessionFile, '');
+ // Create a 0-byte session file (simulates truncated/corrupted write)
+ const today = new Date().toISOString().slice(0, 10);
+ const sessionFile = path.join(sessionsDir, `${today}-empty0000-session.tmp`);
+ fs.writeFileSync(sessionFile, '');
- try {
- const result = await runScript(path.join(scriptsDir, 'session-start.js'), '', {
- HOME: isoHome, USERPROFILE: isoHome
- });
- assert.strictEqual(result.code, 0, 'Should exit 0 with empty session file');
- // readFile returns '' (falsy) → the if (content && ...) guard skips injection
- assert.ok(
- !result.stdout.includes('Previous session summary'),
- 'Should NOT inject empty string into context'
- );
- } finally {
- fs.rmSync(isoHome, { recursive: true, force: true });
- }
- })) passed++; else failed++;
+ try {
+ const result = await runScript(path.join(scriptsDir, 'session-start.js'), '', {
+ HOME: isoHome,
+ USERPROFILE: isoHome
+ });
+ assert.strictEqual(result.code, 0, 'Should exit 0 with empty session file');
+ // readFile returns '' (falsy) → the if (content && ...) guard skips injection
+ assert.ok(!result.stdout.includes('Previous session summary'), 'Should NOT inject empty string into context');
+ } finally {
+ fs.rmSync(isoHome, { recursive: true, force: true });
+ }
+ })
+ )
+ passed++;
+ else failed++;
// ── Round 49: typecheck extension matching and session-end conditional sections ──
console.log('\nRound 49: post-edit-typecheck.js (extension edge cases):');
- if (await asyncTest('.d.ts files match the TS regex and trigger typecheck path', async () => {
- const testDir = createTestDir();
- const testFile = path.join(testDir, 'types.d.ts');
- fs.writeFileSync(testFile, 'declare const x: number;');
-
- const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), stdinJson);
- assert.strictEqual(result.code, 0, 'Should exit 0 for .d.ts file');
- assert.ok(result.stdout.includes('tool_input'), 'Should pass through stdin data');
- cleanupTestDir(testDir);
- })) passed++; else failed++;
-
- if (await asyncTest('.mts extension does not trigger typecheck', async () => {
- const stdinJson = JSON.stringify({ tool_input: { file_path: '/project/utils.mts' } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), stdinJson);
- assert.strictEqual(result.code, 0, 'Should exit 0 for .mts file');
- assert.strictEqual(result.stdout, stdinJson, 'Should pass through .mts unchanged');
- })) passed++; else failed++;
+ if (
+ await asyncTest('.d.ts files match the TS regex and trigger typecheck path', async () => {
+ const testDir = createTestDir();
+ const testFile = path.join(testDir, 'types.d.ts');
+ fs.writeFileSync(testFile, 'declare const x: number;');
+
+ const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), stdinJson);
+ assert.strictEqual(result.code, 0, 'Should exit 0 for .d.ts file');
+ assert.ok(result.stdout.includes('tool_input'), 'Should pass through stdin data');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('.mts extension does not trigger typecheck', async () => {
+ const stdinJson = JSON.stringify({ tool_input: { file_path: '/project/utils.mts' } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), stdinJson);
+ assert.strictEqual(result.code, 0, 'Should exit 0 for .mts file');
+ assert.strictEqual(result.stdout, stdinJson, 'Should pass through .mts unchanged');
+ })
+ )
+ passed++;
+ else failed++;
console.log('\nRound 49: session-end.js (conditional summary sections):');
- if (await asyncTest('summary omits Files Modified and Tools Used when none found', async () => {
- const isoHome = path.join(os.tmpdir(), `ecc-notools-${Date.now()}`);
- const sessionsDir = path.join(isoHome, '.claude', 'sessions');
- fs.mkdirSync(sessionsDir, { recursive: true });
-
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
- // Only user messages — no tool_use entries at all
- const lines = [
- '{"type":"user","content":"How does authentication work?"}',
- '{"type":"assistant","message":{"content":[{"type":"text","text":"It uses JWT"}]}}'
- ];
- fs.writeFileSync(transcriptPath, lines.join('\n'));
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
-
- try {
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
- HOME: isoHome, USERPROFILE: isoHome
- });
- assert.strictEqual(result.code, 0);
+ if (
+ await asyncTest('summary omits Files Modified and Tools Used when none found', async () => {
+ const isoHome = path.join(os.tmpdir(), `ecc-notools-${Date.now()}`);
+ const sessionsDir = path.join(isoHome, '.claude', 'sessions');
+ fs.mkdirSync(sessionsDir, { recursive: true });
- const files = fs.readdirSync(sessionsDir).filter(f => f.endsWith('-session.tmp'));
- assert.ok(files.length > 0, 'Should create session file');
- const content = fs.readFileSync(path.join(sessionsDir, files[0]), 'utf8');
- assert.ok(content.includes('authentication'), 'Should include user message');
- assert.ok(!content.includes('### Files Modified'), 'Should omit Files Modified when empty');
- assert.ok(!content.includes('### Tools Used'), 'Should omit Tools Used when empty');
- } finally {
- fs.rmSync(isoHome, { recursive: true, force: true });
- cleanupTestDir(testDir);
- }
- })) passed++; else failed++;
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
+ // Only user messages — no tool_use entries at all
+ const lines = ['{"type":"user","content":"How does authentication work?"}', '{"type":"assistant","message":{"content":[{"type":"text","text":"It uses JWT"}]}}'];
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+
+ try {
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
+ HOME: isoHome,
+ USERPROFILE: isoHome
+ });
+ assert.strictEqual(result.code, 0);
+
+ const files = fs.readdirSync(sessionsDir).filter(f => f.endsWith('-session.tmp'));
+ assert.ok(files.length > 0, 'Should create session file');
+ const content = fs.readFileSync(path.join(sessionsDir, files[0]), 'utf8');
+ assert.ok(content.includes('authentication'), 'Should include user message');
+ assert.ok(!content.includes('### Files Modified'), 'Should omit Files Modified when empty');
+ assert.ok(!content.includes('### Tools Used'), 'Should omit Tools Used when empty');
+ } finally {
+ fs.rmSync(isoHome, { recursive: true, force: true });
+ cleanupTestDir(testDir);
+ }
+ })
+ )
+ passed++;
+ else failed++;
// ── Round 50: alias reporting, parallel compaction, graceful degradation ──
console.log('\nRound 50: session-start.js (alias reporting):');
- if (await asyncTest('reports available session aliases on startup', async () => {
- const isoHome = path.join(os.tmpdir(), `ecc-start-alias-${Date.now()}`);
- fs.mkdirSync(path.join(isoHome, '.claude', 'sessions'), { recursive: true });
- fs.mkdirSync(path.join(isoHome, '.claude', 'skills', 'learned'), { recursive: true });
-
- // Pre-populate the aliases file
- fs.writeFileSync(path.join(isoHome, '.claude', 'session-aliases.json'), JSON.stringify({
- version: '1.0',
- aliases: {
- 'my-feature': { sessionPath: '/sessions/feat', createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(), title: null },
- 'bug-fix': { sessionPath: '/sessions/fix', createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(), title: null }
- },
- metadata: { totalCount: 2, lastUpdated: new Date().toISOString() }
- }));
-
- try {
- const result = await runScript(path.join(scriptsDir, 'session-start.js'), '', {
- HOME: isoHome, USERPROFILE: isoHome
- });
- assert.strictEqual(result.code, 0);
- assert.ok(result.stderr.includes('alias'), 'Should mention aliases in stderr');
- assert.ok(
- result.stderr.includes('my-feature') || result.stderr.includes('bug-fix'),
- 'Should list at least one alias name'
+ if (
+ await asyncTest('reports available session aliases on startup', async () => {
+ const isoHome = path.join(os.tmpdir(), `ecc-start-alias-${Date.now()}`);
+ fs.mkdirSync(path.join(isoHome, '.claude', 'sessions'), { recursive: true });
+ fs.mkdirSync(path.join(isoHome, '.claude', 'skills', 'learned'), { recursive: true });
+
+ // Pre-populate the aliases file
+ fs.writeFileSync(
+ path.join(isoHome, '.claude', 'session-aliases.json'),
+ JSON.stringify({
+ version: '1.0',
+ aliases: {
+ 'my-feature': { sessionPath: '/sessions/feat', createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(), title: null },
+ 'bug-fix': { sessionPath: '/sessions/fix', createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(), title: null }
+ },
+ metadata: { totalCount: 2, lastUpdated: new Date().toISOString() }
+ })
);
- } finally {
- fs.rmSync(isoHome, { recursive: true, force: true });
- }
- })) passed++; else failed++;
- console.log('\nRound 50: pre-compact.js (parallel execution):');
+ try {
+ const result = await runScript(path.join(scriptsDir, 'session-start.js'), '', {
+ HOME: isoHome,
+ USERPROFILE: isoHome
+ });
+ assert.strictEqual(result.code, 0);
+ assert.ok(result.stderr.includes('alias'), 'Should mention aliases in stderr');
+ assert.ok(result.stderr.includes('my-feature') || result.stderr.includes('bug-fix'), 'Should list at least one alias name');
+ } finally {
+ fs.rmSync(isoHome, { recursive: true, force: true });
+ }
+ })
+ )
+ passed++;
+ else failed++;
- if (await asyncTest('parallel compaction runs all append to log without loss', async () => {
- const isoHome = path.join(os.tmpdir(), `ecc-compact-par-${Date.now()}`);
- const sessionsDir = path.join(isoHome, '.claude', 'sessions');
- fs.mkdirSync(sessionsDir, { recursive: true });
+ console.log('\nRound 50: pre-compact.js (parallel execution):');
- try {
- const promises = Array(3).fill(null).map(() =>
- runScript(path.join(scriptsDir, 'pre-compact.js'), '', {
- HOME: isoHome, USERPROFILE: isoHome
- })
- );
- const results = await Promise.all(promises);
- results.forEach((r, i) => assert.strictEqual(r.code, 0, `Run ${i} should exit 0`));
+ if (
+ await asyncTest('parallel compaction runs all append to log without loss', async () => {
+ const isoHome = path.join(os.tmpdir(), `ecc-compact-par-${Date.now()}`);
+ const sessionsDir = path.join(isoHome, '.claude', 'sessions');
+ fs.mkdirSync(sessionsDir, { recursive: true });
- const logFile = path.join(sessionsDir, 'compaction-log.txt');
- assert.ok(fs.existsSync(logFile), 'Compaction log should exist');
- const content = fs.readFileSync(logFile, 'utf8');
- const entries = (content.match(/Context compaction triggered/g) || []).length;
- assert.strictEqual(entries, 3, `Should have 3 log entries, got ${entries}`);
- } finally {
- fs.rmSync(isoHome, { recursive: true, force: true });
- }
- })) passed++; else failed++;
+ try {
+ const promises = Array(3)
+ .fill(null)
+ .map(() =>
+ runScript(path.join(scriptsDir, 'pre-compact.js'), '', {
+ HOME: isoHome,
+ USERPROFILE: isoHome
+ })
+ );
+ const results = await Promise.all(promises);
+ results.forEach((r, i) => assert.strictEqual(r.code, 0, `Run ${i} should exit 0`));
+
+ const logFile = path.join(sessionsDir, 'compaction-log.txt');
+ assert.ok(fs.existsSync(logFile), 'Compaction log should exist');
+ const content = fs.readFileSync(logFile, 'utf8');
+ const entries = (content.match(/Context compaction triggered/g) || []).length;
+ assert.strictEqual(entries, 3, `Should have 3 log entries, got ${entries}`);
+ } finally {
+ fs.rmSync(isoHome, { recursive: true, force: true });
+ }
+ })
+ )
+ passed++;
+ else failed++;
console.log('\nRound 50: session-start.js (graceful degradation):');
- if (await asyncTest('exits 0 when sessions path is a file (not a directory)', async () => {
- const isoHome = path.join(os.tmpdir(), `ecc-start-blocked-${Date.now()}`);
- fs.mkdirSync(path.join(isoHome, '.claude'), { recursive: true });
- // Block sessions dir creation by placing a file at that path
- fs.writeFileSync(path.join(isoHome, '.claude', 'sessions'), 'blocked');
+ if (
+ await asyncTest('exits 0 when sessions path is a file (not a directory)', async () => {
+ const isoHome = path.join(os.tmpdir(), `ecc-start-blocked-${Date.now()}`);
+ fs.mkdirSync(path.join(isoHome, '.claude'), { recursive: true });
+ // Block sessions dir creation by placing a file at that path
+ fs.writeFileSync(path.join(isoHome, '.claude', 'sessions'), 'blocked');
- try {
- const result = await runScript(path.join(scriptsDir, 'session-start.js'), '', {
- HOME: isoHome, USERPROFILE: isoHome
- });
- assert.strictEqual(result.code, 0, 'Should exit 0 even when sessions dir is blocked');
- } finally {
- fs.rmSync(isoHome, { recursive: true, force: true });
- }
- })) passed++; else failed++;
+ try {
+ const result = await runScript(path.join(scriptsDir, 'session-start.js'), '', {
+ HOME: isoHome,
+ USERPROFILE: isoHome
+ });
+ assert.strictEqual(result.code, 0, 'Should exit 0 even when sessions dir is blocked');
+ } finally {
+ fs.rmSync(isoHome, { recursive: true, force: true });
+ }
+ })
+ )
+ passed++;
+ else failed++;
// ── Round 53: console-warn max matches and format non-existent file ──
console.log('\nRound 53: post-edit-console-warn.js (max matches truncation):');
- if (await asyncTest('reports maximum 5 console.log matches per file', async () => {
- const testDir = createTestDir();
- const testFile = path.join(testDir, 'many-logs.js');
- const lines = Array(7).fill(null).map((_, i) =>
- `console.log("debug line ${i + 1}");`
- );
- fs.writeFileSync(testFile, lines.join('\n'));
+ if (
+ await asyncTest('reports maximum 5 console.log matches per file', async () => {
+ const testDir = createTestDir();
+ const testFile = path.join(testDir, 'many-logs.js');
+ const lines = Array(7)
+ .fill(null)
+ .map((_, i) => `console.log("debug line ${i + 1}");`);
+ fs.writeFileSync(testFile, lines.join('\n'));
- const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), stdinJson);
+ const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), stdinJson);
- assert.strictEqual(result.code, 0, 'Should exit 0');
- // Count line number reports in stderr (format: "N: console.log(...)")
- const lineReports = (result.stderr.match(/^\d+:/gm) || []).length;
- assert.strictEqual(lineReports, 5, `Should report max 5 matches, got ${lineReports}`);
- cleanupTestDir(testDir);
- })) passed++; else failed++;
+ assert.strictEqual(result.code, 0, 'Should exit 0');
+ // Count line number reports in stderr (format: "N: console.log(...)")
+ const lineReports = (result.stderr.match(/^\d+:/gm) || []).length;
+ assert.strictEqual(lineReports, 5, `Should report max 5 matches, got ${lineReports}`);
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
console.log('\nRound 53: post-edit-format.js (non-existent file):');
- if (await asyncTest('passes through data for non-existent .tsx file path', async () => {
- const stdinJson = JSON.stringify({
- tool_input: { file_path: '/nonexistent/path/file.tsx' }
- });
- const result = await runScript(path.join(scriptsDir, 'post-edit-format.js'), stdinJson);
+ if (
+ await asyncTest('passes through data for non-existent .tsx file path', async () => {
+ const stdinJson = JSON.stringify({
+ tool_input: { file_path: '/nonexistent/path/file.tsx' }
+ });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-format.js'), stdinJson);
- assert.strictEqual(result.code, 0, 'Should exit 0 for non-existent file');
- assert.strictEqual(result.stdout, stdinJson, 'Should pass through stdin data unchanged');
- })) passed++; else failed++;
+ assert.strictEqual(result.code, 0, 'Should exit 0 for non-existent file');
+ assert.strictEqual(result.stdout, stdinJson, 'Should pass through stdin data unchanged');
+ })
+ )
+ passed++;
+ else failed++;
// ── Round 55: maxAge boundary, multi-session injection, stdin overflow ──
console.log('\nRound 55: session-start.js (maxAge 7-day boundary):');
- if (await asyncTest('excludes session files older than 7 days', async () => {
- const isoHome = path.join(os.tmpdir(), `ecc-start-7day-${Date.now()}`);
- const sessionsDir = path.join(isoHome, '.claude', 'sessions');
- fs.mkdirSync(sessionsDir, { recursive: true });
- fs.mkdirSync(path.join(isoHome, '.claude', 'skills', 'learned'), { recursive: true });
-
- // Create session file 6.9 days old (should be INCLUDED by maxAge:7)
- const recentFile = path.join(sessionsDir, '2026-02-06-recent69-session.tmp');
- fs.writeFileSync(recentFile, '# Recent Session\n\nRECENT CONTENT HERE');
- const sixPointNineDaysAgo = new Date(Date.now() - 6.9 * 24 * 60 * 60 * 1000);
- fs.utimesSync(recentFile, sixPointNineDaysAgo, sixPointNineDaysAgo);
-
- // Create session file 8 days old (should be EXCLUDED by maxAge:7)
- const oldFile = path.join(sessionsDir, '2026-02-05-old8day-session.tmp');
- fs.writeFileSync(oldFile, '# Old Session\n\nOLD CONTENT SHOULD NOT APPEAR');
- const eightDaysAgo = new Date(Date.now() - 8 * 24 * 60 * 60 * 1000);
- fs.utimesSync(oldFile, eightDaysAgo, eightDaysAgo);
-
- try {
- const result = await runScript(path.join(scriptsDir, 'session-start.js'), '', {
- HOME: isoHome, USERPROFILE: isoHome
- });
- assert.strictEqual(result.code, 0);
- assert.ok(result.stderr.includes('1 recent session'),
- `Should find 1 recent session (6.9-day included, 8-day excluded), stderr: ${result.stderr}`);
- assert.ok(result.stdout.includes('RECENT CONTENT HERE'),
- 'Should inject the 6.9-day-old session content');
- assert.ok(!result.stdout.includes('OLD CONTENT SHOULD NOT APPEAR'),
- 'Should NOT inject the 8-day-old session content');
- } finally {
- fs.rmSync(isoHome, { recursive: true, force: true });
- }
- })) passed++; else failed++;
+ if (
+ await asyncTest('excludes session files older than 7 days', async () => {
+ const isoHome = path.join(os.tmpdir(), `ecc-start-7day-${Date.now()}`);
+ const sessionsDir = path.join(isoHome, '.claude', 'sessions');
+ fs.mkdirSync(sessionsDir, { recursive: true });
+ fs.mkdirSync(path.join(isoHome, '.claude', 'skills', 'learned'), { recursive: true });
+
+ // Create session file 6.9 days old (should be INCLUDED by maxAge:7)
+ const recentFile = path.join(sessionsDir, '2026-02-06-recent69-session.tmp');
+ fs.writeFileSync(recentFile, '# Recent Session\n\nRECENT CONTENT HERE');
+ const sixPointNineDaysAgo = new Date(Date.now() - 6.9 * 24 * 60 * 60 * 1000);
+ fs.utimesSync(recentFile, sixPointNineDaysAgo, sixPointNineDaysAgo);
+
+ // Create session file 8 days old (should be EXCLUDED by maxAge:7)
+ const oldFile = path.join(sessionsDir, '2026-02-05-old8day-session.tmp');
+ fs.writeFileSync(oldFile, '# Old Session\n\nOLD CONTENT SHOULD NOT APPEAR');
+ const eightDaysAgo = new Date(Date.now() - 8 * 24 * 60 * 60 * 1000);
+ fs.utimesSync(oldFile, eightDaysAgo, eightDaysAgo);
+
+ try {
+ const result = await runScript(path.join(scriptsDir, 'session-start.js'), '', {
+ HOME: isoHome,
+ USERPROFILE: isoHome
+ });
+ assert.strictEqual(result.code, 0);
+ assert.ok(result.stderr.includes('1 recent session'), `Should find 1 recent session (6.9-day included, 8-day excluded), stderr: ${result.stderr}`);
+ assert.ok(result.stdout.includes('RECENT CONTENT HERE'), 'Should inject the 6.9-day-old session content');
+ assert.ok(!result.stdout.includes('OLD CONTENT SHOULD NOT APPEAR'), 'Should NOT inject the 8-day-old session content');
+ } finally {
+ fs.rmSync(isoHome, { recursive: true, force: true });
+ }
+ })
+ )
+ passed++;
+ else failed++;
console.log('\nRound 55: session-start.js (newest session selection):');
- if (await asyncTest('injects newest session when multiple recent sessions exist', async () => {
- const isoHome = path.join(os.tmpdir(), `ecc-start-multi-${Date.now()}`);
- const sessionsDir = path.join(isoHome, '.claude', 'sessions');
- fs.mkdirSync(sessionsDir, { recursive: true });
- fs.mkdirSync(path.join(isoHome, '.claude', 'skills', 'learned'), { recursive: true });
+ if (
+ await asyncTest('injects newest session when multiple recent sessions exist', async () => {
+ const isoHome = path.join(os.tmpdir(), `ecc-start-multi-${Date.now()}`);
+ const sessionsDir = path.join(isoHome, '.claude', 'sessions');
+ fs.mkdirSync(sessionsDir, { recursive: true });
+ fs.mkdirSync(path.join(isoHome, '.claude', 'skills', 'learned'), { recursive: true });
- const now = Date.now();
+ const now = Date.now();
- // Create older session (2 days ago)
- const olderSession = path.join(sessionsDir, '2026-02-11-olderabc-session.tmp');
- fs.writeFileSync(olderSession, '# Older Session\n\nOLDER_CONTEXT_MARKER');
- fs.utimesSync(olderSession, new Date(now - 2 * 86400000), new Date(now - 2 * 86400000));
+ // Create older session (2 days ago)
+ const olderSession = path.join(sessionsDir, '2026-02-11-olderabc-session.tmp');
+ fs.writeFileSync(olderSession, '# Older Session\n\nOLDER_CONTEXT_MARKER');
+ fs.utimesSync(olderSession, new Date(now - 2 * 86400000), new Date(now - 2 * 86400000));
- // Create newer session (1 day ago)
- const newerSession = path.join(sessionsDir, '2026-02-12-newerdef-session.tmp');
- fs.writeFileSync(newerSession, '# Newer Session\n\nNEWER_CONTEXT_MARKER');
- fs.utimesSync(newerSession, new Date(now - 1 * 86400000), new Date(now - 1 * 86400000));
+ // Create newer session (1 day ago)
+ const newerSession = path.join(sessionsDir, '2026-02-12-newerdef-session.tmp');
+ fs.writeFileSync(newerSession, '# Newer Session\n\nNEWER_CONTEXT_MARKER');
+ fs.utimesSync(newerSession, new Date(now - 1 * 86400000), new Date(now - 1 * 86400000));
- try {
- const result = await runScript(path.join(scriptsDir, 'session-start.js'), '', {
- HOME: isoHome, USERPROFILE: isoHome
- });
- assert.strictEqual(result.code, 0);
- assert.ok(result.stderr.includes('2 recent session'),
- `Should find 2 recent sessions, stderr: ${result.stderr}`);
- // Should inject the NEWER session, not the older one
- assert.ok(result.stdout.includes('NEWER_CONTEXT_MARKER'),
- 'Should inject the newest session content');
- } finally {
- fs.rmSync(isoHome, { recursive: true, force: true });
- }
- })) passed++; else failed++;
+ try {
+ const result = await runScript(path.join(scriptsDir, 'session-start.js'), '', {
+ HOME: isoHome,
+ USERPROFILE: isoHome
+ });
+ assert.strictEqual(result.code, 0);
+ assert.ok(result.stderr.includes('2 recent session'), `Should find 2 recent sessions, stderr: ${result.stderr}`);
+ // Should inject the NEWER session, not the older one
+ assert.ok(result.stdout.includes('NEWER_CONTEXT_MARKER'), 'Should inject the newest session content');
+ } finally {
+ fs.rmSync(isoHome, { recursive: true, force: true });
+ }
+ })
+ )
+ passed++;
+ else failed++;
console.log('\nRound 55: session-end.js (stdin overflow):');
- if (await asyncTest('handles stdin exceeding MAX_STDIN (1MB) gracefully', async () => {
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
- // Create a minimal valid transcript so env var fallback works
- fs.writeFileSync(transcriptPath, JSON.stringify({ type: 'user', content: 'Overflow test' }) + '\n');
+ if (
+ await asyncTest('handles stdin exceeding MAX_STDIN (1MB) gracefully', async () => {
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
+ // Create a minimal valid transcript so env var fallback works
+ fs.writeFileSync(transcriptPath, JSON.stringify({ type: 'user', content: 'Overflow test' }) + '\n');
- // Create stdin > 1MB: truncated JSON will be invalid → falls back to env var
- const oversizedPayload = '{"transcript_path":"' + 'x'.repeat(1048600) + '"}';
+ // Create stdin > 1MB: truncated JSON will be invalid → falls back to env var
+ const oversizedPayload = '{"transcript_path":"' + 'x'.repeat(1048600) + '"}';
- try {
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), oversizedPayload, {
- CLAUDE_TRANSCRIPT_PATH: transcriptPath
- });
- assert.strictEqual(result.code, 0, 'Should exit 0 even with oversized stdin');
- // Truncated JSON → JSON.parse throws → falls back to env var → creates session file
- assert.ok(
- result.stderr.includes('Created session file') || result.stderr.includes('Updated session file'),
- `Should create/update session file via env var fallback, stderr: ${result.stderr}`
- );
- } finally {
- cleanupTestDir(testDir);
- }
- })) passed++; else failed++;
+ try {
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), oversizedPayload, {
+ CLAUDE_TRANSCRIPT_PATH: transcriptPath
+ });
+ assert.strictEqual(result.code, 0, 'Should exit 0 even with oversized stdin');
+ // Truncated JSON → JSON.parse throws → falls back to env var → creates session file
+ assert.ok(result.stderr.includes('Created session file') || result.stderr.includes('Updated session file'), `Should create/update session file via env var fallback, stderr: ${result.stderr}`);
+ } finally {
+ cleanupTestDir(testDir);
+ }
+ })
+ )
+ passed++;
+ else failed++;
// ── Round 56: typecheck tsconfig walk-up, suggest-compact fallback path ──
console.log('\nRound 56: post-edit-typecheck.js (tsconfig in parent directory):');
- if (await asyncTest('walks up directory tree to find tsconfig.json in grandparent', async () => {
- const testDir = createTestDir();
- // Place tsconfig at the TOP level, file is nested 2 levels deep
- fs.writeFileSync(path.join(testDir, 'tsconfig.json'), JSON.stringify({
- compilerOptions: { strict: false, noEmit: true }
- }));
- const deepDir = path.join(testDir, 'src', 'components');
- fs.mkdirSync(deepDir, { recursive: true });
- const testFile = path.join(deepDir, 'widget.ts');
- fs.writeFileSync(testFile, 'export const value: number = 42;\n');
-
- const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), stdinJson);
-
- assert.strictEqual(result.code, 0, 'Should exit 0 after walking up to find tsconfig');
- // Core assertion: stdin must pass through regardless of whether tsc ran
- const parsed = JSON.parse(result.stdout);
- assert.strictEqual(parsed.tool_input.file_path, testFile,
- 'Should pass through original stdin data with file_path intact');
- cleanupTestDir(testDir);
- })) passed++; else failed++;
+ if (
+ await asyncTest('walks up directory tree to find tsconfig.json in grandparent', async () => {
+ const testDir = createTestDir();
+ // Place tsconfig at the TOP level, file is nested 2 levels deep
+ fs.writeFileSync(
+ path.join(testDir, 'tsconfig.json'),
+ JSON.stringify({
+ compilerOptions: { strict: false, noEmit: true }
+ })
+ );
+ const deepDir = path.join(testDir, 'src', 'components');
+ fs.mkdirSync(deepDir, { recursive: true });
+ const testFile = path.join(deepDir, 'widget.ts');
+ fs.writeFileSync(testFile, 'export const value: number = 42;\n');
+
+ const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), stdinJson);
+
+ assert.strictEqual(result.code, 0, 'Should exit 0 after walking up to find tsconfig');
+ // Core assertion: stdin must pass through regardless of whether tsc ran
+ const parsed = JSON.parse(result.stdout);
+ assert.strictEqual(parsed.tool_input.file_path, testFile, 'Should pass through original stdin data with file_path intact');
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
console.log('\nRound 56: suggest-compact.js (counter file as directory — fallback path):');
- if (await asyncTest('exits 0 when counter file path is occupied by a directory', async () => {
- const sessionId = `dirblock-${Date.now()}`;
- const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
- // Create a DIRECTORY at the counter file path — openSync('a+') will fail with EISDIR
- fs.mkdirSync(counterFile);
+ if (
+ await asyncTest('exits 0 when counter file path is occupied by a directory', async () => {
+ const sessionId = `dirblock-${Date.now()}`;
+ const counterFile = path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
+ // Create a DIRECTORY at the counter file path — openSync('a+') will fail with EISDIR
+ fs.mkdirSync(counterFile);
- try {
- const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
- CLAUDE_SESSION_ID: sessionId
- });
- assert.strictEqual(result.code, 0,
- 'Should exit 0 even when counter file path is a directory (graceful fallback)');
- } finally {
- // Cleanup: remove the blocking directory
- try { fs.rmdirSync(counterFile); } catch { /* best-effort */ }
- }
- })) passed++; else failed++;
+ try {
+ const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
+ CLAUDE_SESSION_ID: sessionId
+ });
+ assert.strictEqual(result.code, 0, 'Should exit 0 even when counter file path is a directory (graceful fallback)');
+ } finally {
+ // Cleanup: remove the blocking directory
+ try {
+ fs.rmdirSync(counterFile);
+ } catch {
+ /* best-effort */
+ }
+ }
+ })
+ )
+ passed++;
+ else failed++;
// ── Round 59: session-start unreadable file, console-log stdin overflow, pre-compact write error ──
console.log('\nRound 59: session-start.js (unreadable session file — readFile returns null):');
- if (await asyncTest('does not inject content when session file is unreadable', async () => {
- // Skip on Windows or when running as root (permissions won't work)
- if (process.platform === 'win32' || (process.getuid && process.getuid() === 0)) {
- console.log(' (skipped — not supported on this platform)');
- return;
- }
- const isoHome = path.join(os.tmpdir(), `ecc-start-unreadable-${Date.now()}`);
- const sessionsDir = path.join(isoHome, '.claude', 'sessions');
- fs.mkdirSync(sessionsDir, { recursive: true });
+ if (
+ await asyncTest('does not inject content when session file is unreadable', async () => {
+ // Skip on Windows or when running as root (permissions won't work)
+ if (process.platform === 'win32' || (process.getuid && process.getuid() === 0)) {
+ console.log(' (skipped — not supported on this platform)');
+ return;
+ }
+ const isoHome = path.join(os.tmpdir(), `ecc-start-unreadable-${Date.now()}`);
+ const sessionsDir = path.join(isoHome, '.claude', 'sessions');
+ fs.mkdirSync(sessionsDir, { recursive: true });
- // Create a session file with real content, then make it unreadable
- const sessionFile = path.join(sessionsDir, `${Date.now()}-session.tmp`);
- fs.writeFileSync(sessionFile, '# Sensitive session content that should NOT appear');
- fs.chmodSync(sessionFile, 0o000);
+ // Create a session file with real content, then make it unreadable
+ const sessionFile = path.join(sessionsDir, `${Date.now()}-session.tmp`);
+ fs.writeFileSync(sessionFile, '# Sensitive session content that should NOT appear');
+ fs.chmodSync(sessionFile, 0o000);
- try {
- const result = await runScript(path.join(scriptsDir, 'session-start.js'), '', {
- HOME: isoHome, USERPROFILE: isoHome
- });
- assert.strictEqual(result.code, 0, 'Should exit 0 even with unreadable session file');
- // readFile returns null for unreadable files → content is null → no injection
- assert.ok(!result.stdout.includes('Sensitive session content'),
- 'Should NOT inject content from unreadable file');
- } finally {
- try { fs.chmodSync(sessionFile, 0o644); } catch { /* best-effort */ }
- try { fs.rmSync(isoHome, { recursive: true, force: true }); } catch { /* best-effort */ }
- }
- })) passed++; else failed++;
+ try {
+ const result = await runScript(path.join(scriptsDir, 'session-start.js'), '', {
+ HOME: isoHome,
+ USERPROFILE: isoHome
+ });
+ assert.strictEqual(result.code, 0, 'Should exit 0 even with unreadable session file');
+ // readFile returns null for unreadable files → content is null → no injection
+ assert.ok(!result.stdout.includes('Sensitive session content'), 'Should NOT inject content from unreadable file');
+ } finally {
+ try {
+ fs.chmodSync(sessionFile, 0o644);
+ } catch {
+ /* best-effort */
+ }
+ try {
+ fs.rmSync(isoHome, { recursive: true, force: true });
+ } catch {
+ /* best-effort */
+ }
+ }
+ })
+ )
+ passed++;
+ else failed++;
console.log('\nRound 59: check-console-log.js (stdin exceeding 1MB — truncation):');
- if (await asyncTest('truncates stdin at 1MB limit and still passes through data', async () => {
- // Send 1.2MB of data — exceeds the 1MB MAX_STDIN limit
- const payload = 'x'.repeat(1024 * 1024 + 200000);
- const result = await runScript(path.join(scriptsDir, 'check-console-log.js'), payload);
-
- assert.strictEqual(result.code, 0, 'Should exit 0 even with oversized stdin');
- // Output should be truncated — significantly less than input
- assert.ok(result.stdout.length < payload.length,
- `stdout (${result.stdout.length}) should be shorter than input (${payload.length})`);
- // Output should be approximately 1MB (last accepted chunk may push slightly over)
- assert.ok(result.stdout.length <= 1024 * 1024 + 65536,
- `stdout (${result.stdout.length}) should be near 1MB, not unbounded`);
- assert.ok(result.stdout.length > 0, 'Should still pass through truncated data');
- })) passed++; else failed++;
+ if (
+ await asyncTest('truncates stdin at 1MB limit and still passes through data', async () => {
+ // Send 1.2MB of data — exceeds the 1MB MAX_STDIN limit
+ const payload = 'x'.repeat(1024 * 1024 + 200000);
+ const result = await runScript(path.join(scriptsDir, 'check-console-log.js'), payload);
+
+ assert.strictEqual(result.code, 0, 'Should exit 0 even with oversized stdin');
+ // Output should be truncated — significantly less than input
+ assert.ok(result.stdout.length < payload.length, `stdout (${result.stdout.length}) should be shorter than input (${payload.length})`);
+ // Output should be approximately 1MB (last accepted chunk may push slightly over)
+ assert.ok(result.stdout.length <= 1024 * 1024 + 65536, `stdout (${result.stdout.length}) should be near 1MB, not unbounded`);
+ assert.ok(result.stdout.length > 0, 'Should still pass through truncated data');
+ })
+ )
+ passed++;
+ else failed++;
console.log('\nRound 59: pre-compact.js (read-only session file — appendFile error):');
- if (await asyncTest('exits 0 when session file is read-only (appendFile fails)', async () => {
- if (process.platform === 'win32' || (process.getuid && process.getuid() === 0)) {
- console.log(' (skipped — not supported on this platform)');
- return;
- }
- const isoHome = path.join(os.tmpdir(), `ecc-compact-ro-${Date.now()}`);
- const sessionsDir = path.join(isoHome, '.claude', 'sessions');
- fs.mkdirSync(sessionsDir, { recursive: true });
+ if (
+ await asyncTest('exits 0 when session file is read-only (appendFile fails)', async () => {
+ if (process.platform === 'win32' || (process.getuid && process.getuid() === 0)) {
+ console.log(' (skipped — not supported on this platform)');
+ return;
+ }
+ const isoHome = path.join(os.tmpdir(), `ecc-compact-ro-${Date.now()}`);
+ const sessionsDir = path.join(isoHome, '.claude', 'sessions');
+ fs.mkdirSync(sessionsDir, { recursive: true });
- // Create a session file then make it read-only
- const sessionFile = path.join(sessionsDir, `${Date.now()}-session.tmp`);
- fs.writeFileSync(sessionFile, '# Active session\n');
- fs.chmodSync(sessionFile, 0o444);
+ // Create a session file then make it read-only
+ const sessionFile = path.join(sessionsDir, `${Date.now()}-session.tmp`);
+ fs.writeFileSync(sessionFile, '# Active session\n');
+ fs.chmodSync(sessionFile, 0o444);
- try {
- const result = await runScript(path.join(scriptsDir, 'pre-compact.js'), '', {
- HOME: isoHome, USERPROFILE: isoHome
- });
- // Should exit 0 — hooks must not block the user (catch at lines 45-47)
- assert.strictEqual(result.code, 0, 'Should exit 0 even when append fails');
- // Session file should remain unchanged (write was blocked)
- const content = fs.readFileSync(sessionFile, 'utf8');
- assert.strictEqual(content, '# Active session\n',
- 'Read-only session file should remain unchanged');
- } finally {
- try { fs.chmodSync(sessionFile, 0o644); } catch { /* best-effort */ }
- try { fs.rmSync(isoHome, { recursive: true, force: true }); } catch { /* best-effort */ }
- }
- })) passed++; else failed++;
+ try {
+ const result = await runScript(path.join(scriptsDir, 'pre-compact.js'), '', {
+ HOME: isoHome,
+ USERPROFILE: isoHome
+ });
+ // Should exit 0 — hooks must not block the user (catch at lines 45-47)
+ assert.strictEqual(result.code, 0, 'Should exit 0 even when append fails');
+ // Session file should remain unchanged (write was blocked)
+ const content = fs.readFileSync(sessionFile, 'utf8');
+ assert.strictEqual(content, '# Active session\n', 'Read-only session file should remain unchanged');
+ } finally {
+ try {
+ fs.chmodSync(sessionFile, 0o644);
+ } catch {
+ /* best-effort */
+ }
+ try {
+ fs.rmSync(isoHome, { recursive: true, force: true });
+ } catch {
+ /* best-effort */
+ }
+ }
+ })
+ )
+ passed++;
+ else failed++;
// ── Round 60: replaceInFile failure, console-warn stdin overflow, format missing tool_input ──
console.log('\nRound 60: session-end.js (replaceInFile returns false — timestamp update warning):');
- if (await asyncTest('logs warning when existing session file lacks Last Updated field', async () => {
- const isoHome = path.join(os.tmpdir(), `ecc-end-nots-${Date.now()}`);
- const sessionsDir = path.join(isoHome, '.claude', 'sessions');
- fs.mkdirSync(sessionsDir, { recursive: true });
-
- // Create transcript with a user message so a summary is produced
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
- fs.writeFileSync(transcriptPath, '{"type":"user","content":"test message"}\n');
-
- // Pre-create session file WITHOUT the **Last Updated:** line
- // Use today's date and a short ID matching getSessionIdShort() pattern
- const today = new Date().toISOString().split('T')[0];
- const sessionFile = path.join(sessionsDir, `${today}-session-session.tmp`);
- fs.writeFileSync(sessionFile, '# Session file without timestamp marker\nSome existing content\n');
-
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
- HOME: isoHome, USERPROFILE: isoHome
- });
+ if (
+ await asyncTest('logs warning when existing session file lacks Last Updated field', async () => {
+ const isoHome = path.join(os.tmpdir(), `ecc-end-nots-${Date.now()}`);
+ const sessionsDir = path.join(isoHome, '.claude', 'sessions');
+ fs.mkdirSync(sessionsDir, { recursive: true });
+
+ // Create transcript with a user message so a summary is produced
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
+ fs.writeFileSync(transcriptPath, '{"type":"user","content":"test message"}\n');
+
+ // Pre-create session file WITHOUT the **Last Updated:** line
+ // Use today's date and a short ID matching getSessionIdShort() pattern
+ const today = new Date().toISOString().split('T')[0];
+ const sessionFile = path.join(sessionsDir, `${today}-session-session.tmp`);
+ fs.writeFileSync(sessionFile, '# Session file without timestamp marker\nSome existing content\n');
+
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
+ HOME: isoHome,
+ USERPROFILE: isoHome
+ });
- assert.strictEqual(result.code, 0, 'Should exit 0 even when replaceInFile fails');
- // replaceInFile returns false → line 166 logs warning about failed timestamp update
- assert.ok(result.stderr.includes('Failed to update') || result.stderr.includes('[SessionEnd]'),
- 'Should log warning when timestamp pattern not found in session file');
+ assert.strictEqual(result.code, 0, 'Should exit 0 even when replaceInFile fails');
+ // replaceInFile returns false → line 166 logs warning about failed timestamp update
+ assert.ok(result.stderr.includes('Failed to update') || result.stderr.includes('[SessionEnd]'), 'Should log warning when timestamp pattern not found in session file');
- cleanupTestDir(testDir);
- try { fs.rmSync(isoHome, { recursive: true, force: true }); } catch { /* best-effort */ }
- })) passed++; else failed++;
+ cleanupTestDir(testDir);
+ try {
+ fs.rmSync(isoHome, { recursive: true, force: true });
+ } catch {
+ /* best-effort */
+ }
+ })
+ )
+ passed++;
+ else failed++;
console.log('\nRound 60: post-edit-console-warn.js (stdin exceeding 1MB — truncation):');
- if (await asyncTest('truncates stdin at 1MB limit and still passes through data', async () => {
- // Send 1.2MB of data — exceeds the 1MB MAX_STDIN limit
- const payload = 'x'.repeat(1024 * 1024 + 200000);
- const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), payload);
-
- assert.strictEqual(result.code, 0, 'Should exit 0 even with oversized stdin');
- // Data should be truncated — stdout significantly less than input
- assert.ok(result.stdout.length < payload.length,
- `stdout (${result.stdout.length}) should be shorter than input (${payload.length})`);
- // Should be approximately 1MB (last accepted chunk may push slightly over)
- assert.ok(result.stdout.length <= 1024 * 1024 + 65536,
- `stdout (${result.stdout.length}) should be near 1MB, not unbounded`);
- assert.ok(result.stdout.length > 0, 'Should still pass through truncated data');
- })) passed++; else failed++;
+ if (
+ await asyncTest('truncates stdin at 1MB limit and still passes through data', async () => {
+ // Send 1.2MB of data — exceeds the 1MB MAX_STDIN limit
+ const payload = 'x'.repeat(1024 * 1024 + 200000);
+ const result = await runScript(path.join(scriptsDir, 'post-edit-console-warn.js'), payload);
+
+ assert.strictEqual(result.code, 0, 'Should exit 0 even with oversized stdin');
+ // Data should be truncated — stdout significantly less than input
+ assert.ok(result.stdout.length < payload.length, `stdout (${result.stdout.length}) should be shorter than input (${payload.length})`);
+ // Should be approximately 1MB (last accepted chunk may push slightly over)
+ assert.ok(result.stdout.length <= 1024 * 1024 + 65536, `stdout (${result.stdout.length}) should be near 1MB, not unbounded`);
+ assert.ok(result.stdout.length > 0, 'Should still pass through truncated data');
+ })
+ )
+ passed++;
+ else failed++;
console.log('\nRound 60: post-edit-format.js (valid JSON without tool_input key):');
- if (await asyncTest('skips formatting when JSON has no tool_input field', async () => {
- const stdinJson = JSON.stringify({ result: 'ok', output: 'some data' });
- const result = await runScript(path.join(scriptsDir, 'post-edit-format.js'), stdinJson);
+ if (
+ await asyncTest('skips formatting when JSON has no tool_input field', async () => {
+ const stdinJson = JSON.stringify({ result: 'ok', output: 'some data' });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-format.js'), stdinJson);
- assert.strictEqual(result.code, 0, 'Should exit 0 for JSON without tool_input');
- // input.tool_input?.file_path is undefined → skips formatting → passes through
- assert.strictEqual(result.stdout, stdinJson,
- 'Should pass through data unchanged when tool_input is absent');
- })) passed++; else failed++;
+ assert.strictEqual(result.code, 0, 'Should exit 0 for JSON without tool_input');
+ // input.tool_input?.file_path is undefined → skips formatting → passes through
+ assert.strictEqual(result.stdout, stdinJson, 'Should pass through data unchanged when tool_input is absent');
+ })
+ )
+ passed++;
+ else failed++;
// ── Round 64: post-edit-typecheck.js valid JSON without tool_input ──
console.log('\nRound 64: post-edit-typecheck.js (valid JSON without tool_input):');
- if (await asyncTest('skips typecheck when JSON has no tool_input field', async () => {
- const stdinJson = JSON.stringify({ result: 'ok', metadata: { action: 'test' } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), stdinJson);
+ if (
+ await asyncTest('skips typecheck when JSON has no tool_input field', async () => {
+ const stdinJson = JSON.stringify({ result: 'ok', metadata: { action: 'test' } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), stdinJson);
- assert.strictEqual(result.code, 0, 'Should exit 0 for JSON without tool_input');
- // input.tool_input?.file_path is undefined → skips TS check → passes through
- assert.strictEqual(result.stdout, stdinJson,
- 'Should pass through data unchanged when tool_input is absent');
- })) passed++; else failed++;
+ assert.strictEqual(result.code, 0, 'Should exit 0 for JSON without tool_input');
+ // input.tool_input?.file_path is undefined → skips TS check → passes through
+ assert.strictEqual(result.stdout, stdinJson, 'Should pass through data unchanged when tool_input is absent');
+ })
+ )
+ passed++;
+ else failed++;
// ── Round 66: session-end.js entry.role === 'user' fallback and nonexistent transcript ──
console.log('\nRound 66: session-end.js (entry.role user fallback):');
- if (await asyncTest('extracts user messages from role-only format (no type field)', async () => {
- const isoHome = path.join(os.tmpdir(), `ecc-role-only-${Date.now()}`);
- const sessionsDir = path.join(isoHome, '.claude', 'sessions');
- fs.mkdirSync(sessionsDir, { recursive: true });
-
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
- // Use entries with ONLY role field (no type:"user") to exercise the fallback
- const lines = [
- '{"role":"user","content":"Deploy the production build"}',
- '{"role":"assistant","content":"I will deploy now"}',
- '{"role":"user","content":"Check the logs after deploy"}',
- ];
- fs.writeFileSync(transcriptPath, lines.join('\n'));
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
-
- try {
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
- HOME: isoHome, USERPROFILE: isoHome
- });
- assert.strictEqual(result.code, 0);
+ if (
+ await asyncTest('extracts user messages from role-only format (no type field)', async () => {
+ const isoHome = path.join(os.tmpdir(), `ecc-role-only-${Date.now()}`);
+ const sessionsDir = path.join(isoHome, '.claude', 'sessions');
+ fs.mkdirSync(sessionsDir, { recursive: true });
- const files = fs.readdirSync(sessionsDir).filter(f => f.endsWith('-session.tmp'));
- assert.ok(files.length > 0, 'Should create session file');
- const content = fs.readFileSync(path.join(sessionsDir, files[0]), 'utf8');
- // The role-only user messages should be extracted
- assert.ok(content.includes('Deploy the production build') || content.includes('deploy'),
- `Session file should include role-only user messages. Got: ${content.substring(0, 300)}`);
- } finally {
- fs.rmSync(isoHome, { recursive: true, force: true });
- cleanupTestDir(testDir);
- }
- })) passed++; else failed++;
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
+ // Use entries with ONLY role field (no type:"user") to exercise the fallback
+ const lines = ['{"role":"user","content":"Deploy the production build"}', '{"role":"assistant","content":"I will deploy now"}', '{"role":"user","content":"Check the logs after deploy"}'];
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+
+ try {
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
+ HOME: isoHome,
+ USERPROFILE: isoHome
+ });
+ assert.strictEqual(result.code, 0);
+
+ const files = fs.readdirSync(sessionsDir).filter(f => f.endsWith('-session.tmp'));
+ assert.ok(files.length > 0, 'Should create session file');
+ const content = fs.readFileSync(path.join(sessionsDir, files[0]), 'utf8');
+ // The role-only user messages should be extracted
+ assert.ok(content.includes('Deploy the production build') || content.includes('deploy'), `Session file should include role-only user messages. Got: ${content.substring(0, 300)}`);
+ } finally {
+ fs.rmSync(isoHome, { recursive: true, force: true });
+ cleanupTestDir(testDir);
+ }
+ })
+ )
+ passed++;
+ else failed++;
console.log('\nRound 66: session-end.js (nonexistent transcript path):');
- if (await asyncTest('logs "Transcript not found" for nonexistent transcript_path', async () => {
- const isoHome = path.join(os.tmpdir(), `ecc-notfound-${Date.now()}`);
- const sessionsDir = path.join(isoHome, '.claude', 'sessions');
- fs.mkdirSync(sessionsDir, { recursive: true });
+ if (
+ await asyncTest('logs "Transcript not found" for nonexistent transcript_path', async () => {
+ const isoHome = path.join(os.tmpdir(), `ecc-notfound-${Date.now()}`);
+ const sessionsDir = path.join(isoHome, '.claude', 'sessions');
+ fs.mkdirSync(sessionsDir, { recursive: true });
- const stdinJson = JSON.stringify({ transcript_path: '/tmp/nonexistent-transcript-99999.jsonl' });
+ const stdinJson = JSON.stringify({ transcript_path: '/tmp/nonexistent-transcript-99999.jsonl' });
- try {
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
- HOME: isoHome, USERPROFILE: isoHome
- });
- assert.strictEqual(result.code, 0, 'Should exit 0 for missing transcript');
- assert.ok(
- result.stderr.includes('Transcript not found') || result.stderr.includes('not found'),
- `Should log transcript not found. Got stderr: ${result.stderr.substring(0, 300)}`
- );
- // Should still create a session file (with blank template, since summary is null)
- const files = fs.readdirSync(sessionsDir).filter(f => f.endsWith('-session.tmp'));
- assert.ok(files.length > 0, 'Should still create session file even without transcript');
- } finally {
- fs.rmSync(isoHome, { recursive: true, force: true });
- }
- })) passed++; else failed++;
+ try {
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
+ HOME: isoHome,
+ USERPROFILE: isoHome
+ });
+ assert.strictEqual(result.code, 0, 'Should exit 0 for missing transcript');
+ assert.ok(result.stderr.includes('Transcript not found') || result.stderr.includes('not found'), `Should log transcript not found. Got stderr: ${result.stderr.substring(0, 300)}`);
+ // Should still create a session file (with blank template, since summary is null)
+ const files = fs.readdirSync(sessionsDir).filter(f => f.endsWith('-session.tmp'));
+ assert.ok(files.length > 0, 'Should still create session file even without transcript');
+ } finally {
+ fs.rmSync(isoHome, { recursive: true, force: true });
+ }
+ })
+ )
+ passed++;
+ else failed++;
// ── Round 70: session-end.js entry.name / entry.input fallback in direct tool_use entries ──
console.log('\nRound 70: session-end.js (entry.name/entry.input fallback):');
- if (await asyncTest('extracts tool name and file path from entry.name/entry.input (not tool_name/tool_input)', async () => {
- const isoHome = path.join(os.tmpdir(), `ecc-r70-entryname-${Date.now()}`);
- const sessionsDir = path.join(isoHome, '.claude', 'sessions');
- fs.mkdirSync(sessionsDir, { recursive: true });
- const transcriptPath = path.join(isoHome, 'transcript.jsonl');
-
- // Use "name" and "input" fields instead of "tool_name" and "tool_input"
- // This exercises the fallback at session-end.js lines 63 and 66:
- // const toolName = entry.tool_name || entry.name || '';
- // const filePath = entry.tool_input?.file_path || entry.input?.file_path || '';
- const lines = [
- '{"type":"user","content":"Use the alt format fields"}',
- '{"type":"tool_use","name":"Edit","input":{"file_path":"/src/alt-format.ts"}}',
- '{"type":"tool_use","name":"Read","input":{"file_path":"/src/other.ts"}}',
- '{"type":"tool_use","name":"Write","input":{"file_path":"/src/written.ts"}}',
- ];
- fs.writeFileSync(transcriptPath, lines.join('\n'));
-
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- try {
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
- HOME: isoHome, USERPROFILE: isoHome
- });
- assert.strictEqual(result.code, 0, 'Should exit 0');
-
- const files = fs.readdirSync(sessionsDir).filter(f => f.endsWith('.tmp'));
- assert.ok(files.length > 0, 'Should create session file');
- const content = fs.readFileSync(path.join(sessionsDir, files[0]), 'utf8');
- // Tools extracted via entry.name fallback
- assert.ok(content.includes('Edit'), 'Should list Edit via entry.name fallback');
- assert.ok(content.includes('Read'), 'Should list Read via entry.name fallback');
- // Files modified via entry.input fallback (Edit and Write, not Read)
- assert.ok(content.includes('/src/alt-format.ts'), 'Should list edited file via entry.input fallback');
- assert.ok(content.includes('/src/written.ts'), 'Should list written file via entry.input fallback');
- } finally {
- fs.rmSync(isoHome, { recursive: true, force: true });
- }
- })) passed++; else failed++;
+ if (
+ await asyncTest('extracts tool name and file path from entry.name/entry.input (not tool_name/tool_input)', async () => {
+ const isoHome = path.join(os.tmpdir(), `ecc-r70-entryname-${Date.now()}`);
+ const sessionsDir = path.join(isoHome, '.claude', 'sessions');
+ fs.mkdirSync(sessionsDir, { recursive: true });
+ const transcriptPath = path.join(isoHome, 'transcript.jsonl');
+
+ // Use "name" and "input" fields instead of "tool_name" and "tool_input"
+ // This exercises the fallback at session-end.js lines 63 and 66:
+ // const toolName = entry.tool_name || entry.name || '';
+ // const filePath = entry.tool_input?.file_path || entry.input?.file_path || '';
+ const lines = [
+ '{"type":"user","content":"Use the alt format fields"}',
+ '{"type":"tool_use","name":"Edit","input":{"file_path":"/src/alt-format.ts"}}',
+ '{"type":"tool_use","name":"Read","input":{"file_path":"/src/other.ts"}}',
+ '{"type":"tool_use","name":"Write","input":{"file_path":"/src/written.ts"}}'
+ ];
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
+
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ try {
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
+ HOME: isoHome,
+ USERPROFILE: isoHome
+ });
+ assert.strictEqual(result.code, 0, 'Should exit 0');
+
+ const files = fs.readdirSync(sessionsDir).filter(f => f.endsWith('.tmp'));
+ assert.ok(files.length > 0, 'Should create session file');
+ const content = fs.readFileSync(path.join(sessionsDir, files[0]), 'utf8');
+ // Tools extracted via entry.name fallback
+ assert.ok(content.includes('Edit'), 'Should list Edit via entry.name fallback');
+ assert.ok(content.includes('Read'), 'Should list Read via entry.name fallback');
+ // Files modified via entry.input fallback (Edit and Write, not Read)
+ assert.ok(content.includes('/src/alt-format.ts'), 'Should list edited file via entry.input fallback');
+ assert.ok(content.includes('/src/written.ts'), 'Should list written file via entry.input fallback');
+ } finally {
+ fs.rmSync(isoHome, { recursive: true, force: true });
+ }
+ })
+ )
+ passed++;
+ else failed++;
// ── Round 71: session-start.js default source shows getSelectionPrompt ──
console.log('\nRound 71: session-start.js (default source — selection prompt):');
- if (await asyncTest('shows selection prompt when no package manager preference found (default source)', async () => {
- const isoHome = path.join(os.tmpdir(), `ecc-r71-ss-default-${Date.now()}`);
- const isoProject = path.join(isoHome, 'project');
- fs.mkdirSync(path.join(isoHome, '.claude', 'sessions'), { recursive: true });
- fs.mkdirSync(path.join(isoHome, '.claude', 'skills', 'learned'), { recursive: true });
- fs.mkdirSync(isoProject, { recursive: true });
- // No package.json, no lock files, no package-manager.json — forces default source
-
- try {
- const result = await new Promise((resolve, reject) => {
- const env = { ...process.env, HOME: isoHome, USERPROFILE: isoHome };
- delete env.CLAUDE_PACKAGE_MANAGER; // Remove any env-level PM override
- const proc = spawn('node', [path.join(scriptsDir, 'session-start.js')], {
- env,
- cwd: isoProject, // CWD with no package.json or lock files
- stdio: ['pipe', 'pipe', 'pipe']
+ if (
+ await asyncTest('shows selection prompt when no package manager preference found (default source)', async () => {
+ const isoHome = path.join(os.tmpdir(), `ecc-r71-ss-default-${Date.now()}`);
+ const isoProject = path.join(isoHome, 'project');
+ fs.mkdirSync(path.join(isoHome, '.claude', 'sessions'), { recursive: true });
+ fs.mkdirSync(path.join(isoHome, '.claude', 'skills', 'learned'), { recursive: true });
+ fs.mkdirSync(isoProject, { recursive: true });
+ // No package.json, no lock files, no package-manager.json — forces default source
+
+ try {
+ const result = await new Promise((resolve, reject) => {
+ const env = { ...process.env, HOME: isoHome, USERPROFILE: isoHome };
+ delete env.CLAUDE_PACKAGE_MANAGER; // Remove any env-level PM override
+ const proc = spawn('node', [path.join(scriptsDir, 'session-start.js')], {
+ env,
+ cwd: isoProject, // CWD with no package.json or lock files
+ stdio: ['pipe', 'pipe', 'pipe']
+ });
+ let stdout = '';
+ let stderr = '';
+ proc.stdout.on('data', data => (stdout += data));
+ proc.stderr.on('data', data => (stderr += data));
+ proc.stdin.end();
+ proc.on('close', code => resolve({ code, stdout, stderr }));
+ proc.on('error', reject);
});
- let stdout = '';
- let stderr = '';
- proc.stdout.on('data', data => stdout += data);
- proc.stderr.on('data', data => stderr += data);
- proc.stdin.end();
- proc.on('close', code => resolve({ code, stdout, stderr }));
- proc.on('error', reject);
- });
- assert.strictEqual(result.code, 0, 'Should exit 0');
- assert.ok(result.stderr.includes('No package manager preference'),
- `Should show selection prompt when source is default. Got stderr: ${result.stderr.slice(0, 500)}`);
- } finally {
- fs.rmSync(isoHome, { recursive: true, force: true });
- }
- })) passed++; else failed++;
+ assert.strictEqual(result.code, 0, 'Should exit 0');
+ assert.ok(result.stderr.includes('No package manager preference'), `Should show selection prompt when source is default. Got stderr: ${result.stderr.slice(0, 500)}`);
+ } finally {
+ fs.rmSync(isoHome, { recursive: true, force: true });
+ }
+ })
+ )
+ passed++;
+ else failed++;
// ── Round 74: session-start.js main().catch handler ──
console.log('\nRound 74: session-start.js (main catch — unrecoverable error):');
- if (await asyncTest('session-start exits 0 with error message when HOME is non-directory', async () => {
- if (process.platform === 'win32') {
- console.log(' (skipped — /dev/null not available on Windows)');
- return;
- }
- // HOME=/dev/null makes ensureDir(sessionsDir) throw ENOTDIR,
- // which propagates to main().catch — the top-level error boundary
- const result = await runScript(path.join(scriptsDir, 'session-start.js'), '', {
- HOME: '/dev/null',
- USERPROFILE: '/dev/null'
- });
- assert.strictEqual(result.code, 0,
- `Should exit 0 (don't block on errors), got ${result.code}`);
- assert.ok(result.stderr.includes('[SessionStart] Error:'),
- `stderr should contain [SessionStart] Error:, got: ${result.stderr}`);
- })) passed++; else failed++;
+ if (
+ await asyncTest('session-start exits 0 with error message when HOME is non-directory', async () => {
+ if (process.platform === 'win32') {
+ console.log(' (skipped — /dev/null not available on Windows)');
+ return;
+ }
+ // HOME=/dev/null makes ensureDir(sessionsDir) throw ENOTDIR,
+ // which propagates to main().catch — the top-level error boundary
+ const result = await runScript(path.join(scriptsDir, 'session-start.js'), '', {
+ HOME: '/dev/null',
+ USERPROFILE: '/dev/null'
+ });
+ assert.strictEqual(result.code, 0, `Should exit 0 (don't block on errors), got ${result.code}`);
+ assert.ok(result.stderr.includes('[SessionStart] Error:'), `stderr should contain [SessionStart] Error:, got: ${result.stderr}`);
+ })
+ )
+ passed++;
+ else failed++;
// ── Round 75: pre-compact.js main().catch handler ──
console.log('\nRound 75: pre-compact.js (main catch — unrecoverable error):');
- if (await asyncTest('pre-compact exits 0 with error message when HOME is non-directory', async () => {
- if (process.platform === 'win32') {
- console.log(' (skipped — /dev/null not available on Windows)');
- return;
- }
- // HOME=/dev/null makes ensureDir(sessionsDir) throw ENOTDIR,
- // which propagates to main().catch — the top-level error boundary
- const result = await runScript(path.join(scriptsDir, 'pre-compact.js'), '', {
- HOME: '/dev/null',
- USERPROFILE: '/dev/null'
- });
- assert.strictEqual(result.code, 0,
- `Should exit 0 (don't block on errors), got ${result.code}`);
- assert.ok(result.stderr.includes('[PreCompact] Error:'),
- `stderr should contain [PreCompact] Error:, got: ${result.stderr}`);
- })) passed++; else failed++;
+ if (
+ await asyncTest('pre-compact exits 0 with error message when HOME is non-directory', async () => {
+ if (process.platform === 'win32') {
+ console.log(' (skipped — /dev/null not available on Windows)');
+ return;
+ }
+ // HOME=/dev/null makes ensureDir(sessionsDir) throw ENOTDIR,
+ // which propagates to main().catch — the top-level error boundary
+ const result = await runScript(path.join(scriptsDir, 'pre-compact.js'), '', {
+ HOME: '/dev/null',
+ USERPROFILE: '/dev/null'
+ });
+ assert.strictEqual(result.code, 0, `Should exit 0 (don't block on errors), got ${result.code}`);
+ assert.ok(result.stderr.includes('[PreCompact] Error:'), `stderr should contain [PreCompact] Error:, got: ${result.stderr}`);
+ })
+ )
+ passed++;
+ else failed++;
// ── Round 75: session-end.js main().catch handler ──
console.log('\nRound 75: session-end.js (main catch — unrecoverable error):');
- if (await asyncTest('session-end exits 0 with error message when HOME is non-directory', async () => {
- if (process.platform === 'win32') {
- console.log(' (skipped — /dev/null not available on Windows)');
- return;
- }
- // HOME=/dev/null makes ensureDir(sessionsDir) throw ENOTDIR inside main(),
- // which propagates to runMain().catch — the top-level error boundary
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), '{}', {
- HOME: '/dev/null',
- USERPROFILE: '/dev/null'
- });
- assert.strictEqual(result.code, 0,
- `Should exit 0 (don't block on errors), got ${result.code}`);
- assert.ok(result.stderr.includes('[SessionEnd] Error:'),
- `stderr should contain [SessionEnd] Error:, got: ${result.stderr}`);
- })) passed++; else failed++;
+ if (
+ await asyncTest('session-end exits 0 with error message when HOME is non-directory', async () => {
+ if (process.platform === 'win32') {
+ console.log(' (skipped — /dev/null not available on Windows)');
+ return;
+ }
+ // HOME=/dev/null makes ensureDir(sessionsDir) throw ENOTDIR inside main(),
+ // which propagates to runMain().catch — the top-level error boundary
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), '{}', {
+ HOME: '/dev/null',
+ USERPROFILE: '/dev/null'
+ });
+ assert.strictEqual(result.code, 0, `Should exit 0 (don't block on errors), got ${result.code}`);
+ assert.ok(result.stderr.includes('[SessionEnd] Error:'), `stderr should contain [SessionEnd] Error:, got: ${result.stderr}`);
+ })
+ )
+ passed++;
+ else failed++;
// ── Round 76: evaluate-session.js main().catch handler ──
console.log('\nRound 76: evaluate-session.js (main catch — unrecoverable error):');
- if (await asyncTest('evaluate-session exits 0 with error message when HOME is non-directory', async () => {
- if (process.platform === 'win32') {
- console.log(' (skipped — /dev/null not available on Windows)');
- return;
- }
- // HOME=/dev/null makes ensureDir(learnedSkillsPath) throw ENOTDIR,
- // which propagates to main().catch — the top-level error boundary
- const result = await runScript(path.join(scriptsDir, 'evaluate-session.js'), '{}', {
- HOME: '/dev/null',
- USERPROFILE: '/dev/null'
- });
- assert.strictEqual(result.code, 0,
- `Should exit 0 (don't block on errors), got ${result.code}`);
- assert.ok(result.stderr.includes('[ContinuousLearning] Error:'),
- `stderr should contain [ContinuousLearning] Error:, got: ${result.stderr}`);
- })) passed++; else failed++;
+ if (
+ await asyncTest('evaluate-session exits 0 with error message when HOME is non-directory', async () => {
+ if (process.platform === 'win32') {
+ console.log(' (skipped — /dev/null not available on Windows)');
+ return;
+ }
+ // HOME=/dev/null makes ensureDir(learnedSkillsPath) throw ENOTDIR,
+ // which propagates to main().catch — the top-level error boundary
+ const result = await runScript(path.join(scriptsDir, 'evaluate-session.js'), '{}', {
+ HOME: '/dev/null',
+ USERPROFILE: '/dev/null'
+ });
+ assert.strictEqual(result.code, 0, `Should exit 0 (don't block on errors), got ${result.code}`);
+ assert.ok(result.stderr.includes('[ContinuousLearning] Error:'), `stderr should contain [ContinuousLearning] Error:, got: ${result.stderr}`);
+ })
+ )
+ passed++;
+ else failed++;
// ── Round 76: suggest-compact.js main().catch handler ──
console.log('\nRound 76: suggest-compact.js (main catch — double-failure):');
- if (await asyncTest('suggest-compact exits 0 with error when TMPDIR is non-directory', async () => {
- if (process.platform === 'win32') {
- console.log(' (skipped — /dev/null not available on Windows)');
- return;
- }
- // TMPDIR=/dev/null causes openSync to fail (ENOTDIR), then the catch
- // fallback writeFile also fails, propagating to main().catch
- const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
- TMPDIR: '/dev/null'
- });
- assert.strictEqual(result.code, 0,
- `Should exit 0 (don't block on errors), got ${result.code}`);
- assert.ok(result.stderr.includes('[StrategicCompact] Error:'),
- `stderr should contain [StrategicCompact] Error:, got: ${result.stderr}`);
- })) passed++; else failed++;
+ if (
+ await asyncTest('suggest-compact exits 0 with error when TMPDIR is non-directory', async () => {
+ if (process.platform === 'win32') {
+ console.log(' (skipped — /dev/null not available on Windows)');
+ return;
+ }
+ // TMPDIR=/dev/null causes openSync to fail (ENOTDIR), then the catch
+ // fallback writeFile also fails, propagating to main().catch
+ const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
+ TMPDIR: '/dev/null'
+ });
+ assert.strictEqual(result.code, 0, `Should exit 0 (don't block on errors), got ${result.code}`);
+ assert.ok(result.stderr.includes('[StrategicCompact] Error:'), `stderr should contain [StrategicCompact] Error:, got: ${result.stderr}`);
+ })
+ )
+ passed++;
+ else failed++;
// ── Round 80: session-end.js entry.message?.role === 'user' third OR condition ──
console.log('\nRound 80: session-end.js (entry.message.role user — third OR condition):');
- if (await asyncTest('extracts user messages from entries where only message.role is user (not type or role)', async () => {
- const isoHome = path.join(os.tmpdir(), `ecc-msgrole-${Date.now()}`);
- const sessionsDir = path.join(isoHome, '.claude', 'sessions');
- fs.mkdirSync(sessionsDir, { recursive: true });
-
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
- // Entries where type is NOT 'user' and there is no direct role field,
- // but message.role IS 'user'. This exercises the third OR condition at
- // session-end.js line 48: entry.message?.role === 'user'
- const lines = [
- '{"type":"human","message":{"role":"user","content":"Refactor the auth module"}}',
- '{"type":"human","message":{"role":"assistant","content":"I will refactor it"}}',
- '{"type":"human","message":{"role":"user","content":"Add integration tests too"}}',
- ];
- fs.writeFileSync(transcriptPath, lines.join('\n'));
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
-
- try {
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
- HOME: isoHome, USERPROFILE: isoHome
- });
- assert.strictEqual(result.code, 0);
+ if (
+ await asyncTest('extracts user messages from entries where only message.role is user (not type or role)', async () => {
+ const isoHome = path.join(os.tmpdir(), `ecc-msgrole-${Date.now()}`);
+ const sessionsDir = path.join(isoHome, '.claude', 'sessions');
+ fs.mkdirSync(sessionsDir, { recursive: true });
+
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
+ // Entries where type is NOT 'user' and there is no direct role field,
+ // but message.role IS 'user'. This exercises the third OR condition at
+ // session-end.js line 48: entry.message?.role === 'user'
+ const lines = [
+ '{"type":"human","message":{"role":"user","content":"Refactor the auth module"}}',
+ '{"type":"human","message":{"role":"assistant","content":"I will refactor it"}}',
+ '{"type":"human","message":{"role":"user","content":"Add integration tests too"}}'
+ ];
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const files = fs.readdirSync(sessionsDir).filter(f => f.endsWith('-session.tmp'));
- assert.ok(files.length > 0, 'Should create session file');
- const content = fs.readFileSync(path.join(sessionsDir, files[0]), 'utf8');
- // The third OR condition should fire for type:"human" + message.role:"user"
- assert.ok(content.includes('Refactor the auth module') || content.includes('auth'),
- `Session should include message extracted via message.role path. Got: ${content.substring(0, 300)}`);
- } finally {
- fs.rmSync(isoHome, { recursive: true, force: true });
- cleanupTestDir(testDir);
- }
- })) passed++; else failed++;
+ try {
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
+ HOME: isoHome,
+ USERPROFILE: isoHome
+ });
+ assert.strictEqual(result.code, 0);
+
+ const files = fs.readdirSync(sessionsDir).filter(f => f.endsWith('-session.tmp'));
+ assert.ok(files.length > 0, 'Should create session file');
+ const content = fs.readFileSync(path.join(sessionsDir, files[0]), 'utf8');
+ // The third OR condition should fire for type:"human" + message.role:"user"
+ assert.ok(content.includes('Refactor the auth module') || content.includes('auth'), `Session should include message extracted via message.role path. Got: ${content.substring(0, 300)}`);
+ } finally {
+ fs.rmSync(isoHome, { recursive: true, force: true });
+ cleanupTestDir(testDir);
+ }
+ })
+ )
+ passed++;
+ else failed++;
// ── Round 81: suggest-compact threshold upper bound, session-end non-string content ──
console.log('\nRound 81: suggest-compact.js (COMPACT_THRESHOLD > 10000):');
- if (await asyncTest('COMPACT_THRESHOLD exceeding 10000 falls back to default 50', async () => {
- // suggest-compact.js line 31: rawThreshold <= 10000 ? rawThreshold : 50
- // Values > 10000 are positive and finite but fail the upper-bound check.
- // Existing tests cover 0, negative, NaN — this covers the > 10000 boundary.
- const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
- COMPACT_THRESHOLD: '20000'
- });
- assert.strictEqual(result.code, 0, 'Should exit 0');
- // The script logs the threshold it chose — should fall back to 50
- // Look for the fallback value in stderr (log output)
- const compactSource = fs.readFileSync(path.join(scriptsDir, 'suggest-compact.js'), 'utf8');
- // The condition at line 31: rawThreshold <= 10000 ? rawThreshold : 50
- assert.ok(compactSource.includes('<= 10000'),
- 'Source should have <= 10000 upper bound check');
- assert.ok(compactSource.includes(': 50'),
- 'Source should fall back to 50 when threshold exceeds 10000');
- })) passed++; else failed++;
-
- console.log('\nRound 81: session-end.js (user entry with non-string non-array content):');
-
- if (await asyncTest('skips user messages with numeric content (non-string non-array branch)', async () => {
- // session-end.js line 50-55: rawContent is checked for string, then array, else ''
- // When content is a number (42), neither branch matches, text = '', message is skipped.
- const isoHome = path.join(os.tmpdir(), `ecc-r81-numcontent-${Date.now()}`);
- const sessionsDir = path.join(isoHome, '.claude', 'sessions');
- fs.mkdirSync(sessionsDir, { recursive: true });
- const transcriptPath = path.join(isoHome, 'transcript.jsonl');
-
- const lines = [
- // Normal user message (string content) — should be included
- '{"type":"user","content":"Real user message"}',
- // User message with numeric content — exercises the else: '' branch
- '{"type":"user","content":42}',
- // User message with boolean content — also hits the else branch
- '{"type":"user","content":true}',
- // User message with object content (no .text) — also hits the else branch
- '{"type":"user","content":{"type":"image","source":"data:..."}}',
- ];
- fs.writeFileSync(transcriptPath, lines.join('\n'));
-
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- try {
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
- HOME: isoHome, USERPROFILE: isoHome
+ if (
+ await asyncTest('COMPACT_THRESHOLD exceeding 10000 falls back to default 50', async () => {
+ // suggest-compact.js line 31: rawThreshold <= 10000 ? rawThreshold : 50
+ // Values > 10000 are positive and finite but fail the upper-bound check.
+ // Existing tests cover 0, negative, NaN — this covers the > 10000 boundary.
+ const result = await runScript(path.join(scriptsDir, 'suggest-compact.js'), '', {
+ COMPACT_THRESHOLD: '20000'
});
assert.strictEqual(result.code, 0, 'Should exit 0');
+ // The script logs the threshold it chose — should fall back to 50
+ // Look for the fallback value in stderr (log output)
+ const compactSource = fs.readFileSync(path.join(scriptsDir, 'suggest-compact.js'), 'utf8');
+ // The condition at line 31: rawThreshold <= 10000 ? rawThreshold : 50
+ assert.ok(compactSource.includes('<= 10000'), 'Source should have <= 10000 upper bound check');
+ assert.ok(compactSource.includes(': 50'), 'Source should fall back to 50 when threshold exceeds 10000');
+ })
+ )
+ passed++;
+ else failed++;
- const files = fs.readdirSync(sessionsDir).filter(f => f.endsWith('.tmp'));
- assert.ok(files.length > 0, 'Should create session file');
- const content = fs.readFileSync(path.join(sessionsDir, files[0]), 'utf8');
- // The real string message should appear
- assert.ok(content.includes('Real user message'),
- 'Should include the string content user message');
- // Numeric/boolean/object content should NOT appear as text
- assert.ok(!content.includes('42'),
- 'Numeric content should be skipped (else branch → empty string → filtered)');
- } finally {
- fs.rmSync(isoHome, { recursive: true, force: true });
- }
- })) passed++; else failed++;
+ console.log('\nRound 81: session-end.js (user entry with non-string non-array content):');
+
+ if (
+ await asyncTest('skips user messages with numeric content (non-string non-array branch)', async () => {
+ // session-end.js line 50-55: rawContent is checked for string, then array, else ''
+ // When content is a number (42), neither branch matches, text = '', message is skipped.
+ const isoHome = path.join(os.tmpdir(), `ecc-r81-numcontent-${Date.now()}`);
+ const sessionsDir = path.join(isoHome, '.claude', 'sessions');
+ fs.mkdirSync(sessionsDir, { recursive: true });
+ const transcriptPath = path.join(isoHome, 'transcript.jsonl');
+
+ const lines = [
+ // Normal user message (string content) — should be included
+ '{"type":"user","content":"Real user message"}',
+ // User message with numeric content — exercises the else: '' branch
+ '{"type":"user","content":42}',
+ // User message with boolean content — also hits the else branch
+ '{"type":"user","content":true}',
+ // User message with object content (no .text) — also hits the else branch
+ '{"type":"user","content":{"type":"image","source":"data:..."}}'
+ ];
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
+
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ try {
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
+ HOME: isoHome,
+ USERPROFILE: isoHome
+ });
+ assert.strictEqual(result.code, 0, 'Should exit 0');
+
+ const files = fs.readdirSync(sessionsDir).filter(f => f.endsWith('.tmp'));
+ assert.ok(files.length > 0, 'Should create session file');
+ const content = fs.readFileSync(path.join(sessionsDir, files[0]), 'utf8');
+ // The real string message should appear
+ assert.ok(content.includes('Real user message'), 'Should include the string content user message');
+ // Numeric/boolean/object content should NOT appear as text
+ assert.ok(!content.includes('42'), 'Numeric content should be skipped (else branch → empty string → filtered)');
+ } finally {
+ fs.rmSync(isoHome, { recursive: true, force: true });
+ }
+ })
+ )
+ passed++;
+ else failed++;
// ── Round 82: tool_name OR fallback, template marker regex no-match ──
console.log('\nRound 82: session-end.js (entry.tool_name without type=tool_use):');
- if (await asyncTest('collects tool name from entry with tool_name but non-tool_use type', async () => {
- const isoHome = path.join(os.tmpdir(), `ecc-r82-toolname-${Date.now()}`);
- const sessionsDir = path.join(isoHome, '.claude', 'sessions');
- fs.mkdirSync(sessionsDir, { recursive: true });
-
- const transcriptPath = path.join(isoHome, 'transcript.jsonl');
- const lines = [
- '{"type":"user","content":"Fix the bug"}',
- '{"type":"result","tool_name":"Edit","tool_input":{"file_path":"/tmp/app.js"}}',
- '{"type":"assistant","message":{"content":[{"type":"text","text":"Done fixing"}]}}',
- ];
- fs.writeFileSync(transcriptPath, lines.join('\n'));
-
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- try {
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
- HOME: isoHome, USERPROFILE: isoHome
- });
- assert.strictEqual(result.code, 0, 'Should exit 0');
- const files = fs.readdirSync(sessionsDir).filter(f => f.endsWith('.tmp'));
- assert.ok(files.length > 0, 'Should create session file');
- const content = fs.readFileSync(path.join(sessionsDir, files[0]), 'utf8');
- // The tool name "Edit" should appear even though type is "result", not "tool_use"
- assert.ok(content.includes('Edit'), 'Should collect Edit tool via tool_name OR fallback');
- // The file modified should also be collected since tool_name is Edit
- assert.ok(content.includes('app.js'), 'Should collect modified file path from tool_input');
- } finally {
- fs.rmSync(isoHome, { recursive: true, force: true });
- }
- })) passed++; else failed++;
+ if (
+ await asyncTest('collects tool name from entry with tool_name but non-tool_use type', async () => {
+ const isoHome = path.join(os.tmpdir(), `ecc-r82-toolname-${Date.now()}`);
+ const sessionsDir = path.join(isoHome, '.claude', 'sessions');
+ fs.mkdirSync(sessionsDir, { recursive: true });
+
+ const transcriptPath = path.join(isoHome, 'transcript.jsonl');
+ const lines = [
+ '{"type":"user","content":"Fix the bug"}',
+ '{"type":"result","tool_name":"Edit","tool_input":{"file_path":"/tmp/app.js"}}',
+ '{"type":"assistant","message":{"content":[{"type":"text","text":"Done fixing"}]}}'
+ ];
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
+
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ try {
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
+ HOME: isoHome,
+ USERPROFILE: isoHome
+ });
+ assert.strictEqual(result.code, 0, 'Should exit 0');
+ const files = fs.readdirSync(sessionsDir).filter(f => f.endsWith('.tmp'));
+ assert.ok(files.length > 0, 'Should create session file');
+ const content = fs.readFileSync(path.join(sessionsDir, files[0]), 'utf8');
+ // The tool name "Edit" should appear even though type is "result", not "tool_use"
+ assert.ok(content.includes('Edit'), 'Should collect Edit tool via tool_name OR fallback');
+ // The file modified should also be collected since tool_name is Edit
+ assert.ok(content.includes('app.js'), 'Should collect modified file path from tool_input');
+ } finally {
+ fs.rmSync(isoHome, { recursive: true, force: true });
+ }
+ })
+ )
+ passed++;
+ else failed++;
console.log('\nRound 82: session-end.js (template marker present but regex no-match):');
- if (await asyncTest('preserves file when marker present but regex does not match corrupted template', async () => {
- const isoHome = path.join(os.tmpdir(), `ecc-r82-tmpl-${Date.now()}`);
- const sessionsDir = path.join(isoHome, '.claude', 'sessions');
- fs.mkdirSync(sessionsDir, { recursive: true });
+ if (
+ await asyncTest('preserves file when marker present but regex does not match corrupted template', async () => {
+ const isoHome = path.join(os.tmpdir(), `ecc-r82-tmpl-${Date.now()}`);
+ const sessionsDir = path.join(isoHome, '.claude', 'sessions');
+ fs.mkdirSync(sessionsDir, { recursive: true });
- const today = new Date().toISOString().split('T')[0];
- const sessionFile = path.join(sessionsDir, `session-${today}.tmp`);
+ const today = new Date().toISOString().split('T')[0];
+ const sessionFile = path.join(sessionsDir, `session-${today}.tmp`);
- // Write a corrupted template: has the marker but NOT the full regex structure
- const corruptedTemplate = `# Session: ${today}
+ // Write a corrupted template: has the marker but NOT the full regex structure
+ const corruptedTemplate = `# Session: ${today}
**Date:** ${today}
**Started:** 10:00
**Last Updated:** 10:00
@@ -3683,255 +4341,283 @@ async function runTests() {
Some random content without the expected ### Context to Load section
`;
- fs.writeFileSync(sessionFile, corruptedTemplate);
-
- // Provide a transcript with enough content to generate a summary
- const transcriptPath = path.join(isoHome, 'transcript.jsonl');
- const lines = [
- '{"type":"user","content":"Implement authentication feature"}',
- '{"type":"assistant","message":{"content":[{"type":"text","text":"I will implement the auth feature using JWT tokens and bcrypt for password hashing."}]}}',
- '{"type":"tool_use","tool_name":"Write","name":"Write","tool_input":{"file_path":"/tmp/auth.js"}}',
- '{"type":"user","content":"Now add the login endpoint"}',
- '{"type":"assistant","message":{"content":[{"type":"text","text":"Adding the login endpoint with proper validation."}]}}',
- ];
- fs.writeFileSync(transcriptPath, lines.join('\n'));
-
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- try {
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
- HOME: isoHome, USERPROFILE: isoHome
- });
- assert.strictEqual(result.code, 0, 'Should exit 0');
-
- const content = fs.readFileSync(sessionFile, 'utf8');
- // The marker text should still be present since regex didn't match
- assert.ok(content.includes('[Session context goes here]'),
- 'Marker should remain when regex fails to match corrupted template');
- // The corrupted content should still be there
- assert.ok(content.includes('Some random content'),
- 'Original corrupted content should be preserved');
- } finally {
- fs.rmSync(isoHome, { recursive: true, force: true });
- }
- })) passed++; else failed++;
+ fs.writeFileSync(sessionFile, corruptedTemplate);
+
+ // Provide a transcript with enough content to generate a summary
+ const transcriptPath = path.join(isoHome, 'transcript.jsonl');
+ const lines = [
+ '{"type":"user","content":"Implement authentication feature"}',
+ '{"type":"assistant","message":{"content":[{"type":"text","text":"I will implement the auth feature using JWT tokens and bcrypt for password hashing."}]}}',
+ '{"type":"tool_use","tool_name":"Write","name":"Write","tool_input":{"file_path":"/tmp/auth.js"}}',
+ '{"type":"user","content":"Now add the login endpoint"}',
+ '{"type":"assistant","message":{"content":[{"type":"text","text":"Adding the login endpoint with proper validation."}]}}'
+ ];
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
+
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ try {
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
+ HOME: isoHome,
+ USERPROFILE: isoHome
+ });
+ assert.strictEqual(result.code, 0, 'Should exit 0');
+
+ const content = fs.readFileSync(sessionFile, 'utf8');
+ // The marker text should still be present since regex didn't match
+ assert.ok(content.includes('[Session context goes here]'), 'Marker should remain when regex fails to match corrupted template');
+ // The corrupted content should still be there
+ assert.ok(content.includes('Some random content'), 'Original corrupted content should be preserved');
+ } finally {
+ fs.rmSync(isoHome, { recursive: true, force: true });
+ }
+ })
+ )
+ passed++;
+ else failed++;
// ── Round 87: post-edit-format.js and post-edit-typecheck.js stdin overflow (1MB) ──
console.log('\nRound 87: post-edit-format.js (stdin exceeding 1MB — truncation):');
- if (await asyncTest('truncates stdin at 1MB limit and still passes through data (post-edit-format)', async () => {
- // Send 1.2MB of data — exceeds the 1MB MAX_STDIN limit (lines 14-22)
- const payload = 'x'.repeat(1024 * 1024 + 200000);
- const result = await runScript(path.join(scriptsDir, 'post-edit-format.js'), payload);
-
- assert.strictEqual(result.code, 0, 'Should exit 0 even with oversized stdin');
- // Output should be truncated — significantly less than input
- assert.ok(result.stdout.length < payload.length,
- `stdout (${result.stdout.length}) should be shorter than input (${payload.length})`);
- // Output should be approximately 1MB (last accepted chunk may push slightly over)
- assert.ok(result.stdout.length <= 1024 * 1024 + 65536,
- `stdout (${result.stdout.length}) should be near 1MB, not unbounded`);
- assert.ok(result.stdout.length > 0, 'Should still pass through truncated data');
- })) passed++; else failed++;
+ if (
+ await asyncTest('truncates stdin at 1MB limit and still passes through data (post-edit-format)', async () => {
+ // Send 1.2MB of data — exceeds the 1MB MAX_STDIN limit (lines 14-22)
+ const payload = 'x'.repeat(1024 * 1024 + 200000);
+ const result = await runScript(path.join(scriptsDir, 'post-edit-format.js'), payload);
+
+ assert.strictEqual(result.code, 0, 'Should exit 0 even with oversized stdin');
+ // Output should be truncated — significantly less than input
+ assert.ok(result.stdout.length < payload.length, `stdout (${result.stdout.length}) should be shorter than input (${payload.length})`);
+ // Output should be approximately 1MB (last accepted chunk may push slightly over)
+ assert.ok(result.stdout.length <= 1024 * 1024 + 65536, `stdout (${result.stdout.length}) should be near 1MB, not unbounded`);
+ assert.ok(result.stdout.length > 0, 'Should still pass through truncated data');
+ })
+ )
+ passed++;
+ else failed++;
console.log('\nRound 87: post-edit-typecheck.js (stdin exceeding 1MB — truncation):');
- if (await asyncTest('truncates stdin at 1MB limit and still passes through data (post-edit-typecheck)', async () => {
- // Send 1.2MB of data — exceeds the 1MB MAX_STDIN limit (lines 16-24)
- const payload = 'x'.repeat(1024 * 1024 + 200000);
- const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), payload);
-
- assert.strictEqual(result.code, 0, 'Should exit 0 even with oversized stdin');
- // Output should be truncated — significantly less than input
- assert.ok(result.stdout.length < payload.length,
- `stdout (${result.stdout.length}) should be shorter than input (${payload.length})`);
- // Output should be approximately 1MB (last accepted chunk may push slightly over)
- assert.ok(result.stdout.length <= 1024 * 1024 + 65536,
- `stdout (${result.stdout.length}) should be near 1MB, not unbounded`);
- assert.ok(result.stdout.length > 0, 'Should still pass through truncated data');
- })) passed++; else failed++;
+ if (
+ await asyncTest('truncates stdin at 1MB limit and still passes through data (post-edit-typecheck)', async () => {
+ // Send 1.2MB of data — exceeds the 1MB MAX_STDIN limit (lines 16-24)
+ const payload = 'x'.repeat(1024 * 1024 + 200000);
+ const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), payload);
+
+ assert.strictEqual(result.code, 0, 'Should exit 0 even with oversized stdin');
+ // Output should be truncated — significantly less than input
+ assert.ok(result.stdout.length < payload.length, `stdout (${result.stdout.length}) should be shorter than input (${payload.length})`);
+ // Output should be approximately 1MB (last accepted chunk may push slightly over)
+ assert.ok(result.stdout.length <= 1024 * 1024 + 65536, `stdout (${result.stdout.length}) should be near 1MB, not unbounded`);
+ assert.ok(result.stdout.length > 0, 'Should still pass through truncated data');
+ })
+ )
+ passed++;
+ else failed++;
// ── Round 89: post-edit-typecheck.js error detection path (relevantLines) ──
console.log('\nRound 89: post-edit-typecheck.js (TypeScript error detection path):');
- if (await asyncTest('filters TypeScript errors to edited file when tsc reports errors', async () => {
- // post-edit-typecheck.js lines 60-85: when execFileSync('npx', ['tsc', ...]) throws,
- // the catch block filters error output by file path candidates and logs relevant lines.
- // All existing tests either have no tsconfig (tsc never runs) or valid TS (tsc succeeds).
- // This test creates a .ts file with a type error and a tsconfig.json.
- const testDir = createTestDir();
- fs.writeFileSync(path.join(testDir, 'tsconfig.json'), JSON.stringify({
- compilerOptions: { strict: true, noEmit: true }
- }));
- const testFile = path.join(testDir, 'broken.ts');
- // Intentional type error: assigning string to number
- fs.writeFileSync(testFile, 'const x: number = "not a number";\n');
-
- const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
- const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), stdinJson);
-
- // Core: script must exit 0 and pass through stdin data regardless
- assert.strictEqual(result.code, 0, 'Should exit 0 even when tsc finds errors');
- const parsed = JSON.parse(result.stdout);
- assert.strictEqual(parsed.tool_input.file_path, testFile,
- 'Should pass through original stdin data with file_path intact');
-
- // If tsc is available and ran, check that error output is filtered to this file
- if (result.stderr.includes('TypeScript errors in')) {
- assert.ok(result.stderr.includes('broken.ts'),
- `Should reference the edited file basename. Got: ${result.stderr}`);
- }
- // Either way, no crash and data passes through (verified above)
- cleanupTestDir(testDir);
- })) passed++; else failed++;
+ if (
+ await asyncTest('filters TypeScript errors to edited file when tsc reports errors', async () => {
+ // post-edit-typecheck.js lines 60-85: when execFileSync('npx', ['tsc', ...]) throws,
+ // the catch block filters error output by file path candidates and logs relevant lines.
+ // All existing tests either have no tsconfig (tsc never runs) or valid TS (tsc succeeds).
+ // This test creates a .ts file with a type error and a tsconfig.json.
+ const testDir = createTestDir();
+ fs.writeFileSync(
+ path.join(testDir, 'tsconfig.json'),
+ JSON.stringify({
+ compilerOptions: { strict: true, noEmit: true }
+ })
+ );
+ const testFile = path.join(testDir, 'broken.ts');
+ // Intentional type error: assigning string to number
+ fs.writeFileSync(testFile, 'const x: number = "not a number";\n');
+
+ const stdinJson = JSON.stringify({ tool_input: { file_path: testFile } });
+ const result = await runScript(path.join(scriptsDir, 'post-edit-typecheck.js'), stdinJson);
+
+ // Core: script must exit 0 and pass through stdin data regardless
+ assert.strictEqual(result.code, 0, 'Should exit 0 even when tsc finds errors');
+ const parsed = JSON.parse(result.stdout);
+ assert.strictEqual(parsed.tool_input.file_path, testFile, 'Should pass through original stdin data with file_path intact');
+
+ // If tsc is available and ran, check that error output is filtered to this file
+ if (result.stderr.includes('TypeScript errors in')) {
+ assert.ok(result.stderr.includes('broken.ts'), `Should reference the edited file basename. Got: ${result.stderr}`);
+ }
+ // Either way, no crash and data passes through (verified above)
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
// ── Round 89: extractSessionSummary entry.name + entry.input fallback paths ──
console.log('\nRound 89: session-end.js (entry.name + entry.input fallback in extractSessionSummary):');
- if (await asyncTest('extracts tool name from entry.name and file path from entry.input (fallback format)', async () => {
- // session-end.js line 63: const toolName = entry.tool_name || entry.name || '';
- // session-end.js line 66: const filePath = entry.tool_input?.file_path || entry.input?.file_path || '';
- // All existing tests use tool_name + tool_input format. This tests the name + input fallback.
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
-
- const lines = [
- '{"type":"user","content":"Fix the auth module"}',
- // Tool entries using "name" + "input" instead of "tool_name" + "tool_input"
- '{"type":"tool_use","name":"Edit","input":{"file_path":"/src/auth.ts"}}',
- '{"type":"tool_use","name":"Write","input":{"file_path":"/src/new-helper.ts"}}',
- // Also include a tool with tool_name but entry.input (mixed format)
- '{"tool_name":"Read","input":{"file_path":"/src/config.ts"}}',
- ];
- fs.writeFileSync(transcriptPath, lines.join('\n'));
-
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
- HOME: testDir
- });
- assert.strictEqual(result.code, 0, 'Should exit 0');
-
- // Read the session file to verify tool names and file paths were extracted
- const claudeDir = path.join(testDir, '.claude', 'sessions');
- if (fs.existsSync(claudeDir)) {
- const files = fs.readdirSync(claudeDir).filter(f => f.endsWith('.tmp'));
- if (files.length > 0) {
- const content = fs.readFileSync(path.join(claudeDir, files[0]), 'utf8');
- // Tools from entry.name fallback
- assert.ok(content.includes('Edit'),
- `Should extract Edit tool from entry.name fallback. Got: ${content}`);
- assert.ok(content.includes('Write'),
- `Should extract Write tool from entry.name fallback. Got: ${content}`);
- // File paths from entry.input fallback
- assert.ok(content.includes('/src/auth.ts'),
- `Should extract file path from entry.input.file_path fallback. Got: ${content}`);
- assert.ok(content.includes('/src/new-helper.ts'),
- `Should extract Write file from entry.input.file_path fallback. Got: ${content}`);
+ if (
+ await asyncTest('extracts tool name from entry.name and file path from entry.input (fallback format)', async () => {
+ // session-end.js line 63: const toolName = entry.tool_name || entry.name || '';
+ // session-end.js line 66: const filePath = entry.tool_input?.file_path || entry.input?.file_path || '';
+ // All existing tests use tool_name + tool_input format. This tests the name + input fallback.
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
+
+ const lines = [
+ '{"type":"user","content":"Fix the auth module"}',
+ // Tool entries using "name" + "input" instead of "tool_name" + "tool_input"
+ '{"type":"tool_use","name":"Edit","input":{"file_path":"/src/auth.ts"}}',
+ '{"type":"tool_use","name":"Write","input":{"file_path":"/src/new-helper.ts"}}',
+ // Also include a tool with tool_name but entry.input (mixed format)
+ '{"tool_name":"Read","input":{"file_path":"/src/config.ts"}}'
+ ];
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
+
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
+ HOME: testDir
+ });
+ assert.strictEqual(result.code, 0, 'Should exit 0');
+
+ // Read the session file to verify tool names and file paths were extracted
+ const claudeDir = path.join(testDir, '.claude', 'sessions');
+ if (fs.existsSync(claudeDir)) {
+ const files = fs.readdirSync(claudeDir).filter(f => f.endsWith('.tmp'));
+ if (files.length > 0) {
+ const content = fs.readFileSync(path.join(claudeDir, files[0]), 'utf8');
+ // Tools from entry.name fallback
+ assert.ok(content.includes('Edit'), `Should extract Edit tool from entry.name fallback. Got: ${content}`);
+ assert.ok(content.includes('Write'), `Should extract Write tool from entry.name fallback. Got: ${content}`);
+ // File paths from entry.input fallback
+ assert.ok(content.includes('/src/auth.ts'), `Should extract file path from entry.input.file_path fallback. Got: ${content}`);
+ assert.ok(content.includes('/src/new-helper.ts'), `Should extract Write file from entry.input.file_path fallback. Got: ${content}`);
+ }
}
- }
- cleanupTestDir(testDir);
- })) passed++; else failed++;
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
// ── Round 90: readStdinJson timeout path (utils.js lines 215-229) ──
console.log('\nRound 90: readStdinJson (timeout fires when stdin stays open):');
- if (await asyncTest('readStdinJson resolves with {} when stdin never closes (timeout fires, no data)', async () => {
- // utils.js line 215: setTimeout fires because stdin 'end' never arrives.
- // Line 225: data.trim() is empty → resolves with {}.
- // Exercises: removeAllListeners, process.stdin.unref(), and the empty-data timeout resolution.
- const script = 'const u=require("./scripts/lib/utils");u.readStdinJson({timeoutMs:100}).then(d=>{process.stdout.write(JSON.stringify(d));process.exit(0)})';
- return new Promise((resolve, reject) => {
- const child = spawn('node', ['-e', script], {
- cwd: path.resolve(__dirname, '..', '..'),
- stdio: ['pipe', 'pipe', 'pipe']
- });
- // Don't write anything or close stdin — force the timeout to fire
- let stdout = '';
- child.stdout.on('data', d => stdout += d);
- const timer = setTimeout(() => { child.kill(); reject(new Error('Test timed out')); }, 5000);
- child.on('close', (code) => {
- clearTimeout(timer);
- try {
- assert.strictEqual(code, 0, 'Should exit 0 via timeout resolution');
- const parsed = JSON.parse(stdout);
- assert.deepStrictEqual(parsed, {}, 'Should resolve with {} when no data received before timeout');
- resolve();
- } catch (err) {
- reject(err);
- }
- });
- });
- })) passed++; else failed++;
-
- if (await asyncTest('readStdinJson resolves with {} when timeout fires with invalid partial JSON', async () => {
- // utils.js lines 224-228: setTimeout fires, data.trim() is non-empty,
- // JSON.parse(data) throws → catch at line 226 resolves with {}.
- const script = 'const u=require("./scripts/lib/utils");u.readStdinJson({timeoutMs:100}).then(d=>{process.stdout.write(JSON.stringify(d));process.exit(0)})';
- return new Promise((resolve, reject) => {
- const child = spawn('node', ['-e', script], {
- cwd: path.resolve(__dirname, '..', '..'),
- stdio: ['pipe', 'pipe', 'pipe']
+ if (
+ await asyncTest('readStdinJson resolves with {} when stdin never closes (timeout fires, no data)', async () => {
+ // utils.js line 215: setTimeout fires because stdin 'end' never arrives.
+ // Line 225: data.trim() is empty → resolves with {}.
+ // Exercises: removeAllListeners, process.stdin.unref(), and the empty-data timeout resolution.
+ const script = 'const u=require("./scripts/lib/utils");u.readStdinJson({timeoutMs:100}).then(d=>{process.stdout.write(JSON.stringify(d));process.exit(0)})';
+ return new Promise((resolve, reject) => {
+ const child = spawn('node', ['-e', script], {
+ cwd: path.resolve(__dirname, '..', '..'),
+ stdio: ['pipe', 'pipe', 'pipe']
+ });
+ // Don't write anything or close stdin — force the timeout to fire
+ let stdout = '';
+ child.stdout.on('data', d => (stdout += d));
+ const timer = setTimeout(() => {
+ child.kill();
+ reject(new Error('Test timed out'));
+ }, 5000);
+ child.on('close', code => {
+ clearTimeout(timer);
+ try {
+ assert.strictEqual(code, 0, 'Should exit 0 via timeout resolution');
+ const parsed = JSON.parse(stdout);
+ assert.deepStrictEqual(parsed, {}, 'Should resolve with {} when no data received before timeout');
+ resolve();
+ } catch (err) {
+ reject(err);
+ }
+ });
});
- // Write partial invalid JSON but don't close stdin — timeout fires with unparseable data
- child.stdin.write('{"incomplete":');
- let stdout = '';
- child.stdout.on('data', d => stdout += d);
- const timer = setTimeout(() => { child.kill(); reject(new Error('Test timed out')); }, 5000);
- child.on('close', (code) => {
- clearTimeout(timer);
- try {
- assert.strictEqual(code, 0, 'Should exit 0 via timeout resolution');
- const parsed = JSON.parse(stdout);
- assert.deepStrictEqual(parsed, {}, 'Should resolve with {} when partial JSON cannot be parsed');
- resolve();
- } catch (err) {
- reject(err);
- }
+ })
+ )
+ passed++;
+ else failed++;
+
+ if (
+ await asyncTest('readStdinJson resolves with {} when timeout fires with invalid partial JSON', async () => {
+ // utils.js lines 224-228: setTimeout fires, data.trim() is non-empty,
+ // JSON.parse(data) throws → catch at line 226 resolves with {}.
+ const script = 'const u=require("./scripts/lib/utils");u.readStdinJson({timeoutMs:100}).then(d=>{process.stdout.write(JSON.stringify(d));process.exit(0)})';
+ return new Promise((resolve, reject) => {
+ const child = spawn('node', ['-e', script], {
+ cwd: path.resolve(__dirname, '..', '..'),
+ stdio: ['pipe', 'pipe', 'pipe']
+ });
+ // Write partial invalid JSON but don't close stdin — timeout fires with unparseable data
+ child.stdin.write('{"incomplete":');
+ let stdout = '';
+ child.stdout.on('data', d => (stdout += d));
+ const timer = setTimeout(() => {
+ child.kill();
+ reject(new Error('Test timed out'));
+ }, 5000);
+ child.on('close', code => {
+ clearTimeout(timer);
+ try {
+ assert.strictEqual(code, 0, 'Should exit 0 via timeout resolution');
+ const parsed = JSON.parse(stdout);
+ assert.deepStrictEqual(parsed, {}, 'Should resolve with {} when partial JSON cannot be parsed');
+ resolve();
+ } catch (err) {
+ reject(err);
+ }
+ });
});
- });
- })) passed++; else failed++;
+ })
+ )
+ passed++;
+ else failed++;
// ── Round 94: session-end.js tools used but no files modified ──
console.log('\nRound 94: session-end.js (tools used without files modified):');
- if (await asyncTest('session file includes Tools Used but omits Files Modified when only Read/Grep used', async () => {
- // session-end.js buildSummarySection (lines 217-228):
- // filesModified.length > 0 → include "### Files Modified" section
- // toolsUsed.length > 0 → include "### Tools Used" section
- // Previously tested: BOTH present (Round ~10) and NEITHER present (Round ~10).
- // Untested combination: toolsUsed present, filesModified empty.
- // Transcript with Read/Grep tools (don't add to filesModified) and user messages.
- const testDir = createTestDir();
- const transcriptPath = path.join(testDir, 'transcript.jsonl');
-
- const lines = [
- '{"type":"user","content":"Search the codebase for auth handlers"}',
- '{"type":"tool_use","tool_name":"Read","tool_input":{"file_path":"/src/auth.ts"}}',
- '{"type":"tool_use","tool_name":"Grep","tool_input":{"pattern":"handler"}}',
- '{"type":"user","content":"Check the test file too"}',
- '{"type":"tool_use","tool_name":"Read","tool_input":{"file_path":"/tests/auth.test.ts"}}',
- ];
- fs.writeFileSync(transcriptPath, lines.join('\n'));
-
- const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
- const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
- HOME: testDir
- });
- assert.strictEqual(result.code, 0, 'Should exit 0');
-
- const claudeDir = path.join(testDir, '.claude', 'sessions');
- if (fs.existsSync(claudeDir)) {
- const files = fs.readdirSync(claudeDir).filter(f => f.endsWith('.tmp'));
- if (files.length > 0) {
- const content = fs.readFileSync(path.join(claudeDir, files[0]), 'utf8');
- assert.ok(content.includes('### Tools Used'), 'Should include Tools Used section');
- assert.ok(content.includes('Read'), 'Should list Read tool');
- assert.ok(content.includes('Grep'), 'Should list Grep tool');
- assert.ok(!content.includes('### Files Modified'),
- 'Should NOT include Files Modified section (Read/Grep do not modify files)');
+ if (
+ await asyncTest('session file includes Tools Used but omits Files Modified when only Read/Grep used', async () => {
+ // session-end.js buildSummarySection (lines 217-228):
+ // filesModified.length > 0 → include "### Files Modified" section
+ // toolsUsed.length > 0 → include "### Tools Used" section
+ // Previously tested: BOTH present (Round ~10) and NEITHER present (Round ~10).
+ // Untested combination: toolsUsed present, filesModified empty.
+ // Transcript with Read/Grep tools (don't add to filesModified) and user messages.
+ const testDir = createTestDir();
+ const transcriptPath = path.join(testDir, 'transcript.jsonl');
+
+ const lines = [
+ '{"type":"user","content":"Search the codebase for auth handlers"}',
+ '{"type":"tool_use","tool_name":"Read","tool_input":{"file_path":"/src/auth.ts"}}',
+ '{"type":"tool_use","tool_name":"Grep","tool_input":{"pattern":"handler"}}',
+ '{"type":"user","content":"Check the test file too"}',
+ '{"type":"tool_use","tool_name":"Read","tool_input":{"file_path":"/tests/auth.test.ts"}}'
+ ];
+ fs.writeFileSync(transcriptPath, lines.join('\n'));
+
+ const stdinJson = JSON.stringify({ transcript_path: transcriptPath });
+ const result = await runScript(path.join(scriptsDir, 'session-end.js'), stdinJson, {
+ HOME: testDir
+ });
+ assert.strictEqual(result.code, 0, 'Should exit 0');
+
+ const claudeDir = path.join(testDir, '.claude', 'sessions');
+ if (fs.existsSync(claudeDir)) {
+ const files = fs.readdirSync(claudeDir).filter(f => f.endsWith('.tmp'));
+ if (files.length > 0) {
+ const content = fs.readFileSync(path.join(claudeDir, files[0]), 'utf8');
+ assert.ok(content.includes('### Tools Used'), 'Should include Tools Used section');
+ assert.ok(content.includes('Read'), 'Should list Read tool');
+ assert.ok(content.includes('Grep'), 'Should list Grep tool');
+ assert.ok(!content.includes('### Files Modified'), 'Should NOT include Files Modified section (Read/Grep do not modify files)');
+ }
}
- }
- cleanupTestDir(testDir);
- })) passed++; else failed++;
+ cleanupTestDir(testDir);
+ })
+ )
+ passed++;
+ else failed++;
// Summary
console.log('\n=== Test Results ===');