claude-code-session-manager 0.97.0 → 0.100.0

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

@@ -1,201 +0,0 @@
-/**
- * classifyTranscriptLine.test.cjs — unit tests for src/main/lib/classifyTranscriptLine.cjs.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/classifyTranscriptLine.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-
-const {
-  classifyLine,
-  trimContentArray,
-  makeRaw,
-  buildPreviewText,
-  MAX_RAW_STR,
-  PREVIEW_CHARS,
-  EXEMPT_TYPES,
-} = require('../lib/classifyTranscriptLine.cjs');
-
-test('classifyLine returns [] for non-object input', () => {
-  expect(classifyLine(null)).toEqual([]);
-  expect(classifyLine('not an object')).toEqual([]);
-});
-
-test('classifyLine tags usage events', () => {
-  const [ev] = classifyLine({ usage: { input_tokens: 10, output_tokens: 5 } });
-  expect(ev.kind).toBe('usage');
-  expect(ev.data).toEqual({ input_tokens: 10, output_tokens: 5 });
-});
-
-test('classifyLine tags TodoWrite tool_use as todo_write', () => {
-  const [ev] = classifyLine({
-    message: { content: [{ type: 'tool_use', name: 'TodoWrite', input: { todos: [{ content: 'x' }] } }] },
-  });
-  expect(ev.kind).toBe('todo_write');
-  expect(ev.data).toEqual([{ content: 'x' }]);
-});
-
-test('classifyLine tags ExitPlanMode as plan', () => {
-  const [ev] = classifyLine({
-    message: { content: [{ type: 'tool_use', name: 'ExitPlanMode', input: { plan: 'do things' } }] },
-  });
-  expect(ev.kind).toBe('plan');
-});
-
-test('classifyLine tags Agent/Task tool_use as agent_spawn with toolUseId', () => {
-  const [ev] = classifyLine({
-    message: { content: [{ type: 'tool_use', name: 'Agent', id: 'tool-1', input: { description: 'do work' } }] },
-  });
-  expect(ev.kind).toBe('agent_spawn');
-  expect(ev.data.toolUseId).toBe('tool-1');
-});
-
-test('classifyLine tags generic tool_use blocks', () => {
-  const [ev] = classifyLine({
-    message: { content: [{ type: 'tool_use', name: 'Bash', id: 'tool-2', input: { command: 'ls' } }] },
-  });
-  expect(ev.kind).toBe('tool_use');
-  expect(ev.data).toEqual({ name: 'Bash', input: { command: 'ls' }, id: 'tool-2' });
-});
-
-test('classifyLine tags tool_result blocks with toolUseId', () => {
-  const [ev] = classifyLine({
-    message: { content: [{ type: 'tool_result', tool_use_id: 'tool-1' }] },
-  });
-  expect(ev.kind).toBe('tool_result');
-  expect(ev.data).toEqual({ toolUseId: 'tool-1' });
-});
-
-test('classifyLine falls back to message kind for non-array content', () => {
-  const [ev] = classifyLine({ type: 'assistant', message: { content: 'hello' } });
-  expect(ev.kind).toBe('assistant');
-});
-
-test('CORE: a content array of [text, tool_use, tool_use] emits exactly 3 events, not 1', () => {
-  const events = classifyLine({
-    type: 'assistant',
-    message: {
-      content: [
-        { type: 'text', text: 'doing two things' },
-        { type: 'tool_use', name: 'Bash', id: 'tu-1', input: { command: 'ls' } },
-        { type: 'tool_use', name: 'Bash', id: 'tu-2', input: { command: 'pwd' } },
-      ],
-    },
-  });
-  expect(events).toHaveLength(3);
-  expect(events[0].kind).toBe('assistant'); // text block inherits the message's own type
-  expect(events[0].data).toBe('doing two things');
-  expect(events[1].kind).toBe('tool_use');
-  expect(events[1].data.id).toBe('tu-1');
-  expect(events[2].kind).toBe('tool_use');
-  expect(events[2].data.id).toBe('tu-2');
-});
-
-test('CORE: a message carrying both usage AND non-empty content emits the usage event AND the content event(s)', () => {
-  const events = classifyLine({
-    type: 'assistant',
-    usage: { input_tokens: 100, output_tokens: 40 },
-    message: { content: [{ type: 'text', text: 'hello' }] },
-  });
-  expect(events).toHaveLength(2);
-  expect(events.map((e) => e.kind).sort()).toEqual(['assistant', 'usage']);
-  const usageEv = events.find((e) => e.kind === 'usage');
-  expect(usageEv.data).toEqual({ input_tokens: 100, output_tokens: 40 });
-  const textEv = events.find((e) => e.kind === 'assistant');
-  expect(textEv.data).toBe('hello');
-});
-
-test('unknown/future content block types are surfaced, not dropped', () => {
-  const events = classifyLine({
-    type: 'assistant',
-    message: { content: [{ type: 'server_tool_use', id: 'x', input: {} }] },
-  });
-  expect(events).toHaveLength(1);
-  expect(events[0].kind).toBe('content_server_tool_use');
-  expect(events[0].data).toEqual({ type: 'server_tool_use', id: 'x', input: {} });
-});
-
-test('trimContentArray passes through non-array input', () => {
-  expect(trimContentArray('not-an-array')).toBe('not-an-array');
-});
-
-test('trimContentArray truncates long text fields past MAX_RAW_STR', () => {
-  const longText = 'a'.repeat(MAX_RAW_STR + 100);
-  const [block] = trimContentArray([{ type: 'text', text: longText }]);
-  expect(block.text.length).toBe(MAX_RAW_STR + 1);
-  expect(block.text.endsWith('…')).toBe(true);
-});
-
-test('trimContentArray now trims tool_use/tool_result blocks too (EXEMPT_TYPES is empty — orchestrator.ts/race.ts, the sole prior consumers, were deleted 2026-07-30)', () => {
-  expect(EXEMPT_TYPES.size).toBe(0);
-  const longText = 'a'.repeat(MAX_RAW_STR + 100);
-  const [block] = trimContentArray([{ type: 'tool_use', text: longText }]);
-  expect(block.text.length).toBe(MAX_RAW_STR + 1);
-  expect(block.text.endsWith('…')).toBe(true);
-});
-
-test('makeRaw builds a projection from message content', () => {
-  const raw = makeRaw({ message: { content: [{ type: 'text', text: 'hi' }] } });
-  expect(raw.message.content).toEqual([{ type: 'text', text: 'hi' }]);
-});
-
-test('CORE: makeRaw preserves every top-level field on the line, not just message.content', () => {
-  const line = {
-    type: 'assistant',
-    message: { content: [{ type: 'text', text: 'hi' }] },
-    attributionSkill: 'develop',
-    attributionPlugin: 'session-manager-dev',
-    attributionMcpServer: 'some-server',
-    attributionMcpTool: 'some_tool',
-    effort: 'high',
-    gitBranch: 'main',
-    isSidechain: false,
-    isMeta: true,
-    requestId: 'req-123',
-    isApiErrorMessage: false,
-    interruptedByShutdown: false,
-    permissionMode: 'default',
-    promptSource: 'user',
-    toolUseResult: { ok: true },
-  };
-  const raw = makeRaw(line);
-  for (const key of [
-    'attributionSkill',
-    'attributionPlugin',
-    'attributionMcpServer',
-    'attributionMcpTool',
-    'effort',
-    'gitBranch',
-    'isSidechain',
-    'isMeta',
-    'requestId',
-    'isApiErrorMessage',
-    'interruptedByShutdown',
-    'permissionMode',
-    'promptSource',
-    'toolUseResult',
-  ]) {
-    expect(raw[key]).toEqual(line[key]);
-  }
-});
-
-test('CORE: every event carries a bounded previewText and, when a ref is passed, the ref survives untouched', () => {
-  const ref = { filePath: '/tmp/fake.jsonl', byteOffset: 128, byteLength: 64 };
-  const [ev] = classifyLine({ type: 'user', message: { content: 'a'.repeat(PREVIEW_CHARS + 500) } }, ref);
-  expect(ev.ref).toEqual(ref);
-  expect(ev.previewText.length).toBeLessThanOrEqual(PREVIEW_CHARS + 1);
-  expect(ev.previewText.endsWith('…')).toBe(true);
-});
-
-test('classifyLine omits ref (null) when the caller has no file context', () => {
-  const [ev] = classifyLine({ usage: { input_tokens: 1, output_tokens: 1 } });
-  expect(ev.ref).toBeNull();
-});
-
-test('buildPreviewText caps at PREVIEW_CHARS', () => {
-  const s = buildPreviewText('x'.repeat(PREVIEW_CHARS + 50));
-  expect(s.length).toBe(PREVIEW_CHARS + 1);
-  expect(s.endsWith('…')).toBe(true);
-});

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

@@ -1,66 +0,0 @@
-// PRD 1122 — scheduler.cjs's computeDepHistorySatisfaction: the once-per-tick
-// history/archive lookup that findBlockingDep consults for a dependsOn slug
-// with no live queue row.
-import { describe, it, expect } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-1122-home-'));
-process.env.HOME = tmpHome;
-
-const scheduler = require('../scheduler.cjs');
-const queueHistory = require('../lib/queueHistory.cjs');
-const { DEP_HISTORY_FAIL_OPEN } = require('../lib/schedulerBatch.cjs');
-
-function tmpProjectCwd(prefix) {
-  return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-}
-
-describe('computeDepHistorySatisfaction', () => {
-  it('includes a slug completed in this project\'s history shard', async () => {
-    const cwd = tmpProjectCwd('sm-1122-hist-');
-    await queueHistory.appendHistory([
-      { slug: '900-base', status: 'completed', runId: 'r1', finishedAt: new Date().toISOString(), cwd },
-    ]);
-    const state = { jobs: [{ slug: '901-next', status: 'pending', cwd, dependsOn: ['900-base'] }] };
-    const byCwd = await scheduler.computeDepHistorySatisfaction(state);
-    expect(byCwd.get(cwd).has('900-base')).toBe(true);
-  });
-
-  it('includes a slug found only under prds-archived/', async () => {
-    const cwd = tmpProjectCwd('sm-1122-arch-');
-    const archiveDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'prds-archived');
-    fs.mkdirSync(archiveDir, { recursive: true });
-    fs.writeFileSync(path.join(archiveDir, '900-base.md'), '---\ntitle: x\n---\n# Goal\n');
-    const state = { jobs: [{ slug: '901-next', status: 'pending', cwd, dependsOn: ['900-base'] }] };
-    const byCwd = await scheduler.computeDepHistorySatisfaction(state);
-    expect(byCwd.get(cwd).has('900-base')).toBe(true);
-  });
-
-  it('a slug in neither history nor archive is absent from the satisfied set', async () => {
-    const cwd = tmpProjectCwd('sm-1122-none-');
-    const state = { jobs: [{ slug: '901-next', status: 'pending', cwd, dependsOn: ['900-base'] }] };
-    const byCwd = await scheduler.computeDepHistorySatisfaction(state);
-    expect(byCwd.get(cwd).has('900-base')).toBe(false);
-  });
-
-  it('degrades to DEP_HISTORY_FAIL_OPEN for one project on a read failure, without throwing', async () => {
-    // A relative cwd makes projectHistoryPath (via completedSlugsForCwd)
-    // throw synchronously rather than ENOENT — the read-failure path, not
-    // the "no history yet" path.
-    const badCwd = 'relative/not-a-project-root';
-    const goodCwd = tmpProjectCwd('sm-1122-good-');
-    const state = {
-      jobs: [
-        { slug: '901-next', status: 'pending', cwd: badCwd, dependsOn: ['900-base'] },
-        { slug: '801-next', status: 'pending', cwd: goodCwd, dependsOn: ['800-base'] },
-      ],
-    };
-    const byCwd = await scheduler.computeDepHistorySatisfaction(state);
-    expect(byCwd.get(badCwd)).toBe(DEP_HISTORY_FAIL_OPEN);
-    // The other project's lookup is unaffected by the first one's failure.
-    expect(byCwd.get(goodCwd)).not.toBe(DEP_HISTORY_FAIL_OPEN);
-    expect(byCwd.get(goodCwd).has('800-base')).toBe(false);
-  });
-});

package/src/main/__tests__/config-readText-bounded.test.cjs

@@ -1,84 +0,0 @@
-/**
- * config-readText-bounded.test.cjs — readText's optional { maxBytes } bounded
- * prefix read. Regression coverage for perf-known-projects-bounded-cwd-read:
- * resolveProjectCwd used to read whole (sometimes multi-MB) transcript files
- * just to find the first line containing "cwd".
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/config-readText-bounded.test.cjs
- */
-
-'use strict';
-
-import { test, expect, afterEach } from 'vitest';
-const fsp = require('node:fs/promises');
-const os = require('node:os');
-const path = require('node:path');
-const config = require('../config.cjs');
-
-const tmpDirs = [];
-afterEach(async () => {
-  while (tmpDirs.length) {
-    const d = tmpDirs.pop();
-    await fsp.rm(d, { recursive: true, force: true });
-  }
-});
-
-async function mkTmpFile(name, content) {
-  const dir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-readtext-'));
-  config.addAllowedRoot(dir);
-  tmpDirs.push(dir);
-  const abs = path.join(dir, name);
-  await fsp.writeFile(abs, content, 'utf8');
-  return abs;
-}
-
-test('bounded read returns only the requested prefix and sets truncated', async () => {
-  const lines = Array.from({ length: 2000 }, (_, i) => `{"line":${i},"pad":"${'x'.repeat(50)}"}`).join('\n') + '\n';
-  const abs = await mkTmpFile('big.jsonl', lines);
-  const full = await config.readText(abs);
-  expect(full.truncated).toBe(false);
-
-  const bounded = await config.readText(abs, { maxBytes: 1024 });
-  expect(bounded.exists).toBe(true);
-  expect(bounded.truncated).toBe(true);
-  expect(bounded.text.length).toBeLessThan(full.text.length);
-  expect(Buffer.byteLength(bounded.text, 'utf8')).toBeLessThanOrEqual(1024);
-  // every line handed back must be a complete, parseable JSON line — no
-  // partial trailing fragment from the byte cut.
-  const returnedLines = bounded.text.split('\n').filter(Boolean);
-  for (const line of returnedLines) {
-    expect(() => JSON.parse(line)).not.toThrow();
-  }
-});
-
-test('unbounded read (no opts) is byte-identical to before', async () => {
-  const content = 'line one\nline two\nline three\n';
-  const abs = await mkTmpFile('plain.txt', content);
-  const r = await config.readText(abs);
-  expect(r.exists).toBe(true);
-  expect(r.text).toBe(content);
-  expect(r.truncated).toBe(false);
-  expect(typeof r.mtimeMs).toBe('number');
-  expect(r.error).toBe(null);
-});
-
-test('maxBytes larger than the file returns the whole file with truncated=false', async () => {
-  const content = 'short file\ncontent here\n';
-  const abs = await mkTmpFile('small.txt', content);
-  const r = await config.readText(abs, { maxBytes: 1024 * 1024 });
-  expect(r.exists).toBe(true);
-  expect(r.text).toBe(content);
-  expect(r.truncated).toBe(false);
-});
-
-test('bounded read on a missing file behaves like the unbounded case', async () => {
-  const dir = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-readtext-missing-'));
-  config.addAllowedRoot(dir);
-  tmpDirs.push(dir);
-  const abs = path.join(dir, 'nope.txt');
-  const r = await config.readText(abs, { maxBytes: 1024 });
-  expect(r.exists).toBe(false);
-  expect(r.text).toBe('');
-  expect(r.truncated).toBe(false);
-  expect(r.error).toBe(null);
-});

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

@@ -1,59 +0,0 @@
-/**
- * configWriteBoundaryOwners.test.cjs — validateWrite's ops-subtree exemption
- * (config.cjs ~line 166) must derive its writable-namespace list from
- * opsOwnership.cjs's OWNERS map, not a separately hand-maintained array. PRD
- * 1398 declared 'ui-prefs' owned in OWNERS but config.cjs's own array was
- * never updated, so every real ui-prefs write threw "Write outside allowed
- * write boundaries" before assertOpsWrite's per-writer check ever ran (PRD
- * 1410). This test exercises the REAL validateWrite (via writeJson) for
- * every OWNERS namespace so that class of drift can never reoccur silently.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/configWriteBoundaryOwners.test.cjs
- */
-
-'use strict';
-
-import { test, expect, afterEach } from 'vitest';
-const fs = require('node:fs');
-const fsp = require('node:fs/promises');
-const os = require('node:os');
-const path = require('node:path');
-const config = require('../config.cjs');
-const { OWNERS } = require('../lib/opsOwnership.cjs');
-
-// Real-homedir-rooted (not os.tmpdir()) so the fixture root is classified as
-// a plain project, not an ephemeral cwd — opsPath() throws for roots under
-// os.tmpdir(), which would make every namespace's exemption silently
-// evaporate (opsSubs = []) and the test would pass for the wrong reason. Same
-// pattern as prdCreate.test.cjs's real-homedir-rooted tests.
-const roots = [];
-afterEach(async () => {
-  while (roots.length) {
-    const r = roots.pop();
-    await fsp.rm(r, { recursive: true, force: true });
-  }
-});
-
-async function mkProjectRoot(tag) {
-  const root = await fsp.mkdtemp(path.join(os.homedir(), `.sm-configwriteboundary-${tag}-`));
-  config.addAllowedRoot(root);
-  roots.push(root);
-  return root;
-}
-
-for (const [namespace, owner] of Object.entries(OWNERS)) {
-  test(`OWNERS namespace '${namespace}' is writable by its declared owner '${owner}'`, async () => {
-    const root = await mkProjectRoot(namespace);
-    const target = path.join(root, 'session-manager-operations', namespace, 'probe.json');
-    const result = await config.writeJson(target, { probe: 1 }, { writer: owner });
-    expect(result.ok).toBe(true);
-    expect(fs.existsSync(target)).toBe(true);
-  });
-}
-
-test('a namespace not declared in OWNERS is still rejected', async () => {
-  const root = await mkProjectRoot('undeclared');
-  const target = path.join(root, 'session-manager-operations', 'not-a-real-namespace', 'probe.json');
-  await expect(config.writeJson(target, { probe: 1 }, { writer: 'anyone' }))
-    .rejects.toThrow(/Write outside allowed write boundaries/);
-});