claude-code-session-manager 0.33.1 → 0.35.0

package/src/main/__tests__/exchanges.test.cjs

@@ -0,0 +1,177 @@
+'use strict';
+
+/**
+ * Unit test for exchanges.cjs.
+ *
+ * Runs against a tmp HOME so no real files are touched.
+ * Stubs summarize.cjs to avoid any network calls.
+ *
+ * Run: timeout 120 node --test src/main/__tests__/exchanges.test.cjs
+ */
+
+const { test, describe, before, after } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const path = require('node:path');
+const os = require('node:os');
+
+// ─── Tmp HOME setup ─────────────────────────────────────────────────────────
+
+let tmpHome;
+let origHome;
+
+before(() => {
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'exchanges-test-'));
+  origHome = process.env.HOME;
+  // node:os.homedir() reads HOME on Linux
+  process.env.HOME = tmpHome;
+});
+
+after(async () => {
+  process.env.HOME = origHome;
+  await fsp.rm(tmpHome, { recursive: true, force: true });
+});
+
+// ─── Module loading under tmp HOME ──────────────────────────────────────────
+
+// Clear module cache so encodeCwd / config / exchanges pick up the new HOME
+function freshRequire(mod) {
+  delete require.cache[require.resolve(mod)];
+  return require(mod);
+}
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe('recordExchange', () => {
+  test('writes a complete record when summarize succeeds', async () => {
+    // Stub summarize to return a fixed summary without a network call
+    const summarizePath = require.resolve('../lib/summarize.cjs');
+    delete require.cache[summarizePath];
+    require.cache[summarizePath] = {
+      id: summarizePath,
+      filename: summarizePath,
+      loaded: true,
+      exports: {
+        summarize: async () => ({ summary: 'Test summary.', model: 'claude-haiku-4-5' }),
+      },
+    };
+
+    // Clear exchanges so it picks up the stub
+    const exchangesPath = require.resolve('../exchanges.cjs');
+    delete require.cache[exchangesPath];
+    // Also clear config so it re-reads the new HOME
+    const configPath = require.resolve('../config.cjs');
+    delete require.cache[configPath];
+    const encodeCwdPath = require.resolve('../lib/encodeCwd.cjs');
+    delete require.cache[encodeCwdPath];
+
+    const { recordExchange, EXCHANGES_DIR } = require('../exchanges.cjs');
+
+    const sessionId = 'sess-abc-123';
+    const cwd = '/home/user/myproject';
+    const prompt = 'What is 2+2?';
+    const result = 'The answer is 4.';
+
+    await recordExchange({ sessionId, cwd, prompt, result });
+
+    // Re-resolve the exchanges dir using the actual module's path (under tmpHome)
+    const { encodeCwd } = require('../lib/encodeCwd.cjs');
+    const encoded = encodeCwd(cwd);
+    const logPath = path.join(tmpHome, '.claude', 'knowledge-log', 'exchanges', `${encoded}.jsonl`);
+
+    const content = await fsp.readFile(logPath, 'utf8');
+    const lines = content.trim().split('\n').filter(Boolean);
+    assert.equal(lines.length, 1, 'should write exactly one line');
+
+    const record = JSON.parse(lines[0]);
+    assert.equal(record.sessionId, sessionId);
+    assert.equal(record.cwd, cwd);
+    assert.equal(record.prompt, prompt);
+    assert.equal(record.result, result);
+    assert.equal(record.summary, 'Test summary.');
+    assert.equal(record.model, 'claude-haiku-4-5');
+    assert.ok(record.ts, 'ts field should be present');
+    assert.equal(record.degraded, undefined, 'should not have degraded field on success');
+  });
+
+  test('still writes a record when summarize degrades (no_api_key)', async () => {
+    // Stub summarize to return a degraded result
+    const summarizePath = require.resolve('../lib/summarize.cjs');
+    delete require.cache[summarizePath];
+    require.cache[summarizePath] = {
+      id: summarizePath,
+      filename: summarizePath,
+      loaded: true,
+      exports: {
+        summarize: async (text) => ({
+          summary: text.slice(0, 600),
+          model: 'raw',
+          degraded: 'no_api_key',
+        }),
+      },
+    };
+
+    const exchangesPath = require.resolve('../exchanges.cjs');
+    delete require.cache[exchangesPath];
+
+    const { recordExchange } = require('../exchanges.cjs');
+    const { encodeCwd } = require('../lib/encodeCwd.cjs');
+
+    const sessionId = 'sess-degrade-456';
+    const cwd = '/home/user/anotherproject';
+    const result = 'Some verbatim result text from the assistant.';
+
+    await recordExchange({ sessionId, cwd, prompt: 'do something', result });
+
+    const encoded = encodeCwd(cwd);
+    const logPath = path.join(tmpHome, '.claude', 'knowledge-log', 'exchanges', `${encoded}.jsonl`);
+
+    const content = await fsp.readFile(logPath, 'utf8');
+    const lines = content.trim().split('\n').filter(Boolean);
+    assert.equal(lines.length, 1);
+
+    const record = JSON.parse(lines[0]);
+    assert.equal(record.sessionId, sessionId);
+    assert.equal(record.result, result, 'verbatim result must be stored');
+    assert.equal(record.degraded, 'no_api_key');
+    assert.equal(record.model, 'raw');
+    // summary is the raw slice of the result
+    assert.equal(record.summary, result.slice(0, 600));
+  });
+
+  test('appends multiple records to the same file', async () => {
+    // Stub summarize
+    const summarizePath = require.resolve('../lib/summarize.cjs');
+    delete require.cache[summarizePath];
+    require.cache[summarizePath] = {
+      id: summarizePath,
+      filename: summarizePath,
+      loaded: true,
+      exports: {
+        summarize: async () => ({ summary: 'ok', model: 'claude-haiku-4-5' }),
+      },
+    };
+
+    const exchangesPath = require.resolve('../exchanges.cjs');
+    delete require.cache[exchangesPath];
+    const { recordExchange } = require('../exchanges.cjs');
+    const { encodeCwd } = require('../lib/encodeCwd.cjs');
+
+    const cwd = '/home/user/multiproject';
+
+    await recordExchange({ sessionId: 's1', cwd, prompt: 'first', result: 'res1' });
+    await recordExchange({ sessionId: 's2', cwd, prompt: 'second', result: 'res2' });
+
+    const encoded = encodeCwd(cwd);
+    const logPath = path.join(tmpHome, '.claude', 'knowledge-log', 'exchanges', `${encoded}.jsonl`);
+    const content = await fsp.readFile(logPath, 'utf8');
+    const lines = content.trim().split('\n').filter(Boolean);
+    assert.equal(lines.length, 2);
+
+    const r1 = JSON.parse(lines[0]);
+    const r2 = JSON.parse(lines[1]);
+    assert.equal(r1.sessionId, 's1');
+    assert.equal(r2.sessionId, 's2');
+  });
+});

package/src/main/__tests__/files-reject-credentials.test.cjs

@@ -0,0 +1,40 @@
+'use strict';
+
+// rejectCredentials — write-side denylist for files:* mutations (write/create/
+// rename/delete all call it). Pure path logic; no fs touched.
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const os = require('node:os');
+const path = require('node:path');
+
+const { rejectCredentials } = require('../files.cjs');
+
+const home = os.homedir();
+const under = (...p) => path.join(home, ...p);
+
+test('denies writing the OAuth credentials file', () => {
+  assert.throws(() => rejectCredentials(under('.claude', '.credentials.json')), /credentials\.json denied/);
+});
+
+test('denies writes anywhere inside ~/.ssh (keys, authorized_keys, config)', () => {
+  for (const p of ['authorized_keys', 'authorized_keys2', 'id_ed25519', 'config']) {
+    assert.throws(() => rejectCredentials(under('.ssh', p)), /\.ssh denied/, `~/.ssh/${p} should be denied`);
+  }
+  assert.throws(() => rejectCredentials(under('.ssh')), /\.ssh denied/);
+});
+
+test('denies writing autostart persistence entries', () => {
+  assert.throws(() => rejectCredentials(under('.config', 'autostart', 'evil.desktop')), /autostart denied/);
+});
+
+test('allows ordinary files — including shell rc, which developers do edit', () => {
+  for (const p of [under('Projects', 'app', 'src', 'index.ts'), under('.bashrc'), under('.zshrc'), under('.config', 'session-manager', 'voice.json')]) {
+    assert.doesNotThrow(() => rejectCredentials(p), `${p} should be allowed`);
+  }
+});
+
+test('a path that merely starts with ".ssh" but is a sibling is not over-blocked', () => {
+  // ~/.sshfoo is a different entry — must NOT be caught by the ~/.ssh rule.
+  assert.doesNotThrow(() => rejectCredentials(under('.sshfoo', 'x')));
+});

package/src/main/__tests__/kg-augment.test.cjs

@@ -0,0 +1,195 @@
+'use strict';
+
+/**
+ * Unit test for kg exchange-pairing logic (kgExchangePairing.cjs).
+ *
+ * Verifies:
+ *   1. When a prompt has a matching exchange record, the enriched entry includes
+ *      result and summary from the exchange.
+ *   2. When no exchange file exists for the cwd, entries fall back to prompt-only
+ *      (no crash, no empty-graph wipe).
+ *   3. When an exchange exists but the prompt text doesn't match, the entry is
+ *      returned unchanged (no false enrichment).
+ *   4. normalizePromptKey trims, lowercases, and collapses whitespace so minor
+ *      differences between log sources don't break the match.
+ *
+ * Does NOT spawn claude -p. Run:
+ *   timeout 120 node --test src/main/__tests__/kg-augment.test.cjs
+ */
+
+const { test, describe, before, after } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const path = require('node:path');
+const os = require('node:os');
+
+// ─── Tmp directory ───────────────────────────────────────────────────────────
+
+let tmpDir;
+
+before(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kg-augment-test-'));
+});
+
+after(async () => {
+  await fsp.rm(tmpDir, { recursive: true, force: true });
+});
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function freshRequire(mod) {
+  delete require.cache[require.resolve(mod)];
+  return require(mod);
+}
+
+const PAIRING_MOD = '../lib/kgExchangePairing.cjs';
+
+/** Write NDJSON exchange records to a file under a fresh exchanges dir. */
+async function writeExchangeFile(exchangesDir, cwd, records) {
+  // Derive the encoded cwd the same way the module does
+  const { encodeCwd } = require('../lib/encodeCwd.cjs');
+  const encoded = encodeCwd(cwd);
+  const filePath = path.join(exchangesDir, `${encoded}.jsonl`);
+  await fsp.mkdir(exchangesDir, { recursive: true });
+  const content = records.map((r) => JSON.stringify(r)).join('\n') + '\n';
+  await fsp.writeFile(filePath, content, 'utf8');
+}
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe('normalizePromptKey', () => {
+  test('lowercases, collapses whitespace, trims', () => {
+    const { normalizePromptKey } = freshRequire(PAIRING_MOD);
+    assert.equal(normalizePromptKey('  Hello   World  '), 'hello world');
+    assert.equal(normalizePromptKey('Fix\nthe\t\tbug'), 'fix the bug');
+  });
+
+  test('truncates at 500 chars', () => {
+    const { normalizePromptKey } = freshRequire(PAIRING_MOD);
+    const long = 'a'.repeat(800);
+    assert.equal(normalizePromptKey(long).length, 500);
+  });
+
+  test('handles empty / null / undefined gracefully', () => {
+    const { normalizePromptKey } = freshRequire(PAIRING_MOD);
+    assert.equal(normalizePromptKey(''), '');
+    assert.equal(normalizePromptKey(null), '');
+    assert.equal(normalizePromptKey(undefined), '');
+  });
+});
+
+describe('loadExchangeIndex', () => {
+  test('returns empty Map when exchanges file does not exist', async () => {
+    const { loadExchangeIndex } = freshRequire(PAIRING_MOD);
+    const exchangesDir = path.join(tmpDir, 'missing-dir');
+    const idx = await loadExchangeIndex(exchangesDir, '/some/project');
+    assert.ok(idx instanceof Map);
+    assert.equal(idx.size, 0, 'should return empty Map on missing file');
+  });
+
+  test('indexes exchange records by normalized prompt key', async () => {
+    const { loadExchangeIndex } = freshRequire(PAIRING_MOD);
+    const exchangesDir = path.join(tmpDir, 'idx-test-exchanges');
+    const cwd = '/home/user/testproject';
+
+    await writeExchangeFile(exchangesDir, cwd, [
+      { ts: '2026-06-25T01:00:00Z', sessionId: 's1', cwd, prompt: 'Fix the bug', result: 'I fixed it.', summary: 'Bug fixed.' },
+      { ts: '2026-06-25T01:01:00Z', sessionId: 's1', cwd, prompt: 'Add a feature', result: 'Feature added.', summary: 'Feature added.' },
+    ]);
+
+    const idx = await loadExchangeIndex(exchangesDir, cwd);
+    assert.equal(idx.size, 2);
+    assert.ok(idx.has('fix the bug'), 'should have normalized key');
+    assert.equal(idx.get('fix the bug').result, 'I fixed it.');
+    assert.equal(idx.get('fix the bug').summary, 'Bug fixed.');
+  });
+
+  test('skips malformed NDJSON lines without throwing', async () => {
+    const { loadExchangeIndex, normalizePromptKey } = freshRequire(PAIRING_MOD);
+    const { encodeCwd } = require('../lib/encodeCwd.cjs');
+    const exchangesDir = path.join(tmpDir, 'malformed-test');
+    const cwd = '/home/user/malformed';
+
+    await fsp.mkdir(exchangesDir, { recursive: true });
+    const encoded = encodeCwd(cwd);
+    const filePath = path.join(exchangesDir, `${encoded}.jsonl`);
+    await fsp.writeFile(filePath, [
+      'not-json-at-all',
+      JSON.stringify({ ts: '2026-06-25T00:00:00Z', sessionId: 's1', cwd, prompt: 'valid prompt', result: 'ok', summary: 'ok' }),
+      '{ broken json',
+    ].join('\n') + '\n', 'utf8');
+
+    const idx = await loadExchangeIndex(exchangesDir, cwd);
+    assert.equal(idx.size, 1, 'should index only the valid line');
+    assert.ok(idx.has(normalizePromptKey('valid prompt')));
+  });
+});
+
+describe('enrichEntries', () => {
+  test('adds result and summary when exchange matches by prompt text', async () => {
+    const { loadExchangeIndex, enrichEntries } = freshRequire(PAIRING_MOD);
+    const exchangesDir = path.join(tmpDir, 'enrich-match');
+    const cwd = '/home/user/myapp';
+
+    await writeExchangeFile(exchangesDir, cwd, [
+      { ts: '2026-06-25T10:00:00Z', sessionId: 's1', cwd, prompt: 'Refactor the scheduler', result: 'I refactored it.', summary: 'Scheduler refactored.' },
+    ]);
+
+    const idx = await loadExchangeIndex(exchangesDir, cwd);
+
+    const entries = [
+      { ts: '2026-06-25T09:59:00Z', session_id: 's1', cwd, prompt: 'Refactor the scheduler' },
+      { ts: '2026-06-25T09:58:00Z', session_id: 's1', cwd, prompt: 'Unrelated prompt' },
+    ];
+
+    const enriched = enrichEntries(entries, idx);
+
+    // First entry has a match — should have result + summary
+    assert.equal(enriched[0].result, 'I refactored it.', 'matched entry should get result');
+    assert.equal(enriched[0].summary, 'Scheduler refactored.', 'matched entry should get summary');
+    // Original fields preserved
+    assert.equal(enriched[0].prompt, 'Refactor the scheduler');
+    assert.equal(enriched[0].cwd, cwd);
+
+    // Second entry has no match — returned unchanged (no result/summary)
+    assert.equal(enriched[1].result, undefined, 'unmatched entry should not get result');
+    assert.equal(enriched[1].summary, undefined, 'unmatched entry should not get summary');
+    assert.equal(enriched[1].prompt, 'Unrelated prompt');
+  });
+
+  test('falls back to prompt-only when exchange index is empty (missing file)', async () => {
+    const { loadExchangeIndex, enrichEntries } = freshRequire(PAIRING_MOD);
+    // Point at a directory that doesn't exist
+    const idx = await loadExchangeIndex(path.join(tmpDir, 'nonexistent'), '/some/cwd');
+    assert.equal(idx.size, 0);
+
+    const entries = [
+      { ts: '2026-06-25T00:00:00Z', session_id: 'sx', cwd: '/some/cwd', prompt: 'Do something' },
+    ];
+    const enriched = enrichEntries(entries, idx);
+    // Entry returned unchanged — no crash
+    assert.equal(enriched.length, 1);
+    assert.equal(enriched[0].prompt, 'Do something');
+    assert.equal(enriched[0].result, undefined);
+    assert.equal(enriched[0].summary, undefined);
+  });
+
+  test('whitespace-tolerant matching (trailing newline in one source)', async () => {
+    const { loadExchangeIndex, enrichEntries } = freshRequire(PAIRING_MOD);
+    const exchangesDir = path.join(tmpDir, 'ws-tolerant');
+    const cwd = '/home/user/wstol';
+
+    // Exchange record has trailing whitespace/newline in prompt
+    await writeExchangeFile(exchangesDir, cwd, [
+      { ts: '2026-06-25T00:00:00Z', sessionId: 's1', cwd, prompt: '  Build the widget  \n', result: 'Widget built.', summary: 'Widget.' },
+    ]);
+
+    const idx = await loadExchangeIndex(exchangesDir, cwd);
+
+    // Prompt log entry has clean text — should still match after normalization
+    const entries = [{ ts: '2026-06-25T00:00:01Z', session_id: 's1', cwd, prompt: 'Build the widget' }];
+    const enriched = enrichEntries(entries, idx);
+    assert.equal(enriched[0].result, 'Widget built.', 'should match despite whitespace differences');
+  });
+});

package/src/main/__tests__/memoryAggregate.test.cjs

@@ -0,0 +1,70 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { parseClusters } = require('../memoryAggregate.cjs');
+
+test('parseClusters maps well-formed JSON to the result shape and routes unlisted slugs to orphans', () => {
+  const slugs = ['scheduler_concurrency_memory', 'no_schedule_self_e2e', 'unrelated_note'];
+  const raw = JSON.stringify({
+    clusters: [
+      {
+        name: 'Scheduler ops',
+        summary: 'Scheduler concurrency + e2e isolation rules.',
+        memberSlugs: ['scheduler_concurrency_memory', 'no_schedule_self_e2e'],
+        links: [{ from: 'scheduler_concurrency_memory', to: 'no_schedule_self_e2e', label: 'related' }],
+      },
+    ],
+    orphans: ['unrelated_note'],
+  });
+
+  const result = parseClusters(raw, slugs);
+
+  assert.equal(result.clusters.length, 1);
+  assert.equal(result.clusters[0].name, 'Scheduler ops');
+  assert.deepEqual(result.clusters[0].memberSlugs, ['scheduler_concurrency_memory', 'no_schedule_self_e2e']);
+  assert.deepEqual(result.clusters[0].links, [{ from: 'scheduler_concurrency_memory', to: 'no_schedule_self_e2e', label: 'related' }]);
+  assert.deepEqual(result.orphans, ['unrelated_note']);
+});
+
+test('parseClusters routes a slug omitted from the response to orphans even without explicit listing', () => {
+  const slugs = ['a', 'b', 'c'];
+  const raw = JSON.stringify({
+    clusters: [{ name: 'Cluster A', summary: 's', memberSlugs: ['a'], links: [] }],
+  });
+
+  const result = parseClusters(raw, slugs);
+
+  assert.deepEqual(result.orphans.sort(), ['b', 'c']);
+});
+
+test('parseClusters returns empty clusters and all slugs as orphans on garbage LLM output', () => {
+  const slugs = ['one', 'two', 'three'];
+  const result = parseClusters('not json at all, just prose garbage', slugs);
+
+  assert.deepEqual(result.clusters, []);
+  assert.deepEqual(result.orphans, slugs);
+});
+
+test('parseClusters is robust to empty/null input', () => {
+  const slugs = ['x'];
+  assert.deepEqual(parseClusters('', slugs), { clusters: [], orphans: ['x'] });
+  assert.deepEqual(parseClusters(null, slugs), { clusters: [], orphans: ['x'] });
+});
+
+test('parseClusters drops link endpoints and members that reference nonexistent slugs', () => {
+  const slugs = ['known'];
+  const raw = JSON.stringify({
+    clusters: [{
+      name: 'C',
+      summary: 's',
+      memberSlugs: ['known', 'ghost'],
+      links: [{ from: 'known', to: 'ghost' }],
+    }],
+  });
+
+  const result = parseClusters(raw, slugs);
+  assert.deepEqual(result.clusters[0].memberSlugs, ['known']);
+  assert.deepEqual(result.clusters[0].links, []);
+  assert.deepEqual(result.orphans, []);
+});

package/src/main/agentMemory.cjs

@@ -228,33 +228,12 @@ async function deleteEntry({ agentId, entryId }) {
   }
 }
 
-async function listAgents() {
-  try {
-    await ensureRoot();
-    const dir = rootDir();
-    const r = await config.listDir(dir, { filesOnly: true });
-    if (!r.ok) return { agents: [], error: r.error };
-    const agents = r.entries
-      .filter((e) => e.name.endsWith('.json'))
-      .map((e) => ({
-        agentId: e.name.replace(/\.json$/, ''),
-        bytes: e.size,
-        mtimeMs: e.mtimeMs,
-      }))
-      .sort((a, b) => a.agentId.localeCompare(b.agentId));
-    return { agents, error: null };
-  } catch (e) {
-    return { agents: [], error: e.message };
-  }
-}
-
 function registerAgentMemoryHandlers() {
   const { schemas: s, validated: v } = require('./ipcSchemas.cjs');
   ipcMain.handle('agent-memory:list', v(s.agentMemoryList, list));
   ipcMain.handle('agent-memory:get', v(s.agentMemoryGet, get));
   ipcMain.handle('agent-memory:set', v(s.agentMemorySet, set));
   ipcMain.handle('agent-memory:delete', v(s.agentMemoryDelete, deleteEntry));
-  ipcMain.handle('agent-memory:list-agents', () => listAgents());
 }
 
 module.exports = {