cc-devflow 4.2.0 → 4.4.1

package/lib/skill-runtime/__tests__/cli-bootstrap.integration.test.js

@@ -0,0 +1,181 @@
+/**
+ * [INPUT]: 依赖 child_process 调用 CLI，依赖临时仓库夹具与 .claude 模板文件。
+ * [OUTPUT]: 验证恢复后的多平台 CLI 会安装 .claude，并按原版策略覆盖差异文件。
+ * [POS]: lib/skill-runtime/__tests__ 的 CLI 分发回归测试。
+ * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const matter = require('gray-matter');
+
+const REPO_ROOT = path.resolve(__dirname, '../../..');
+const CLI_BIN = path.join(REPO_ROOT, 'bin/cc-devflow-cli.js');
+const TEMPLATE_ROOT = path.join(REPO_ROOT, '.claude');
+
+function runCli(args, cwd) {
+  const result = spawnSync(process.execPath, [CLI_BIN, ...args], {
+    cwd,
+    encoding: 'utf8'
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  return result;
+}
+
+function readPackageJson(repoRoot) {
+  const packagePath = path.join(repoRoot, 'package.json');
+  return JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+}
+
+describe('cc-devflow cli distribution bootstrap', () => {
+  let repoRoot;
+
+  beforeEach(() => {
+    repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-cli-bootstrap-'));
+    fs.writeFileSync(
+      path.join(repoRoot, 'package.json'),
+      JSON.stringify(
+        {
+          name: 'tmp-repo',
+          version: '0.0.0',
+          scripts: {
+            test: 'node -e "process.exit(0)"'
+          }
+        },
+        null,
+        2
+      )
+    );
+  });
+
+  afterEach(() => {
+    fs.rmSync(repoRoot, { recursive: true, force: true });
+  });
+
+  test('init installs .claude without mutating unrelated package scripts', () => {
+    const result = runCli(['init', '--dir', repoRoot], repoRoot);
+    expect(result.status).toBe(0);
+
+    const packageJson = readPackageJson(repoRoot);
+    expect(packageJson.scripts.test).toBe('node -e "process.exit(0)"');
+    expect(packageJson.scripts).toEqual({
+      test: 'node -e "process.exit(0)"'
+    });
+
+    expect(fs.existsSync(path.join(repoRoot, '.claude', 'skills', 'cc-roadmap', 'SKILL.md'))).toBe(true);
+    expect(fs.existsSync(path.join(repoRoot, '.claude', 'skills', 'cc-plan', 'SKILL.md'))).toBe(true);
+    expect(fs.existsSync(path.join(repoRoot, '.claude', 'skills', 'cc-investigate', 'SKILL.md'))).toBe(true);
+    expect(fs.existsSync(path.join(repoRoot, '.claude', 'skills', 'docs-sync'))).toBe(false);
+    expect(fs.existsSync(path.join(repoRoot, '.claude', 'skills', 'npm-release'))).toBe(false);
+    expect(fs.existsSync(path.join(repoRoot, '.claude', 'tsc-cache'))).toBe(false);
+  });
+
+  test('init overwrites diverged .claude files with packaged content', () => {
+    expect(runCli(['init', '--dir', repoRoot], repoRoot).status).toBe(0);
+
+    const targetSkill = path.join(repoRoot, '.claude', 'skills', 'cc-roadmap', 'SKILL.md');
+    fs.writeFileSync(targetSkill, '# local override\n');
+
+    const result = runCli(['init', '--dir', repoRoot], repoRoot);
+    expect(result.status).toBe(0);
+
+    expect(fs.existsSync(`${targetSkill}.new`)).toBe(false);
+    expect(fs.readFileSync(targetSkill, 'utf8')).toBe(
+      fs.readFileSync(path.join(TEMPLATE_ROOT, 'skills', 'cc-roadmap', 'SKILL.md'), 'utf8')
+    );
+  });
+
+  test('force re-initialization resets .claude to the packaged template', () => {
+    expect(runCli(['init', '--dir', repoRoot], repoRoot).status).toBe(0);
+
+    const targetSkill = path.join(repoRoot, '.claude', 'skills', 'cc-roadmap', 'SKILL.md');
+    fs.writeFileSync(targetSkill, '# local override\n');
+
+    const result = runCli(['init', '--dir', repoRoot, '--force'], repoRoot);
+    expect(result.status).toBe(0);
+
+    expect(fs.readFileSync(targetSkill, 'utf8')).toBe(
+      fs.readFileSync(path.join(TEMPLATE_ROOT, 'skills', 'cc-roadmap', 'SKILL.md'), 'utf8')
+    );
+    expect(fs.existsSync(`${targetSkill}.new`)).toBe(false);
+  });
+
+  test('adapt mirrors public skills into .codex/skills for Codex', () => {
+    expect(runCli(['init', '--dir', repoRoot], repoRoot).status).toBe(0);
+
+    const result = runCli(['adapt', '--cwd', repoRoot, '--platform', 'codex'], repoRoot);
+    expect(result.status).toBe(0);
+
+    expect(fs.existsSync(path.join(repoRoot, '.codex', 'skills', 'cc-devflow', 'SKILL.md'))).toBe(false);
+    expect(fs.existsSync(path.join(repoRoot, '.codex', 'skills', 'cc-roadmap', 'SKILL.md'))).toBe(true);
+    expect(fs.existsSync(path.join(repoRoot, '.codex', 'skills', 'cc-plan', 'SKILL.md'))).toBe(true);
+    expect(fs.existsSync(path.join(repoRoot, '.codex', 'skills', 'cc-investigate', 'SKILL.md'))).toBe(true);
+    expect(fs.existsSync(path.join(repoRoot, '.codex', 'skills', 'cc-do', 'SKILL.md'))).toBe(true);
+    expect(fs.existsSync(path.join(repoRoot, '.codex', 'skills', 'cc-check', 'SKILL.md'))).toBe(true);
+    expect(fs.existsSync(path.join(repoRoot, '.codex', 'skills', 'cc-act', 'SKILL.md'))).toBe(true);
+
+    const codexInvestigateSkill = fs.readFileSync(
+      path.join(repoRoot, '.codex', 'skills', 'cc-investigate', 'SKILL.md'),
+      'utf8'
+    );
+    const parsed = matter(codexInvestigateSkill);
+    expect(parsed.data.reads).toContain('.codex/skills/cc-investigate/references/investigation-contract.md');
+    expect(parsed.data.reads).not.toContain('references/investigation-contract.md');
+
+    const codexDoSkill = matter(
+      fs.readFileSync(path.join(repoRoot, '.codex', 'skills', 'cc-do', 'SKILL.md'), 'utf8')
+    );
+    expect(codexDoSkill.data.writes).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          path: 'devflow/changes/<change-key>/execution/tasks/<task-id>/checkpoint.json',
+          durability: 'durable',
+          required: true
+        })
+      ])
+    );
+    expect(codexDoSkill.data.effects).toContain('code changes');
+
+    const codexRoadmapSkill = matter(
+      fs.readFileSync(path.join(repoRoot, '.codex', 'skills', 'cc-roadmap', 'SKILL.md'), 'utf8')
+    );
+    expect(codexRoadmapSkill.data.writes).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          path: 'devflow/ROADMAP.md',
+          durability: 'durable',
+          required: true
+        }),
+        expect.objectContaining({
+          path: 'devflow/BACKLOG.md',
+          durability: 'durable',
+          required: true
+        })
+      ])
+    );
+  });
+
+  test('adapt preserves pre-existing non-public Codex skills and does not mirror new private ones', () => {
+    expect(runCli(['init', '--dir', repoRoot], repoRoot).status).toBe(0);
+
+    const privateClaudeSkill = path.join(repoRoot, '.claude', 'skills', 'skill-creator');
+    const preservedCodexSkill = path.join(repoRoot, '.codex', 'skills', 'local-postmortem-gate');
+    fs.mkdirSync(privateClaudeSkill, { recursive: true });
+    fs.mkdirSync(preservedCodexSkill, { recursive: true });
+    fs.writeFileSync(path.join(privateClaudeSkill, 'SKILL.md'), '# private skill\n');
+    fs.writeFileSync(path.join(preservedCodexSkill, 'SKILL.md'), '# original codex skill\n');
+
+    const result = runCli(['adapt', '--cwd', repoRoot, '--platform', 'codex'], repoRoot);
+    expect(result.status).toBe(0);
+
+    expect(fs.existsSync(path.join(repoRoot, '.codex', 'skills', 'cc-roadmap', 'SKILL.md'))).toBe(true);
+    expect(fs.existsSync(path.join(repoRoot, '.codex', 'skills', 'local-postmortem-gate', 'SKILL.md'))).toBe(true);
+    expect(fs.existsSync(path.join(repoRoot, '.codex', 'skills', 'skill-creator'))).toBe(false);
+  });
+});

package/lib/skill-runtime/__tests__/delegation.test.js

@@ -0,0 +1,97 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const {
+  syncDelegationRuntime,
+  ensureWorkerWorkspace,
+  getWorkerStatePath,
+  getWorkerJournalPath,
+  getWorkerAssignmentPath,
+  getMessageBusPath,
+  getTeamMemoryPath,
+  getWorkerWorkspacePath
+} = require('../delegation');
+const { getTeamStatePath } = require('../team-state');
+
+describe('syncDelegationRuntime', () => {
+  test('writes workspace scratch files and team-state truth without polluting devflow/changes', async () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-delegation-'));
+    fs.writeFileSync(path.join(repoRoot, 'package.json'), JSON.stringify({ name: 'delegation-smoke', version: '1.0.0' }, null, 2));
+
+    const manifest = {
+      changeId: 'REQ-123',
+      goal: 'Delegate selected tasks',
+      createdAt: '2026-03-25T01:00:00.000Z',
+      updatedAt: '2026-03-25T01:01:00.000Z',
+      tasks: [
+        {
+          id: 'T001',
+          title: 'Single file direct task',
+          type: 'IMPL',
+          dependsOn: [],
+          touches: ['src/a.ts'],
+          run: ['echo direct'],
+          checks: [],
+          status: 'pending',
+          attempts: 0,
+          maxRetries: 1
+        },
+        {
+          id: 'T002',
+          title: 'Multi file delegated task',
+          type: 'IMPL',
+          dependsOn: [],
+          touches: ['src/a.ts', 'src/b.ts'],
+          run: ['echo delegated'],
+          checks: [],
+          status: 'pending',
+          attempts: 0,
+          maxRetries: 1
+        }
+      ],
+      metadata: {
+        source: 'default',
+        generatedBy: 'test',
+        planVersion: 3
+      }
+    };
+
+    const result = await syncDelegationRuntime(repoRoot, 'REQ-123', manifest);
+
+    const teamState = JSON.parse(fs.readFileSync(getTeamStatePath(repoRoot, 'REQ-123'), 'utf8'));
+    const workerId = teamState.team.taskAssignments.T002;
+    const assignment = fs.readFileSync(getWorkerAssignmentPath(repoRoot, 'REQ-123', workerId), 'utf8');
+    const messageBus = fs.readFileSync(getMessageBusPath(repoRoot, 'REQ-123'), 'utf8');
+    const teamMemory = fs.readFileSync(getTeamMemoryPath(repoRoot, 'REQ-123'), 'utf8');
+    const workerState = fs.readFileSync(getWorkerStatePath(repoRoot, 'REQ-123', workerId), 'utf8');
+    const workerJournal = fs.readFileSync(getWorkerJournalPath(repoRoot, 'REQ-123', workerId), 'utf8');
+    const workerWorkspace = getWorkerWorkspacePath(repoRoot, 'REQ-123', workerId);
+
+    expect(result.delegatedCount).toBe(1);
+    expect(assignment).toContain(`Assignment: ${workerId}`);
+    expect(assignment).toContain('`T002` Multi file delegated task');
+    expect(messageBus).toContain('queued for T002');
+    expect(teamMemory).toContain('Worker Count: 1');
+    expect(teamState.planVersion).toBe(3);
+    expect(workerId).toMatch(/^delegate-/);
+    expect(workerState).toContain('Status: `idle`');
+    expect(workerJournal).toContain('Assigned Tasks: T002');
+    expect(workerWorkspace).toContain('devflow/workspaces');
+    expect(fs.existsSync(path.join(repoRoot, 'devflow/changes/REQ-123-delegate-selected-tasks/execution/workers'))).toBe(false);
+  });
+
+  test('falls back to controller workspace when git worktree is unavailable', async () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-no-git-'));
+    const worker = await ensureWorkerWorkspace(repoRoot, 'REQ-123', {
+      taskId: 'T001',
+      workerId: 'delegate-01',
+      role: 'dev-implementer',
+      route: 'delegate'
+    });
+
+    expect(worker.mode).toBe('fallback');
+    expect(worker.cwd).toBe(repoRoot);
+    expect(worker.reason).toBe('git-unavailable');
+  });
+});

package/lib/skill-runtime/__tests__/dispatch.test.js

@@ -0,0 +1,267 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const { runDispatch } = require('../operations/dispatch');
+const { runResume } = require('../operations/resume');
+const {
+  getRuntimeStatePath,
+  getTaskManifestPath,
+  getCheckpointPath,
+  getEventsPath
+} = require('../store');
+
+function writeJson(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+describe('runDispatch', () => {
+  test('blocks execution when the current plan version has not been approved', async () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-dispatch-unapproved-'));
+    const manifestPath = getTaskManifestPath(repoRoot, 'REQ-123');
+
+    writeJson(getRuntimeStatePath(repoRoot, 'REQ-123'), {
+      changeId: 'REQ-123',
+      changeKey: 'REQ-123-block-unapproved-execution',
+      slug: 'block-unapproved-execution',
+      createdAt: '2026-03-25T01:00:00.000Z',
+      goal: 'Block unapproved execution',
+      status: 'planned',
+      initializedAt: '2026-03-25T01:00:00.000Z',
+      plannedAt: '2026-03-25T01:01:00.000Z',
+      approval: {
+        status: 'pending',
+        executionMode: 'delegate'
+      },
+      updatedAt: '2026-03-25T01:01:00.000Z'
+    });
+
+    writeJson(manifestPath, {
+      changeId: 'REQ-123',
+      goal: 'Block unapproved execution',
+      createdAt: '2026-03-25T01:00:00.000Z',
+      updatedAt: '2026-03-25T01:01:00.000Z',
+      tasks: [
+        {
+          id: 'T001',
+          title: 'Should not execute before approval',
+          type: 'IMPL',
+          dependsOn: [],
+          touches: ['lib/skill-runtime/operations/dispatch.js'],
+          run: ['echo blocked'],
+          checks: [],
+          status: 'pending',
+          attempts: 0,
+          maxRetries: 0
+        }
+      ],
+      metadata: {
+        source: 'default',
+        generatedBy: 'test',
+        planVersion: 1
+      }
+    });
+
+    const result = await runDispatch({
+      repoRoot,
+      changeId: 'REQ-123',
+      parallel: 1
+    });
+
+    const nextManifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+
+    expect(result.success).toBe(false);
+    expect(result.reason).toContain('cc-plan approval gate');
+    expect(nextManifest.tasks[0].status).toBe('pending');
+  });
+
+  test('rejects stale results when planVersion changes during task execution and records it in checkpoint', async () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-dispatch-'));
+    const manifestPath = getTaskManifestPath(repoRoot, 'REQ-123');
+
+    writeJson(getRuntimeStatePath(repoRoot, 'REQ-123'), {
+      changeId: 'REQ-123',
+      changeKey: 'REQ-123-reject-stale-results',
+      slug: 'reject-stale-results',
+      createdAt: '2026-03-25T01:00:00.000Z',
+      goal: 'Reject stale results',
+      status: 'planned',
+      initializedAt: '2026-03-25T01:00:00.000Z',
+      plannedAt: '2026-03-25T01:01:00.000Z',
+      approval: {
+        status: 'approved',
+        executionMode: 'delegate',
+        planVersion: 1,
+        approvedAt: '2026-03-25T01:01:30.000Z'
+      },
+      updatedAt: '2026-03-25T01:01:00.000Z'
+    });
+
+    writeJson(manifestPath, {
+      changeId: 'REQ-123',
+      goal: 'Reject stale results',
+      createdAt: '2026-03-25T01:00:00.000Z',
+      updatedAt: '2026-03-25T01:01:00.000Z',
+      tasks: [
+        {
+          id: 'T001',
+          title: 'Mutate plan version mid-flight',
+          type: 'IMPL',
+          dependsOn: [],
+          touches: ['lib/skill-runtime/operations/dispatch.js'],
+          run: [
+            `node -e "const fs=require('fs'); const p='${manifestPath.replace(/\\/g, '\\\\')}'; const data=JSON.parse(fs.readFileSync(p,'utf8')); data.metadata.planVersion=2; fs.writeFileSync(p, JSON.stringify(data, null, 2)+'\\n');"`
+          ],
+          checks: [],
+          status: 'pending',
+          attempts: 0,
+          maxRetries: 0
+        }
+      ],
+      metadata: {
+        source: 'default',
+        generatedBy: 'test',
+        planVersion: 1
+      }
+    });
+
+    const result = await runDispatch({
+      repoRoot,
+      changeId: 'REQ-123',
+      parallel: 1
+    });
+
+    const nextManifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    const checkpoint = JSON.parse(fs.readFileSync(getCheckpointPath(repoRoot, 'REQ-123', 'T001'), 'utf8'));
+    const events = fs.readFileSync(getEventsPath(repoRoot, 'REQ-123', 'T001'), 'utf8');
+
+    expect(result.success).toBe(false);
+    expect(nextManifest.tasks[0].status).toBe('failed');
+    expect(nextManifest.tasks[0].lastError).toContain('Stale result rejected');
+    expect(checkpoint.planVersion).toBe(1);
+    expect(checkpoint.error).toContain('Stale result rejected');
+    expect(events).toContain('task_stale_rejected');
+  });
+
+  test('restores unresolved work from the latest stable checkpoint on resume without creating handoff markdown', async () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-resume-stable-'));
+    const changeId = 'REQ-123';
+    const manifestPath = getTaskManifestPath(repoRoot, changeId);
+
+    writeJson(getRuntimeStatePath(repoRoot, changeId), {
+      changeId,
+      changeKey: 'REQ-123-recover-from-stable-checkpoint',
+      slug: 'recover-from-stable-checkpoint',
+      createdAt: '2026-04-09T01:00:00.000Z',
+      goal: 'Recover from stable checkpoint',
+      status: 'in_progress',
+      initializedAt: '2026-04-09T01:00:00.000Z',
+      plannedAt: '2026-04-09T01:01:00.000Z',
+      approval: {
+        status: 'approved',
+        executionMode: 'delegate',
+        planVersion: 1,
+        approvedAt: '2026-04-09T01:01:30.000Z'
+      },
+      updatedAt: '2026-04-09T01:02:00.000Z'
+    });
+
+    writeJson(manifestPath, {
+      changeId,
+      goal: 'Recover from stable checkpoint',
+      createdAt: '2026-04-09T01:00:00.000Z',
+      updatedAt: '2026-04-09T01:02:00.000Z',
+      tasks: [
+        {
+          id: 'T001',
+          title: 'Stable checkpoint task',
+          type: 'TEST',
+          dependsOn: [],
+          touches: ['src/a.ts'],
+          run: ['node -e "process.exit(0)"'],
+          checks: [],
+          status: 'passed',
+          attempts: 1,
+          maxRetries: 0
+        },
+        {
+          id: 'T002',
+          title: 'Retry-exhausted failed task',
+          type: 'IMPL',
+          dependsOn: ['T001'],
+          touches: ['src/b.ts'],
+          run: ['node -e "process.exit(0)"'],
+          checks: [],
+          status: 'failed',
+          attempts: 2,
+          maxRetries: 1,
+          lastError: 'Command failed'
+        },
+        {
+          id: 'T003',
+          title: 'Task skipped by failed dependency',
+          type: 'IMPL',
+          dependsOn: ['T002'],
+          touches: ['src/c.ts'],
+          run: ['node -e "process.exit(0)"'],
+          checks: [],
+          status: 'skipped',
+          attempts: 0,
+          maxRetries: 0,
+          lastError: 'Blocked by failed dependency'
+        }
+      ],
+      metadata: {
+        source: 'default',
+        generatedBy: 'test',
+        planVersion: 1
+      }
+    });
+
+    writeJson(getCheckpointPath(repoRoot, changeId, 'T001'), {
+      changeId,
+      taskId: 'T001',
+      sessionId: 'stable-session',
+      planVersion: 1,
+      status: 'passed',
+      summary: 'Task passed after 1 attempt(s)',
+      error: '',
+      outputExcerpt: '',
+      timestamp: '2026-04-09T01:05:00.000Z',
+      attempt: 1
+    });
+
+    writeJson(getCheckpointPath(repoRoot, changeId, 'T002'), {
+      changeId,
+      taskId: 'T002',
+      sessionId: 'failed-session',
+      planVersion: 1,
+      status: 'failed',
+      summary: 'Task failed: Command failed',
+      error: 'Command failed',
+      outputExcerpt: 'Command failed',
+      timestamp: '2026-04-09T01:06:00.000Z',
+      attempt: 2
+    });
+
+    const result = await runResume({
+      repoRoot,
+      changeId,
+      parallel: 1,
+      fromCheckpoint: 'stable'
+    });
+
+    const nextManifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+
+    expect(result.success).toBe(true);
+    expect(result.restoredCheckpoint).toMatchObject({
+      taskId: 'T001',
+      status: 'passed'
+    });
+    expect(result.restoredTasks).toEqual(['T002', 'T003']);
+    expect(nextManifest.tasks.map((task) => task.status)).toEqual(['passed', 'passed', 'passed']);
+    expect(nextManifest.tasks[1].attempts).toBe(1);
+    expect(nextManifest.tasks[2].attempts).toBe(1);
+  });
+});