claude-code-session-manager 0.97.0 → 0.100.0

package/src/main/lib/__tests__/cwdClassify.test.cjs

@@ -1,111 +0,0 @@
-// cwdClassify.cjs — one classifier for "what project is this path", failing
-// CLOSED on the unprovable worktree case. Fixtures live under a per-run
-// mkdtemp sandbox, never the live roots.
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { classifyCwd, nearestGitEntry, worktreeMainRootOf } = require('../cwdClassify.cjs');
-const { assertOpsWrite, resolveOpsRoot } = require('../opsOwnership.cjs');
-const { isEphemeralCwd } = require('../ephemeralCwd.cjs');
-const { projectRootOf } = require('../activeSessions.cjs');
-
-const OPS = 'session-manager-operations';
-let sandbox;
-const real = (p) => fs.realpathSync(p);
-
-beforeEach(() => { sandbox = real(fs.mkdtempSync(path.join(os.tmpdir(), 'sm-cwdclassify-'))); });
-afterEach(() => { fs.rmSync(sandbox, { recursive: true, force: true }); });
-
-function mkWorktree({ backRef = true } = {}) {
-  const main = path.join(sandbox, 'main');
-  const wt = path.join(sandbox, 'wt');
-  const admin = path.join(main, '.git', 'worktrees', 'wt1');
-  fs.mkdirSync(admin, { recursive: true });
-  fs.mkdirSync(wt, { recursive: true });
-  fs.writeFileSync(path.join(wt, '.git'), `gitdir: ${admin}\n`);
-  if (backRef) fs.writeFileSync(path.join(admin, 'gitdir'), `${path.join(wt, '.git')}\n`);
-  return { main, wt };
-}
-
-test('healthy worktree → worktree, projectRoot is the main tree', () => {
-  const { main, wt } = mkWorktree();
-  const c = classifyCwd(wt);
-  assert.equal(c.kind, 'worktree');
-  assert.equal(c.projectRoot, main);
-  assert.equal(projectRootOf(wt), main);
-  assert.equal(isEphemeralCwd(wt), true);
-  assert.equal(worktreeMainRootOf(wt), main);
-});
-
-test('broken back-reference → unknown; ops writes refused, resolution and dispatch stay open', () => {
-  const { wt } = mkWorktree({ backRef: false });
-  const c = classifyCwd(wt);
-  assert.equal(c.kind, 'unknown');
-  assert.equal(c.projectRoot, wt);
-  assert.match(c.reason, /back-reference/);
-  assert.equal(projectRootOf(wt), wt); // total — never throws
-  assert.equal(resolveOpsRoot(wt), path.join(wt, OPS)); // reads/dispatch unaffected
-  assert.throws(
-    () => assertOpsWrite(path.join(wt, OPS, 'scheduler', 'state', 'queue.json'), 'scheduler'),
-    (e) => e.unknownCwd === true && /back-reference/.test(e.message),
-  );
-});
-
-test('garbled .git file → unknown', () => {
-  const dir = path.join(sandbox, 'garbled');
-  fs.mkdirSync(dir);
-  fs.writeFileSync(path.join(dir, '.git'), 'not a pointer\n');
-  assert.equal(classifyCwd(dir).kind, 'unknown');
-});
-
-test('separate-git-dir → project (gitdir not under worktrees/)', () => {
-  const dir = path.join(sandbox, 'sep');
-  fs.mkdirSync(dir);
-  fs.writeFileSync(path.join(dir, '.git'), `gitdir: ${path.join(sandbox, 'elsewhere.git')}\n`);
-  const c = classifyCwd(dir);
-  assert.equal(c.kind, 'project');
-  assert.equal(c.projectRoot, dir);
-  assert.doesNotThrow(() => assertOpsWrite(path.join(dir, OPS, 'scheduler', 'state', 'queue.json'), 'scheduler'));
-});
-
-test('submodule (relative gitdir) → project rooted at the submodule', () => {
-  const sup = path.join(sandbox, 'super');
-  const sub = path.join(sup, 'libs', 'sub');
-  fs.mkdirSync(path.join(sup, '.git', 'modules', 'sub'), { recursive: true });
-  fs.mkdirSync(path.join(sub, 'src'), { recursive: true });
-  fs.writeFileSync(path.join(sub, '.git'), 'gitdir: ../../.git/modules/sub\n');
-  const c = classifyCwd(path.join(sub, 'src'));
-  assert.equal(c.kind, 'project');
-  assert.equal(c.projectRoot, sub);
-});
-
-test('plain project (.git dir, and no git at all) → project', () => {
-  const proj = path.join(sandbox, 'proj');
-  fs.mkdirSync(path.join(proj, '.git'), { recursive: true });
-  fs.mkdirSync(path.join(proj, 'src'));
-  assert.deepEqual(
-    { k: classifyCwd(path.join(proj, 'src')).kind, r: classifyCwd(path.join(proj, 'src')).projectRoot },
-    { k: 'project', r: proj },
-  );
-  const bare = path.join(sandbox, 'nogit');
-  fs.mkdirSync(bare);
-  assert.equal(classifyCwd(bare).projectRoot, bare);
-  assert.equal(nearestGitEntry(bare), null);
-});
-
-test('nested ops root: outermost (indexOf) and innermost (lastIndexOf) are both reported, neither unified', () => {
-  const proj = path.join(sandbox, 'proj');
-  fs.mkdirSync(path.join(proj, '.git'), { recursive: true });
-  const nested = path.join(proj, OPS, 'scheduler', 'prds', OPS, 'scheduler', 'state');
-  const c = classifyCwd(nested);
-  assert.equal(c.projectRoot, proj);
-  assert.equal(c.outermostOpsRoot, path.join(proj, OPS));
-  assert.equal(c.innermostOpsRoot, path.join(proj, OPS, 'scheduler', 'prds', OPS));
-  assert.equal(classifyCwd(proj).outermostOpsRoot, null);
-});
-
-test('ephemeral: os.tmpdir() itself', () => {
-  assert.equal(classifyCwd(path.resolve(os.tmpdir())).kind, 'ephemeral');
-  assert.equal(isEphemeralCwd(os.tmpdir()), true);
-});

package/src/main/lib/__tests__/definitionOfDoneSequence.test.cjs

@@ -1,95 +0,0 @@
-/**
- * definitionOfDoneSequence.test.cjs — extractAcSequence / resolveGate parsing
- * matrix plus real gate lines lifted from archived PRDs (gateFixtures.json).
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/definitionOfDoneSequence.test.cjs
- */
-'use strict';
-
-const assert = require('node:assert/strict');
-const { extractAcSequence, extractAcCommand, resolveGate } = require('../definitionOfDone.cjs');
-const fixtures = require('./gateFixtures.json');
-
-const ac = (...lines) => ['# Acceptance criteria', '', ...lines, '', '# Out of scope', ''].join('\n');
-const argvs = (seq) => seq.map((c) => c.argv);
-
-test('splits a && chain, honouring a leading timeout N per command', () => {
-  const seq = extractAcSequence(ac('- [ ] Gate: `timeout 300 npm run typecheck && timeout 60 npm run lint`'));
-  assert.deepEqual(argvs(seq), [['npm', 'run', 'typecheck'], ['npm', 'run', 'lint']]);
-  assert.deepEqual(seq.map((c) => c.timeoutMs), [300_000, 60_000]);
-});
-
-test('a command with no timeout token gets the default timeout', () => {
-  const seq = extractAcSequence(ac('- [ ] `timeout 5 npm run a && npm run b`'));
-  assert.equal(seq[0].timeoutMs, 5_000);
-  assert.equal(seq[1].timeoutMs, 300_000);
-});
-
-test('&& inside quotes is never a split point', () => {
-  const seq = extractAcSequence(ac('- [ ] `timeout 30 node -e "a && b" && timeout 30 echo \'x && y\'`'));
-  assert.deepEqual(argvs(seq), [['node', '-e', 'a && b'], ['echo', 'x && y']]);
-});
-
-test('a leading TMPDIR=$(mktemp -d) is dropped, other literal env is kept', () => {
-  const seq = extractAcSequence(ac('- [ ] `TMPDIR=$(mktemp -d) timeout 900 npm run test:unit && FOO=bar timeout 10 npm run x`'));
-  assert.deepEqual(argvs(seq), [['npm', 'run', 'test:unit'], ['npm', 'run', 'x']]);
-  assert.deepEqual(seq[0].env, {});
-  assert.deepEqual(seq[1].env, { FOO: 'bar' });
-});
-
-test('any surviving shell metacharacter makes the whole gate unparseable (no shell)', () => {
-  for (const bad of [
-    '`timeout 60 npm run a | tail -5`', '`timeout 60 npm run a > out.txt`', '`timeout 60 npm run a; rm x`',
-    '`timeout 60 npm run a & echo`', '`timeout 60 echo $(whoami)`', '`timeout 60 npm run a && timeout 60 npm run b || true`',
-  ]) {
-    assert.deepEqual(extractAcSequence(ac(`- [ ] ${bad}`)), [], bad);
-  }
-});
-
-test('an empty segment (dangling &&) is unparseable', () => {
-  assert.deepEqual(extractAcSequence(ac('- [ ] `timeout 60 npm run a &&`')), []);
-});
-
-test('frontmatter gate: list takes priority over the AC line', () => {
-  const text = '---\ntitle: t\ngate:\n  - timeout 10 npm run one\n  - "timeout 20 npm run two && timeout 30 npm run three"\n---\n' +
-    ac('- [ ] `timeout 999 npm run ignored`');
-  const g = resolveGate(text);
-  assert.equal(g.source, 'explicit');
-  assert.deepEqual(argvs(g.sequence), [['npm', 'run', 'one'], ['npm', 'run', 'two'], ['npm', 'run', 'three']]);
-});
-
-test('frontmatter inline gate list', () => {
-  const g = resolveGate('---\ngate: [timeout 10 npm run one, timeout 20 npm run two]\n---\nbody');
-  assert.deepEqual(argvs(g.sequence), [['npm', 'run', 'one'], ['npm', 'run', 'two']]);
-});
-
-test('a fenced ```gate block takes priority', () => {
-  const text = ac('- [ ] `timeout 999 npm run ignored`', '', '```gate', 'timeout 10 npm run a && timeout 20 npm run b', '```');
-  const g = resolveGate(text);
-  assert.equal(g.source, 'explicit');
-  assert.deepEqual(argvs(g.sequence), [['npm', 'run', 'a'], ['npm', 'run', 'b']]);
-});
-
-test('gate: none is an explicit opt-out, distinct from absent', () => {
-  const none = resolveGate('---\ngate: none\n---\n' + ac('- [ ] `timeout 60 npm test`'));
-  assert.equal(none.source, 'none');
-  assert.deepEqual(none.sequence, []);
-  assert.equal(resolveGate(ac('- [ ] prose only')).source, 'absent');
-});
-
-test('extractAcCommand delegates: single command → original string, chain → null', () => {
-  assert.equal(extractAcCommand(ac('- [ ] `timeout 60 npm test`')), 'timeout 60 npm test');
-  assert.equal(extractAcCommand(ac('- [ ] `timeout 60 npm a && timeout 60 npm b`')), null);
-});
-
-test('real archived gate lines: count how many now parse', () => {
-  const parsed = fixtures.filter((line) => extractAcSequence(ac(line)).length > 0);
-  console.log(`[gate-fixtures] ${parsed.length}/${fixtures.length} real gate lines now parse`);
-  const chains = fixtures.filter((l) => l.includes('&&') && /^- \[ \] (Gate|Locally)/.test(l));
-  for (const line of chains) assert.ok(extractAcSequence(ac(line)).length >= 2, line);
-  // The three deliberately un-runnable fixtures (shell loop, pipe, prose) stay empty.
-  const unparseable = fixtures.filter((l) => /for i in|\| tail|Prose only/.test(l));
-  assert.equal(unparseable.length, 3);
-  for (const line of unparseable) assert.deepEqual(extractAcSequence(ac(line)), [], line);
-  assert.equal(parsed.length, fixtures.length - 3);
-});