kenaz 0.3.3 → 0.3.5

package/core/.formation/tools/headless-branch-recovery.test.js

@@ -1,64 +0,0 @@
-'use strict';
-// TASK_2243: pre-dispatch branch recovery must never move a user's branch or drop edits.
-// All git runs in throwaway repos under os.tmpdir() -- never against the real repo.
-const { test } = require('node:test');
-const assert = require('node:assert/strict');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { execFileSync } = require('child_process');
-const { recoverStaleDispatchBranch } = require('./headless');
-
-function git(cwd, ...args) {
-  return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: 'pipe', windowsHide: true }).trim();
-}
-
-// main has a.txt; <branch> has a commit changing a.txt (so a dirty edit conflicts with main).
-function makeRepo(t, branch) {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'recover-branch-'));
-  t.after(() => { try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* best effort */ } });
-  git(dir, 'init', '--initial-branch=main');
-  git(dir, 'config', 'user.email', 't@example.com');
-  git(dir, 'config', 'user.name', 't');
-  fs.writeFileSync(path.join(dir, 'a.txt'), 'base\n');
-  git(dir, 'add', '.');
-  git(dir, 'commit', '-m', 'base');
-  git(dir, 'checkout', '-b', branch);
-  fs.writeFileSync(path.join(dir, 'a.txt'), 'branch work\n');
-  git(dir, 'commit', '-am', 'branch work');
-  return dir;
-}
-
-const quiet = { log() {}, lockFile: path.join(os.tmpdir(), 'no-such-dispatch-lock-' + process.pid) };
-const run = (dir) => recoverStaleDispatchBranch(dir, {
-  ...quiet, currentBranch: git(dir, 'rev-parse', '--abbrev-ref', 'HEAD'), targetBranch: 'main',
-});
-const head = (dir) => git(dir, 'rev-parse', '--abbrev-ref', 'HEAD');
-
-test('(a) user branch task/600-foo is left alone', (t) => {
-  const dir = makeRepo(t, 'task/600-foo');
-  run(dir);
-  assert.equal(head(dir), 'task/600-foo');
-});
-
-test('(b) dirty tree on task/task_123 keeps edits and branch', (t) => {
-  const dir = makeRepo(t, 'task/task_123');
-  fs.writeFileSync(path.join(dir, 'a.txt'), 'uncommitted edit\n');
-  run(dir);
-  assert.equal(head(dir), 'task/task_123');
-  assert.equal(fs.readFileSync(path.join(dir, 'a.txt'), 'utf8'), 'uncommitted edit\n');
-});
-
-test('(c) control: clean stale task/task_123 is recovered to main', (t) => {
-  const dir = makeRepo(t, 'task/task_123');
-  run(dir);
-  assert.equal(head(dir), 'main');
-});
-
-test('live dispatch lock for the same card blocks recovery', (t) => {
-  const dir = makeRepo(t, 'task/task_123');
-  const lockFile = path.join(dir, 'lock.json');
-  fs.writeFileSync(lockFile, JSON.stringify({ taskId: 'TASK_123', pid: null, startedAt: new Date().toISOString() }));
-  recoverStaleDispatchBranch(dir, { ...quiet, lockFile, currentBranch: 'task/task_123', targetBranch: 'main' });
-  assert.equal(head(dir), 'task/task_123');
-});

package/core/.formation/tools/headless-dryrun.test.js

@@ -1,79 +0,0 @@
-// TASK_2283: headless.js `--dry-run` must report the unit worktree it WOULD create,
-// not create it (nor take the parallel-count lock / run branch recovery).
-// Drives the real CLI (headless.js) against a disposable temp git repo.
-// Sibling of dispatch-dryrun.test.js (TASK_2274, formation-mode dispatch.js).
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { spawnSync } = require('child_process');
-
-const HEADLESS = path.join(__dirname, 'headless.js');
-const GIT = ['-c', 'user.email=t@t', '-c', 'user.name=t'];
-
-function mkRepo() {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 't2283_'));
-  fs.mkdirSync(path.join(root, '.kenaz', 'tasks', 'backlog'), { recursive: true });
-  fs.writeFileSync(path.join(root, '.kenaz', 'tasks', 'backlog', 'TASK_9001_probe.yaml'), [
-    'id: TASK_9001', 'title: probe', 'description: probe', 'status: backlog',
-    'priority: P2', 'scope_paths:', '  - src/x.js', ''].join('\n'));
-  fs.writeFileSync(path.join(root, 'README.md'), 'x\n');
-  const g = (...a) => spawnSync('git', [...GIT, ...a], { cwd: root, encoding: 'utf8', windowsHide: true });
-  g('init', '-q'); g('add', '-A'); g('commit', '-q', '-m', 'init');
-  return { root, g };
-}
-function run(root, extra, envOver) {
-  const env = { ...process.env, ...(envOver || {}) }; delete env.CLAUDE_PROJECT_DIR;
-  return spawnSync(process.execPath, [HEADLESS, '--formation=unit', '--skill=do', '--task=TASK_9001',
-    '--project-path', root, ...extra], { encoding: 'utf8', env, windowsHide: true, timeout: 90000 });
-}
-const wtDir = (root) => path.join(root, '.formation', 'worktrees', 'task_task_9001');
-
-test('headless --dry-run: no worktree, no task branch, reports intent', () => {
-  const { root, g } = mkRepo();
-  try {
-    const r = run(root, ['--dry-run']);
-    const out = (r.stdout || '') + (r.stderr || '');
-    assert.equal(r.status, 0, out.slice(-600));
-    assert.ok(!fs.existsSync(wtDir(root)), 'dry-run must not create the unit worktree');
-    assert.equal(g('branch', '--list', 'task/task_9001').stdout.trim(), '', 'dry-run must not create the task branch');
-    assert.match(out, /\[dry-run\] would create unit worktree: .*task_task_9001/);
-    assert.match(out, /count lock NOT taken/);
-    assert.ok(!/Unit worktree:/.test(out), 'no real worktree creation log');
-    // follow-up: no auto-activate (task move + commit) and no .dispatch-branch write
-    const taskFile = (d) => path.join(root, '.kenaz', 'tasks', d, 'TASK_9001_probe.yaml');
-    assert.ok(fs.existsSync(taskFile('backlog')) && !fs.existsSync(taskFile('active')), 'task status must stay backlog');
-    assert.ok(!/Auto-activate/.test(g('log', '--format=%s').stdout), 'no Auto-activate commit');
-    assert.equal(g('rev-list', '--count', 'HEAD').stdout.trim(), '1', 'no commits added');
-    assert.ok(!fs.existsSync(path.join(root, '.formation', '.dispatch-branch')), 'no .dispatch-branch write');
-    assert.match(out, /\[dry-run\] would auto-activate TASK_9001/);
-    assert.match(out, /\[dry-run\] would record dispatch branch/);
-  } finally { fs.rmSync(root, { recursive: true, force: true }); }
-});
-
-test('control: non-dry-run headless DOES create the unit worktree', () => {
-  const { root } = mkRepo();
-  // persistDispatchBranch always writes <core ROOT>/.formation/.dispatch-branch, which
-  // post-complete getDispatchBranch reads to return to the user's branch. Restore it.
-  const realDispatchBranch = path.join(__dirname, '..', '.dispatch-branch');
-  const saved = fs.existsSync(realDispatchBranch) ? fs.readFileSync(realDispatchBranch) : null;
-  try {
-    // PATH = node + git dirs only and a fake HOME/USERPROFILE: the agent launch that
-    // follows the worktree step cannot find a real claude binary (it fails after the
-    // step we assert on). Never drop this isolation — a probe once launched a real agent.
-    const gitDirs = spawnSync(process.platform === 'win32' ? 'where' : 'which', ['git'], { encoding: 'utf8' })
-      .stdout.split(/\r?\n/).filter(Boolean).map((p) => path.dirname(p));
-    const PATH = [path.dirname(process.execPath), ...gitDirs].join(path.delimiter);
-    // Count file redirected to the temp repo (KENAZ_PARALLEL_COUNT_FILE) so a crash cannot
-    // leave the real ROOT/.formation/.parallel-count inflated.
-    const r = run(root, [], { PATH, Path: PATH, USERPROFILE: root, HOME: root,
-      KENAZ_PARALLEL_COUNT_FILE: path.join(root, 'parallel-count') });
-    const out = (r.stdout || '') + (r.stderr || '');
-    assert.match(out, /Unit worktree: \.formation\/worktrees\/task_task_9001/, 'control: worktree creation expected\n' + out.slice(-800));
-  } finally {
-    if (saved === null) fs.rmSync(realDispatchBranch, { force: true });
-    else fs.writeFileSync(realDispatchBranch, saved);
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});