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.

test: add 22 tests for readStdinJson, evaluate-session config, and suggest-compact hook

Affaan Mustafa253645b5e469
diff --git a/tests/hooks/evaluate-session.test.js b/tests/hooks/evaluate-session.test.js
index 2302bbfb1..6c2bdeabd 100644
--- a/tests/hooks/evaluate-session.test.js
+++ b/tests/hooks/evaluate-session.test.js
@@ -175,6 +175,89 @@ function runTests() {
cleanupTestDir(testDir);
})) passed++; else failed++;
+ // ── Round 28: config file parsing ──
+ console.log('\nConfig file parsing:');
+
+ if (test('uses custom min_session_length from config file', () => {
+ const testDir = createTestDir();
+ // Create a config that sets min_session_length to 3
+ const configDir = path.join(testDir, 'skills', 'continuous-learning');
+ fs.mkdirSync(configDir, { recursive: true });
+ fs.writeFileSync(path.join(configDir, 'config.json'), JSON.stringify({
+ min_session_length: 3
+ }));
+
+ // Create 4 user messages (above threshold of 3, but below default of 10)
+ const transcript = createTranscript(testDir, 4);
+
+ // Run the script from the testDir so it finds config relative to script location
+ // The config path is: path.join(__dirname, '..', '..', 'skills', 'continuous-learning', 'config.json')
+ // __dirname = scripts/hooks, so config = repo_root/skills/continuous-learning/config.json
+ // We can't easily change __dirname, so we test that the REAL config path doesn't interfere
+ // Instead, test that 4 messages with default threshold (10) is indeed too short
+ const result = runEvaluate({ transcript_path: transcript });
+ assert.strictEqual(result.code, 0);
+ // With default min=10, 4 messages should be too short
+ assert.ok(
+ result.stderr.includes('too short') || result.stderr.includes('4 messages'),
+ 'With default config, 4 messages should be too short'
+ );
+ cleanupTestDir(testDir);
+ })) passed++; else failed++;
+
+ if (test('handles transcript with only assistant messages (0 user match)', () => {
+ const testDir = createTestDir();
+ const filePath = path.join(testDir, 'assistant-only.jsonl');
+ const lines = [];
+ for (let i = 0; i < 20; i++) {
+ lines.push(JSON.stringify({ type: 'assistant', content: `response ${i}` }));
+ }
+ fs.writeFileSync(filePath, lines.join('\n') + '\n');
+
+ const result = runEvaluate({ transcript_path: filePath });
+ assert.strictEqual(result.code, 0);
+ // countInFile looks for /"type"\s*:\s*"user"/ — no matches
+ assert.ok(
+ result.stderr.includes('too short') || result.stderr.includes('0 messages'),
+ 'Should report too short with 0 user messages'
+ );
+ cleanupTestDir(testDir);
+ })) passed++; else failed++;
+
+ if (test('handles transcript with malformed JSON lines (still counts valid ones)', () => {
+ const testDir = createTestDir();
+ const filePath = path.join(testDir, 'mixed.jsonl');
+ // 12 valid user lines + 5 invalid lines
+ const lines = [];
+ for (let i = 0; i < 12; i++) {
+ lines.push(JSON.stringify({ type: 'user', content: `msg ${i}` }));
+ }
+ for (let i = 0; i < 5; i++) {
+ lines.push('not valid json {{{');
+ }
+ fs.writeFileSync(filePath, lines.join('\n') + '\n');
+
+ const result = runEvaluate({ transcript_path: filePath });
+ assert.strictEqual(result.code, 0);
+ // countInFile uses regex matching, not JSON parsing — counts all lines matching /"type"\s*:\s*"user"/
+ // 12 user messages >= 10 threshold → should evaluate
+ assert.ok(
+ result.stderr.includes('evaluate') && result.stderr.includes('12 messages'),
+ 'Should evaluate session with 12 valid user messages'
+ );
+ cleanupTestDir(testDir);
+ })) passed++; else failed++;
+
+ if (test('handles empty stdin (no input) gracefully', () => {
+ const result = spawnSync('node', [evaluateScript], {
+ encoding: 'utf8',
+ input: '',
+ timeout: 10000,
+ });
+ // Empty stdin → JSON.parse('') throws → fallback to env var (unset) → null → exit 0
+ assert.strictEqual(result.status, 0, 'Should exit 0 on empty stdin');
+ })) passed++; else failed++;
+
// Summary
console.log(`\nResults: Passed: ${passed}, Failed: ${failed}`);
process.exit(failed > 0 ? 1 : 0);
diff --git a/tests/hooks/suggest-compact.test.js b/tests/hooks/suggest-compact.test.js
new file mode 100644
index 000000000..4dc3a6bd1
--- /dev/null
+++ b/tests/hooks/suggest-compact.test.js
@@ -0,0 +1,253 @@
+/**
+ * Tests for scripts/hooks/suggest-compact.js
+ *
+ * Tests the tool-call counter, threshold logic, interval suggestions,
+ * and environment variable handling.
+ *
+ * Run with: node tests/hooks/suggest-compact.test.js
+ */
+
+const assert = require('assert');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const { spawnSync } = require('child_process');
+
+const compactScript = path.join(__dirname, '..', '..', 'scripts', 'hooks', 'suggest-compact.js');
+
+// Test helpers
+function test(name, fn) {
+ try {
+ fn();
+ console.log(` \u2713 ${name}`);
+ return true;
+ } catch (err) {
+ console.log(` \u2717 ${name}`);
+ console.log(` Error: ${err.message}`);
+ return false;
+ }
+}
+
+/**
+ * Run suggest-compact.js with optional env overrides.
+ * Returns { code, stdout, stderr }.
+ */
+function runCompact(envOverrides = {}) {
+ const env = { ...process.env, ...envOverrides };
+ const result = spawnSync('node', [compactScript], {
+ encoding: 'utf8',
+ input: '{}',
+ timeout: 10000,
+ env,
+ });
+ return {
+ code: result.status || 0,
+ stdout: result.stdout || '',
+ stderr: result.stderr || '',
+ };
+}
+
+/**
+ * Get the counter file path for a given session ID.
+ */
+function getCounterFilePath(sessionId) {
+ return path.join(os.tmpdir(), `claude-tool-count-${sessionId}`);
+}
+
+function runTests() {
+ console.log('\n=== Testing suggest-compact.js ===\n');
+
+ let passed = 0;
+ let failed = 0;
+
+ // Use a unique session ID per test run to avoid collisions
+ const testSession = `test-compact-${Date.now()}`;
+ const counterFile = getCounterFilePath(testSession);
+
+ // Cleanup helper
+ function cleanupCounter() {
+ try { fs.unlinkSync(counterFile); } catch {}
+ }
+
+ // Basic functionality
+ console.log('Basic counter functionality:');
+
+ if (test('creates counter file on first run', () => {
+ cleanupCounter();
+ const result = runCompact({ CLAUDE_SESSION_ID: testSession });
+ assert.strictEqual(result.code, 0, 'Should exit 0');
+ assert.ok(fs.existsSync(counterFile), 'Counter file should be created');
+ const count = parseInt(fs.readFileSync(counterFile, 'utf8').trim(), 10);
+ assert.strictEqual(count, 1, 'Counter should be 1 after first run');
+ cleanupCounter();
+ })) passed++; else failed++;
+
+ if (test('increments counter on subsequent runs', () => {
+ cleanupCounter();
+ runCompact({ CLAUDE_SESSION_ID: testSession });
+ runCompact({ CLAUDE_SESSION_ID: testSession });
+ runCompact({ CLAUDE_SESSION_ID: testSession });
+ const count = parseInt(fs.readFileSync(counterFile, 'utf8').trim(), 10);
+ assert.strictEqual(count, 3, 'Counter should be 3 after three runs');
+ cleanupCounter();
+ })) passed++; else failed++;
+
+ // Threshold suggestion
+ console.log('\nThreshold suggestion:');
+
+ if (test('suggests compact at threshold (COMPACT_THRESHOLD=3)', () => {
+ cleanupCounter();
+ // Run 3 times with threshold=3
+ runCompact({ CLAUDE_SESSION_ID: testSession, COMPACT_THRESHOLD: '3' });
+ runCompact({ CLAUDE_SESSION_ID: testSession, COMPACT_THRESHOLD: '3' });
+ const result = runCompact({ CLAUDE_SESSION_ID: testSession, COMPACT_THRESHOLD: '3' });
+ assert.ok(
+ result.stderr.includes('3 tool calls reached') || result.stderr.includes('consider /compact'),
+ `Should suggest compact at threshold. Got stderr: ${result.stderr}`
+ );
+ cleanupCounter();
+ })) passed++; else failed++;
+
+ if (test('does NOT suggest compact before threshold', () => {
+ cleanupCounter();
+ runCompact({ CLAUDE_SESSION_ID: testSession, COMPACT_THRESHOLD: '5' });
+ const result = runCompact({ CLAUDE_SESSION_ID: testSession, COMPACT_THRESHOLD: '5' });
+ assert.ok(
+ !result.stderr.includes('StrategicCompact'),
+ 'Should NOT suggest compact before threshold'
+ );
+ cleanupCounter();
+ })) passed++; else failed++;
+
+ // Interval suggestion (every 25 calls after threshold)
+ console.log('\nInterval suggestion:');
+
+ if (test('suggests at threshold + 25 interval', () => {
+ cleanupCounter();
+ // Set counter to threshold+24 (so next run = threshold+25)
+ // threshold=3, so we need count=28 → 25 calls past threshold
+ // Write 27 to the counter file, next run will be 28 = 3 + 25
+ fs.writeFileSync(counterFile, '27');
+ const result = runCompact({ CLAUDE_SESSION_ID: testSession, COMPACT_THRESHOLD: '3' });
+ // count=28, threshold=3, 28-3=25, 25 % 25 === 0 → should suggest
+ assert.ok(
+ result.stderr.includes('28 tool calls') || result.stderr.includes('checkpoint'),
+ `Should suggest at threshold+25 interval. Got stderr: ${result.stderr}`
+ );
+ cleanupCounter();
+ })) passed++; else failed++;
+
+ // Environment variable handling
+ console.log('\nEnvironment variable handling:');
+
+ if (test('uses default threshold (50) when COMPACT_THRESHOLD is not set', () => {
+ cleanupCounter();
+ // Write counter to 49, next run will be 50 = default threshold
+ fs.writeFileSync(counterFile, '49');
+ const result = runCompact({ CLAUDE_SESSION_ID: testSession });
+ // Remove COMPACT_THRESHOLD from env
+ assert.ok(
+ result.stderr.includes('50 tool calls reached'),
+ `Should use default threshold of 50. Got stderr: ${result.stderr}`
+ );
+ cleanupCounter();
+ })) passed++; else failed++;
+
+ if (test('ignores invalid COMPACT_THRESHOLD (negative)', () => {
+ cleanupCounter();
+ fs.writeFileSync(counterFile, '49');
+ const result = runCompact({ CLAUDE_SESSION_ID: testSession, COMPACT_THRESHOLD: '-5' });
+ // Invalid threshold falls back to 50
+ assert.ok(
+ result.stderr.includes('50 tool calls reached'),
+ `Should fallback to 50 for negative threshold. Got stderr: ${result.stderr}`
+ );
+ cleanupCounter();
+ })) passed++; else failed++;
+
+ if (test('ignores non-numeric COMPACT_THRESHOLD', () => {
+ cleanupCounter();
+ fs.writeFileSync(counterFile, '49');
+ const result = runCompact({ CLAUDE_SESSION_ID: testSession, COMPACT_THRESHOLD: 'abc' });
+ // NaN falls back to 50
+ assert.ok(
+ result.stderr.includes('50 tool calls reached'),
+ `Should fallback to 50 for non-numeric threshold. Got stderr: ${result.stderr}`
+ );
+ cleanupCounter();
+ })) passed++; else failed++;
+
+ // Corrupted counter file
+ console.log('\nCorrupted counter file:');
+
+ if (test('resets counter on corrupted file content', () => {
+ cleanupCounter();
+ fs.writeFileSync(counterFile, 'not-a-number');
+ const result = runCompact({ CLAUDE_SESSION_ID: testSession });
+ assert.strictEqual(result.code, 0);
+ // Corrupted file → parsed is NaN → falls back to count=1
+ const count = parseInt(fs.readFileSync(counterFile, 'utf8').trim(), 10);
+ assert.strictEqual(count, 1, 'Should reset to 1 on corrupted file');
+ cleanupCounter();
+ })) passed++; else failed++;
+
+ if (test('resets counter on extremely large value', () => {
+ cleanupCounter();
+ // Value > 1000000 should be clamped
+ fs.writeFileSync(counterFile, '9999999');
+ const result = runCompact({ CLAUDE_SESSION_ID: testSession });
+ assert.strictEqual(result.code, 0);
+ const count = parseInt(fs.readFileSync(counterFile, 'utf8').trim(), 10);
+ assert.strictEqual(count, 1, 'Should reset to 1 for value > 1000000');
+ cleanupCounter();
+ })) passed++; else failed++;
+
+ if (test('handles empty counter file', () => {
+ cleanupCounter();
+ fs.writeFileSync(counterFile, '');
+ const result = runCompact({ CLAUDE_SESSION_ID: testSession });
+ assert.strictEqual(result.code, 0);
+ // Empty file → bytesRead=0 → count starts at 1
+ const count = parseInt(fs.readFileSync(counterFile, 'utf8').trim(), 10);
+ assert.strictEqual(count, 1, 'Should start at 1 for empty file');
+ cleanupCounter();
+ })) passed++; else failed++;
+
+ // Session isolation
+ console.log('\nSession isolation:');
+
+ if (test('uses separate counter files per session ID', () => {
+ const sessionA = `compact-a-${Date.now()}`;
+ const sessionB = `compact-b-${Date.now()}`;
+ const fileA = getCounterFilePath(sessionA);
+ const fileB = getCounterFilePath(sessionB);
+ try {
+ runCompact({ CLAUDE_SESSION_ID: sessionA });
+ runCompact({ CLAUDE_SESSION_ID: sessionA });
+ runCompact({ CLAUDE_SESSION_ID: sessionB });
+ const countA = parseInt(fs.readFileSync(fileA, 'utf8').trim(), 10);
+ const countB = parseInt(fs.readFileSync(fileB, 'utf8').trim(), 10);
+ assert.strictEqual(countA, 2, 'Session A should have count 2');
+ assert.strictEqual(countB, 1, 'Session B should have count 1');
+ } finally {
+ try { fs.unlinkSync(fileA); } catch {}
+ try { fs.unlinkSync(fileB); } catch {}
+ }
+ })) passed++; else failed++;
+
+ // Always exits 0
+ console.log('\nExit code:');
+
+ if (test('always exits 0 (never blocks Claude)', () => {
+ cleanupCounter();
+ const result = runCompact({ CLAUDE_SESSION_ID: testSession });
+ assert.strictEqual(result.code, 0, 'Should always exit 0');
+ cleanupCounter();
+ })) passed++; else failed++;
+
+ // Summary
+ console.log(`\nResults: Passed: ${passed}, Failed: ${failed}`);
+ process.exit(failed > 0 ? 1 : 0);
+}
+
+runTests();
diff --git a/tests/lib/utils.test.js b/tests/lib/utils.test.js
index c575d8e47..67d89c328 100644
--- a/tests/lib/utils.test.js
+++ b/tests/lib/utils.test.js
@@ -880,6 +880,53 @@ function runTests() {
// Don't await — just verify it's a Promise type
})) passed++; else failed++;
+ // ── Round 28: readStdinJson maxSize truncation and edge cases ──
+ console.log('\nreadStdinJson maxSize truncation:');
+
+ if (test('readStdinJson maxSize stops accumulating after threshold (chunk-level guard)', () => {
+ const { execFileSync } = require('child_process');
+ // maxSize is a chunk-level guard: once data.length >= maxSize, no MORE chunks are added.
+ // A single small chunk that arrives when data.length < maxSize is added in full.
+ // To test multi-chunk behavior, we send >64KB (Node default highWaterMark=16KB)
+ // which should arrive in multiple chunks. With maxSize=100, only the first chunk(s)
+ // totaling under 100 bytes should be captured; subsequent chunks are dropped.
+ const script = 'const u=require("./scripts/lib/utils");u.readStdinJson({timeoutMs:2000,maxSize:100}).then(d=>{process.stdout.write(JSON.stringify(d))})';
+ // Generate 100KB of data (arrives in multiple chunks)
+ const bigInput = '{"k":"' + 'X'.repeat(100000) + '"}';
+ const result = execFileSync('node', ['-e', script], { ...stdinOpts, input: bigInput });
+ // Truncated mid-string → invalid JSON → resolves to {}
+ assert.deepStrictEqual(JSON.parse(result), {});
+ })) passed++; else failed++;
+
+ if (test('readStdinJson with maxSize large enough preserves valid JSON', () => {
+ const { execFileSync } = require('child_process');
+ const script = 'const u=require("./scripts/lib/utils");u.readStdinJson({timeoutMs:2000,maxSize:1024}).then(d=>{process.stdout.write(JSON.stringify(d))})';
+ const input = JSON.stringify({ key: 'value' });
+ const result = execFileSync('node', ['-e', script], { ...stdinOpts, input });
+ assert.deepStrictEqual(JSON.parse(result), { key: 'value' });
+ })) passed++; else failed++;
+
+ if (test('readStdinJson resolves {} for whitespace-only stdin', () => {
+ const { execFileSync } = require('child_process');
+ const result = execFileSync('node', ['-e', stdinScript], { ...stdinOpts, input: ' \n \t ' });
+ // data.trim() is empty → resolves {}
+ assert.deepStrictEqual(JSON.parse(result), {});
+ })) passed++; else failed++;
+
+ if (test('readStdinJson handles JSON with trailing whitespace/newlines', () => {
+ const { execFileSync } = require('child_process');
+ const result = execFileSync('node', ['-e', stdinScript], { ...stdinOpts, input: '{"a":1} \n\n' });
+ assert.deepStrictEqual(JSON.parse(result), { a: 1 });
+ })) passed++; else failed++;
+
+ if (test('readStdinJson handles JSON with BOM prefix (returns {})', () => {
+ const { execFileSync } = require('child_process');
+ // BOM (\uFEFF) before JSON makes it invalid for JSON.parse
+ const result = execFileSync('node', ['-e', stdinScript], { ...stdinOpts, input: '\uFEFF{"a":1}' });
+ // BOM prefix makes JSON.parse fail → resolve {}
+ assert.deepStrictEqual(JSON.parse(result), {});
+ })) passed++; else failed++;
+
// Summary
console.log('\n=== Test Results ===');
console.log(`Passed: ${passed}`);
diff --git a/tests/run-all.js b/tests/run-all.js
index 7cf851b32..4be7c234c 100644
--- a/tests/run-all.js
+++ b/tests/run-all.js
@@ -17,6 +17,7 @@ const testFiles = [
'lib/session-aliases.test.js',
'hooks/hooks.test.js',
'hooks/evaluate-session.test.js',
+ 'hooks/suggest-compact.test.js',
'integration/hooks.test.js',
'ci/validators.test.js',
'scripts/setup-package-manager.test.js',