@ktpartners/dgs-platform 2.9.0 → 3.3.0

package/deliver-great-systems/bin/lib/commands.test.cjs

@@ -37,6 +37,38 @@ function captureCommitOutput(fn) {
   return null;
 }
 
+/**
+ * Capture stdout output from functions that use process.stdout.write + process.exit.
+ * core.cjs output() writes via process.stdout.write and then calls process.exit(0),
+ * which would terminate the test process. This helper mocks both so multiple
+ * cmdCommit invocations can run in sequence and their output is inspectable.
+ *
+ * Returns { stdout: string, exitCode: number|null, json: any|null }.
+ */
+function captureStdout(fn) {
+  const chunks = [];
+  const origWrite = process.stdout.write.bind(process.stdout);
+  const origExit = process.exit;
+  let exitCode = null;
+  process.stdout.write = (data) => { chunks.push(String(data)); return true; };
+  process.exit = (code) => {
+    exitCode = code == null ? 0 : code;
+    throw new Error('__EXIT__');
+  };
+  try {
+    fn();
+  } catch (e) {
+    if (e && e.message !== '__EXIT__') throw e;
+  } finally {
+    process.stdout.write = origWrite;
+    process.exit = origExit;
+  }
+  const stdout = chunks.join('');
+  let json = null;
+  try { json = JSON.parse(stdout); } catch { /* not JSON */ }
+  return { stdout, exitCode, json };
+}
+
 /**
  * Set up a temp project with git, write a file, and return the fixture.
  */
@@ -323,3 +355,422 @@ describe('cmdCommit with push=true, sync_push unset (defaults to off)', () => {
     assert.equal(result.needs_push, undefined);
   });
 });
+
+// ─── --repo-cwd flag tests ────────────────────────────────────────────────────
+
+describe('cmdCommit with --repo-cwd flag', () => {
+  let planningFixture;
+  let worktreeFixture;
+  let commands;
+
+  beforeEach(() => {
+    // Planning-root fixture: holds config, sync_push=off so pushAll won't be
+    // invoked when push=false.
+    planningFixture = setupGitFixture('off');
+    // "Worktree" fixture: a second independent git repo where commits should
+    // actually land when --repo-cwd is passed.
+    worktreeFixture = setupGitFixture('off');
+    // Clear require cache so we load a fresh commands module that picks up
+    // any test-time mutations (e.g., mocked sync.pushAll).
+    commands = require('./commands.cjs');
+  });
+
+  afterEach(() => {
+    planningFixture.cleanup();
+    worktreeFixture.cleanup();
+  });
+
+  it('runs git add/commit/rev-parse in repoCwd, not cwd', () => {
+    // Write file in the worktree, NOT in the planning root
+    const fileName = 'worktree-file.txt';
+    fs.writeFileSync(
+      path.join(worktreeFixture.cwd, fileName),
+      'worktree content'
+    );
+
+    // Record each repo's HEAD before the commit
+    const planningHeadBefore = execSync('git rev-parse HEAD', {
+      cwd: planningFixture.cwd, encoding: 'utf-8'
+    }).trim();
+    const worktreeHeadBefore = execSync('git rev-parse HEAD', {
+      cwd: worktreeFixture.cwd, encoding: 'utf-8'
+    }).trim();
+
+    // Call cmdCommit with cwd=planning, repoCwd=worktree.
+    // raw=false so output() writes JSON (with rawValue undefined path).
+    const capture = captureStdout(() => {
+      commands.cmdCommit(
+        planningFixture.cwd,          // cwd
+        'test: commit in worktree',   // message
+        [fileName],                   // files (relative to repoCwd)
+        false,                        // raw (false => JSON output)
+        false,                        // amend
+        false,                        // push
+        worktreeFixture.cwd           // repoCwd
+      );
+    });
+
+    // Parse result
+    const result = capture.json;
+    assert.ok(result, 'Expected JSON result. stdout: ' + capture.stdout);
+    assert.equal(result.committed, true, 'Expected committed=true');
+    assert.ok(result.hash, 'Expected a commit hash');
+
+    // HEAD must have advanced in the worktree
+    const worktreeHeadAfter = execSync('git rev-parse HEAD', {
+      cwd: worktreeFixture.cwd, encoding: 'utf-8'
+    }).trim();
+    assert.notEqual(worktreeHeadAfter, worktreeHeadBefore,
+      'worktree HEAD must have advanced');
+    assert.ok(worktreeHeadAfter.startsWith(result.hash),
+      `worktree HEAD (${worktreeHeadAfter}) should start with returned hash (${result.hash})`);
+
+    // Planning-root HEAD must be unchanged
+    const planningHeadAfter = execSync('git rev-parse HEAD', {
+      cwd: planningFixture.cwd, encoding: 'utf-8'
+    }).trim();
+    assert.equal(planningHeadAfter, planningHeadBefore,
+      'planning-root HEAD must NOT have moved');
+  });
+
+  it('loads config from cwd, not repoCwd (push uses planning-root config)', () => {
+    // Planning fixture has sync_push=auto
+    planningFixture.cleanup();
+    planningFixture = setupGitFixture('auto');
+
+    // Write file in worktree
+    const fileName = 'pushable.txt';
+    fs.writeFileSync(
+      path.join(worktreeFixture.cwd, fileName),
+      'pushable content'
+    );
+
+    // Mock pushAll and capture what cwd it's called with
+    let pushAllCwd = null;
+    const restore = mockPushAll((cwd) => {
+      pushAllCwd = cwd;
+      return { ok: true, results: [], summary: '' };
+    });
+
+    try {
+      const capture = captureStdout(() => {
+        commands.cmdCommit(
+          planningFixture.cwd,
+          'test: push uses planning cwd',
+          [fileName],
+          false,                      // raw=false => JSON output
+          false,
+          true,                       // push=true
+          worktreeFixture.cwd         // repoCwd
+        );
+      });
+      const result = capture.json;
+      assert.ok(result, 'Expected JSON result. stdout: ' + capture.stdout);
+      assert.equal(result.committed, true);
+      assert.equal(pushAllCwd, planningFixture.cwd,
+        'pushAll must be called with planning-root cwd, not worktree repoCwd');
+    } finally {
+      restore();
+    }
+  });
+
+  it('behaves identically to pre-change when repoCwd is undefined', () => {
+    // Write file in planning root (as existing tests do)
+    writeAndStageFile(planningFixture.cwd, 'no-repo-cwd.txt', 'regression');
+    const headBefore = execSync('git rev-parse HEAD', {
+      cwd: planningFixture.cwd, encoding: 'utf-8'
+    }).trim();
+
+    // Call cmdCommit with NO repoCwd (existing 6-arg signature)
+    const capture = captureStdout(() => {
+      commands.cmdCommit(
+        planningFixture.cwd,
+        'test: no repo-cwd regression',
+        [],
+        false,                        // raw=false => JSON output
+        false,
+        false
+        // no 7th arg
+      );
+    });
+    const result = capture.json;
+    assert.ok(result, 'Expected JSON result. stdout: ' + capture.stdout);
+    assert.equal(result.committed, true);
+    assert.ok(result.hash);
+
+    // Commit must land in planningFixture.cwd (not elsewhere)
+    const headAfter = execSync('git rev-parse HEAD', {
+      cwd: planningFixture.cwd, encoding: 'utf-8'
+    }).trim();
+    assert.notEqual(headAfter, headBefore,
+      'planning-root HEAD must have advanced when no repoCwd is passed');
+    assert.ok(headAfter.startsWith(result.hash),
+      'planning-root HEAD should match returned hash');
+  });
+
+  it('dgs-tools commit CLI parses --repo-cwd flag and targets that directory', () => {
+    // Write file in the worktree (a separate git repo)
+    const fileName = 'cli-repo-cwd.txt';
+    fs.writeFileSync(
+      path.join(worktreeFixture.cwd, fileName),
+      'cli content'
+    );
+
+    const worktreeHeadBefore = execSync('git rev-parse HEAD', {
+      cwd: worktreeFixture.cwd, encoding: 'utf-8'
+    }).trim();
+
+    // Invoke dgs-tools.cjs commit with --repo-cwd from planningFixture.cwd
+    const dgsTools = path.resolve(__dirname, '..', 'dgs-tools.cjs');
+    const cliOut = execSync(
+      `node "${dgsTools}" commit "cli test repo-cwd" --raw --repo-cwd "${worktreeFixture.cwd}" --files "${fileName}"`,
+      { cwd: planningFixture.cwd, encoding: 'utf-8' }
+    );
+    // --raw with a hash rawValue outputs the hash only (not JSON)
+    const hash = cliOut.trim();
+    assert.ok(hash.length > 0, 'Expected some hash/output. stdout: ' + cliOut);
+
+    // Verify the commit landed in the worktree repo
+    const worktreeHeadAfter = execSync('git rev-parse HEAD', {
+      cwd: worktreeFixture.cwd, encoding: 'utf-8'
+    }).trim();
+    assert.notEqual(worktreeHeadAfter, worktreeHeadBefore,
+      'worktree HEAD must advance when --repo-cwd targets it');
+    assert.ok(worktreeHeadAfter.startsWith(hash),
+      `worktree HEAD (${worktreeHeadAfter}) should start with CLI hash (${hash})`);
+  });
+});
+
+// ─── cmdCommit populates dirty_after ────────────────────────────────────────
+// Uses captureStdout (not captureCommitOutput) because cmdCommit's output() goes
+// through process.stdout.write + process.exit, not console.log. captureStdout
+// mocks both correctly. captureCommitOutput exists for historical reasons but
+// doesn't actually intercept output() writes — its assertions silently no-op
+// because process.exit kills the test worker before they run.
+
+describe('cmdCommit populates dirty_after', () => {
+  let fixture;
+  let commands;
+
+  beforeEach(() => {
+    fixture = setupGitFixture('off');
+    commands = require('./commands.cjs');
+  });
+
+  afterEach(() => {
+    fixture.cleanup();
+  });
+
+  it('returns dirty_after=[] when tree is clean after commit', () => {
+    writeAndStageFile(fixture.cwd, 'clean-after.txt', 'clean');
+    const capture = captureStdout(() => {
+      commands.cmdCommit(fixture.cwd, 'test: clean dirty_after', [], false, false, false);
+    });
+    const result = capture.json;
+    assert.ok(result, 'expected JSON result. stdout: ' + capture.stdout);
+    assert.equal(result.committed, true);
+    assert.ok(result.hash);
+    assert.ok(Array.isArray(result.dirty_after), 'dirty_after should be an array');
+    assert.equal(result.dirty_after.length, 0, `clean tree should have empty dirty_after, got: ${JSON.stringify(result.dirty_after)}`);
+  });
+
+  it('includes unstaged files in dirty_after after commit', () => {
+    // Stage and commit file A
+    writeAndStageFile(fixture.cwd, 'staged-file.txt', 'staged');
+    // Write (but do NOT stage) file B — it should remain dirty after the commit
+    fs.writeFileSync(path.join(fixture.cwd, 'dirty-file.txt'), 'unstaged');
+
+    const capture = captureStdout(() => {
+      commands.cmdCommit(fixture.cwd, 'test: dirty dirty_after', ['staged-file.txt'], false, false, false);
+    });
+    const result = capture.json;
+    assert.ok(result, 'expected JSON result. stdout: ' + capture.stdout);
+    assert.equal(result.committed, true);
+    assert.ok(result.hash);
+    assert.ok(Array.isArray(result.dirty_after), 'dirty_after should be an array');
+    assert.ok(
+      result.dirty_after.includes('dirty-file.txt'),
+      `dirty_after should include the unstaged file, got: ${JSON.stringify(result.dirty_after)}`
+    );
+  });
+
+  it('emits dirty_after in nothing_to_commit branch', () => {
+    // Create an unstaged file to make the tree dirty
+    fs.writeFileSync(path.join(fixture.cwd, 'unstaged-only.txt'), 'unstaged');
+
+    const capture = captureStdout(() => {
+      // Pass a pathspec that matches nothing so staging is a no-op — the
+      // unstaged file remains dirty AND there is nothing_to_commit.
+      commands.cmdCommit(fixture.cwd, 'test: nothing', ['nonexistent-pathspec-zzz'], false, false, false);
+    });
+    const result = capture.json;
+    assert.ok(result, 'expected JSON result. stdout: ' + capture.stdout);
+    assert.equal(result.committed, false, `expected committed=false, got result: ${JSON.stringify(result)}`);
+    assert.equal(result.reason, 'nothing_to_commit');
+    assert.ok(Array.isArray(result.dirty_after), 'dirty_after should be an array even when nothing_to_commit');
+    assert.ok(
+      result.dirty_after.includes('unstaged-only.txt'),
+      `dirty_after should include the unstaged file in nothing_to_commit branch, got: ${JSON.stringify(result.dirty_after)}`
+    );
+  });
+
+  it('runs porcelain in repoCwd when --repo-cwd is passed (not in cwd)', () => {
+    // Second fixture for the worktree
+    const worktreeFixture = setupGitFixture('off');
+    try {
+      // Write file in the worktree ONLY — planning root stays untouched
+      const stagedName = 'worktree-staged.txt';
+      fs.writeFileSync(path.join(worktreeFixture.cwd, stagedName), 'content');
+      execSync(`git add "${stagedName}"`, { cwd: worktreeFixture.cwd, stdio: 'pipe' });
+      // Dirty file in the worktree that is NOT staged
+      fs.writeFileSync(path.join(worktreeFixture.cwd, 'worktree-dirty.txt'), 'unstaged');
+      // Separately, make the PLANNING root dirty — this should NOT appear in dirty_after
+      fs.writeFileSync(path.join(fixture.cwd, 'planning-dirty.txt'), 'should-not-see-this');
+
+      const capture = captureStdout(() => {
+        commands.cmdCommit(
+          fixture.cwd,            // cwd (planning root)
+          'test: repo-cwd dirty', // message
+          [stagedName],           // files (relative to repoCwd)
+          false,                  // raw=false -> JSON output
+          false,
+          false,
+          worktreeFixture.cwd     // repoCwd
+        );
+      });
+      const result = capture.json;
+      assert.ok(result, 'expected JSON result. stdout: ' + capture.stdout);
+      assert.equal(result.committed, true);
+      assert.ok(Array.isArray(result.dirty_after), 'dirty_after should be an array');
+      assert.ok(
+        result.dirty_after.includes('worktree-dirty.txt'),
+        `dirty_after should include the worktree-unstaged file, got: ${JSON.stringify(result.dirty_after)}`
+      );
+      assert.ok(
+        !result.dirty_after.includes('planning-dirty.txt'),
+        `dirty_after must NOT include planning-root files when --repo-cwd is set, got: ${JSON.stringify(result.dirty_after)}`
+      );
+    } finally {
+      worktreeFixture.cleanup();
+    }
+  });
+});
+
+// ─── TODO_STATUSES constant ─────────────────────────────────────────────────
+
+describe('TODO_STATUSES constant', () => {
+  it('exports correct values', () => {
+    const { TODO_STATUSES } = require('./commands.cjs');
+    assert.deepStrictEqual(TODO_STATUSES, ['pending', 'done']);
+  });
+});
+
+// ─── setTodoStatus ──────────────────────────────────────────────────────────
+
+describe('setTodoStatus', () => {
+  it('throws on invalid status', () => {
+    const { setTodoStatus } = require('./commands.cjs');
+    assert.throws(() => {
+      setTodoStatus('/nonexistent', 'test.md', 'invalid-status');
+    }, (err) => {
+      assert.ok(err.message.includes('Invalid status'));
+      assert.ok(err.message.includes('pending'));
+      assert.ok(err.message.includes('done'));
+      return true;
+    });
+  });
+});
+
+// ─── cmdListTodos flat-first scanning ─────────────────────────────────────
+
+describe('cmdListTodos flat-first scanning', () => {
+  const { cmdListTodos } = require('./commands.cjs');
+
+  /**
+   * Capture JSON output from cmdListTodos.
+   */
+  function captureTodosOutput(fn) {
+    const logs = [];
+    const origLog = console.log;
+    console.log = (...args) => logs.push(args.join(' '));
+    try {
+      fn();
+    } finally {
+      console.log = origLog;
+    }
+    return logs.length ? JSON.parse(logs[0]) : null;
+  }
+
+  it('lists todos from flat todos/ directory', () => {
+    const fixture = createTempProject({ withGit: true });
+    try {
+      const todosDir = path.join(fixture.planningDir, 'todos');
+      fs.mkdirSync(todosDir, { recursive: true });
+      fs.writeFileSync(path.join(todosDir, 'test-todo.md'), '---\nstatus: pending\ntitle: Test Todo\ncreated: 2026-04-06\narea: general\n---\n\nTodo body.\n');
+      const result = captureTodosOutput(() => cmdListTodos(fixture.cwd, null, true));
+      assert.equal(result.count, 1);
+      assert.equal(result.todos[0].status, 'pending');
+      assert.ok(!result.todos[0].path.includes('pending/'), 'Flat path should NOT contain pending/');
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  it('excludes done todos from flat directory', () => {
+    const fixture = createTempProject({ withGit: true });
+    try {
+      const todosDir = path.join(fixture.planningDir, 'todos');
+      fs.mkdirSync(todosDir, { recursive: true });
+      fs.writeFileSync(path.join(todosDir, 'done-todo.md'), '---\nstatus: done\ntitle: Done Todo\ncreated: 2026-04-06\narea: general\n---\n\nDone.\n');
+      const result = captureTodosOutput(() => cmdListTodos(fixture.cwd, null, true));
+      assert.equal(result.count, 0, 'Done todos should be excluded');
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  it('falls back to legacy todos/pending/ with warning', () => {
+    const fixture = createTempProject({ withTodos: true, withGit: true });
+    try {
+      const pendingDir = path.join(fixture.planningDir, 'todos', 'pending');
+      fs.mkdirSync(pendingDir, { recursive: true });
+      fs.writeFileSync(path.join(pendingDir, 'legacy-todo.md'), '---\ntitle: Legacy Todo\ncreated: 2026-04-06\narea: general\n---\n\nLegacy.\n');
+      const origWrite = process.stderr.write;
+      let stderrOutput = '';
+      process.stderr.write = (msg) => { stderrOutput += msg; };
+      try {
+        const result = captureTodosOutput(() => cmdListTodos(fixture.cwd, null, true));
+        assert.equal(result.count, 1);
+        assert.ok(stderrOutput.includes('[DGS] Warning:'), 'Should emit legacy warning');
+        assert.ok(result.todos[0].path.includes('pending/'), 'Legacy path should contain pending/');
+      } finally {
+        process.stderr.write = origWrite;
+      }
+    } finally {
+      fixture.cleanup();
+    }
+  });
+
+  it('deduplicates when same file in flat and legacy', () => {
+    const fixture = createTempProject({ withGit: true });
+    try {
+      const todosDir = path.join(fixture.planningDir, 'todos');
+      const pendingDir = path.join(todosDir, 'pending');
+      fs.mkdirSync(pendingDir, { recursive: true });
+      const todoContent = '---\nstatus: pending\ntitle: Dedup Test\ncreated: 2026-04-06\narea: general\n---\n\nBody.\n';
+      fs.writeFileSync(path.join(todosDir, 'dedup-test.md'), todoContent);
+      fs.writeFileSync(path.join(pendingDir, 'dedup-test.md'), todoContent);
+      // Suppress stderr
+      const origWrite = process.stderr.write;
+      process.stderr.write = () => {};
+      try {
+        const result = captureTodosOutput(() => cmdListTodos(fixture.cwd, null, true));
+        assert.equal(result.count, 1, 'No duplicates');
+      } finally {
+        process.stderr.write = origWrite;
+      }
+    } finally {
+      fixture.cleanup();
+    }
+  });
+});