cc-devflow 4.3.0 → 4.5.0

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

@@ -0,0 +1,291 @@
+/**
+ * [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, env = {}) {
+  const result = spawnSync(process.execPath, [CLI_BIN, ...args], {
+    cwd,
+    encoding: 'utf8',
+    env: {
+      ...process.env,
+      ...env
+    }
+  });
+
+  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 does not bake project YAML output policy into managed Claude skills', () => {
+    const customSkillDir = path.join(repoRoot, '.claude', 'skills', 'custom-skill');
+    fs.mkdirSync(customSkillDir, { recursive: true });
+    fs.writeFileSync(path.join(customSkillDir, 'SKILL.md'), '# Custom Skill\n');
+    fs.mkdirSync(path.join(repoRoot, '.cc-devflow'), { recursive: true });
+    fs.writeFileSync(
+      path.join(repoRoot, '.cc-devflow', 'config.yml'),
+      [
+        'version: 1',
+        'output:',
+        '  document_language: zh-CN',
+        'agent_preferences:',
+        '  general:',
+        '    - 先给结论。',
+        ''
+      ].join('\n')
+    );
+
+    const result = runCli(['init', '--dir', repoRoot], repoRoot);
+    expect(result.status).toBe(0);
+
+    const skillContent = fs.readFileSync(
+      path.join(repoRoot, '.claude', 'skills', 'cc-plan', 'SKILL.md'),
+      'utf8'
+    );
+
+    expect(skillContent).not.toContain('<!-- CC-DEVFLOW OUTPUT POLICY START -->');
+    expect(skillContent).not.toContain('文档语言: zh-CN');
+    expect(skillContent).toContain('cc-devflow config resolve --format policy');
+    expect(fs.readFileSync(path.join(customSkillDir, 'SKILL.md'), 'utf8')).toBe('# Custom Skill\n');
+  });
+
+  test('config commands manage and diagnose the effective output policy', () => {
+    fs.mkdirSync(path.join(repoRoot, '.cc-devflow'), { recursive: true });
+    fs.writeFileSync(
+      path.join(repoRoot, '.cc-devflow', 'config.yml'),
+      [
+        'version: 1',
+        'output:',
+        '  document_language: zh-CN',
+        ''
+      ].join('\n')
+    );
+
+    const resolveResult = runCli(
+      ['config', 'resolve', '--cwd', repoRoot, '--format', 'policy', '--trace'],
+      repoRoot
+    );
+    const getResult = runCli(['config', 'get', 'output.document_language', '--cwd', repoRoot], repoRoot);
+    const doctorResult = runCli(['config', 'doctor', '--cwd', repoRoot], repoRoot);
+
+    expect(resolveResult.status).toBe(0);
+    expect(resolveResult.stdout).toContain('CC-DevFlow Output Policy');
+    expect(resolveResult.stdout).toContain('Output language: zh-CN');
+    expect(resolveResult.stdout).toContain('Trace:');
+    expect(resolveResult.stdout).toContain('project');
+    expect(getResult.status).toBe(0);
+    expect(getResult.stdout.trim()).toBe('zh-CN');
+    expect(doctorResult.status).toBe(0);
+    expect(doctorResult.stdout).toContain('Config OK');
+
+    const setResult = runCli(
+      ['config', 'set', 'output.document_language', 'en', '--cwd', repoRoot, '--project'],
+      repoRoot
+    );
+    expect(setResult.status).toBe(0);
+    expect(runCli(['config', 'get', 'output.document_language', '--cwd', repoRoot], repoRoot).stdout.trim()).toBe('en');
+
+    const isolatedHome = path.join(repoRoot, 'home');
+    const userInitResult = runCli(
+      ['config', 'init', '--cwd', repoRoot, '--user', '--force'],
+      repoRoot,
+      { HOME: isolatedHome }
+    );
+    expect(userInitResult.status).toBe(0);
+    expect(userInitResult.stdout).toContain(path.join(isolatedHome, '.cc-devflow', 'config.yml'));
+  });
+
+  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 mirrors Codex skills without baking project YAML output policy', () => {
+    fs.mkdirSync(path.join(repoRoot, '.cc-devflow'), { recursive: true });
+    fs.writeFileSync(
+      path.join(repoRoot, '.cc-devflow', 'config.yml'),
+      [
+        'version: 1',
+        'output:',
+        '  document_language: zh-CN',
+        'agent_preferences:',
+        '  documentation:',
+        '    - 输出文档默认使用中文。',
+        ''
+      ].join('\n')
+    );
+    expect(runCli(['init', '--dir', repoRoot], repoRoot).status).toBe(0);
+
+    const result = runCli(['adapt', '--cwd', repoRoot, '--platform', 'codex'], repoRoot);
+    expect(result.status).toBe(0);
+
+    const codexPlanSkill = fs.readFileSync(
+      path.join(repoRoot, '.codex', 'skills', 'cc-plan', 'SKILL.md'),
+      'utf8'
+    );
+    expect(codexPlanSkill).not.toContain('<!-- CC-DEVFLOW OUTPUT POLICY START -->');
+    expect(codexPlanSkill).not.toContain('文档语言: zh-CN');
+    expect(codexPlanSkill).toContain('cc-devflow config resolve --format policy');
+  });
+
+  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__/config.test.js

@@ -0,0 +1,161 @@
+/**
+ * [INPUT]: 临时 home/repo 配置、env 覆盖与 CLI 等价写入操作。
+ * [OUTPUT]: 验证运行时个人配置解析、校验、trace、policy 与写入行为。
+ * [POS]: skill runtime 个人配置的单元测试。
+ * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const {
+  LOCAL_CONFIG_RELATIVE_PATH,
+  PROJECT_CONFIG_RELATIVE_PATH,
+  USER_CONFIG_RELATIVE_PATH,
+  getConfigValue,
+  resolveUserConfig,
+  setConfigValue,
+  writeConfigTemplate
+} = require('../config.js');
+
+describe('skill-runtime user config', () => {
+  let tmpRoot;
+  let homeDir;
+  let repoRoot;
+
+  beforeEach(() => {
+    tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-runtime-config-'));
+    homeDir = path.join(tmpRoot, 'home');
+    repoRoot = path.join(tmpRoot, 'repo');
+    fs.mkdirSync(path.join(homeDir, '.cc-devflow'), { recursive: true });
+    fs.mkdirSync(path.join(repoRoot, '.cc-devflow'), { recursive: true });
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  });
+
+  test('resolves document language with default, file, env, and cli precedence trace', () => {
+    fs.writeFileSync(
+      path.join(homeDir, USER_CONFIG_RELATIVE_PATH),
+      [
+        'version: 1',
+        'output:',
+        '  document_language: en',
+        'agent_preferences:',
+        '  planning:',
+        '    - Keep plans short.',
+        ''
+      ].join('\n')
+    );
+    fs.writeFileSync(
+      path.join(repoRoot, PROJECT_CONFIG_RELATIVE_PATH),
+      [
+        'version: 1',
+        'output:',
+        '  document_language: zh-CN',
+        ''
+      ].join('\n')
+    );
+    fs.writeFileSync(
+      path.join(repoRoot, LOCAL_CONFIG_RELATIVE_PATH),
+      [
+        'version: 1',
+        'agent_preferences:',
+        '  review:',
+        '    order: severe-first',
+        ''
+      ].join('\n')
+    );
+
+    const result = resolveUserConfig({
+      cwd: repoRoot,
+      homeDir,
+      env: {
+        CC_DEVFLOW_DOCUMENT_LANGUAGE: 'en'
+      },
+      overrides: {
+        output: {
+          document_language: 'zh-CN'
+        }
+      }
+    });
+
+    expect(result.config.output.document_language).toBe('zh-CN');
+    expect(result.config.agent_preferences.planning).toEqual(['Keep plans short.']);
+    expect(result.config.agent_preferences.review.order).toBe('severe-first');
+    expect(result.sources.map((source) => source.kind)).toEqual(['user', 'project', 'local', 'env', 'cli']);
+    expect(result.trace.map((entry) => `${entry.source}:${entry.key}:${entry.value}`)).toEqual([
+      'default:version:1',
+      'default:output.document_language:en',
+      'user:version:1',
+      'user:output.document_language:en',
+      'user:agent_preferences.planning:["Keep plans short."]',
+      'project:version:1',
+      'project:output.document_language:zh-CN',
+      'local:version:1',
+      'local:agent_preferences.review.order:severe-first',
+      'env:output.document_language:en',
+      'cli:output.document_language:zh-CN'
+    ]);
+    expect(result.policy).toContain('Output language: zh-CN');
+    expect(result.policy).toContain('Machine-enforced fields: output.document_language');
+    expect(result.policy).toContain('Agent advisory preferences');
+  });
+
+  test('rejects unsupported language and unknown top-level fields', () => {
+    fs.writeFileSync(
+      path.join(repoRoot, PROJECT_CONFIG_RELATIVE_PATH),
+      [
+        'version: 1',
+        'output:',
+        '  document_language: klingon',
+        ''
+      ].join('\n')
+    );
+
+    expect(() => resolveUserConfig({ cwd: repoRoot, homeDir })).toThrow(/output.document_language/);
+
+    fs.writeFileSync(
+      path.join(repoRoot, PROJECT_CONFIG_RELATIVE_PATH),
+      [
+        'version: 1',
+        'preferences:',
+        '  general:',
+        '    - non standard root',
+        ''
+      ].join('\n')
+    );
+
+    expect(() => resolveUserConfig({ cwd: repoRoot, homeDir })).toThrow(/Unsupported config key/);
+  });
+
+  test('wraps invalid YAML errors with the config path', () => {
+    const configPath = path.join(repoRoot, PROJECT_CONFIG_RELATIVE_PATH);
+    fs.writeFileSync(configPath, 'version: 1\noutput:\n  document_language: [\n');
+
+    expect(() => resolveUserConfig({ cwd: repoRoot, homeDir })).toThrow(configPath);
+  });
+
+  test('reads and writes config values without losing advisory preferences', () => {
+    const configPath = writeConfigTemplate({ scope: 'project', cwd: repoRoot, homeDir });
+    expect(configPath).toBe(path.join(repoRoot, PROJECT_CONFIG_RELATIVE_PATH));
+
+    setConfigValue('output.document_language', 'en', { scope: 'project', cwd: repoRoot, homeDir });
+    setConfigValue('agent_preferences.documentation.voice', 'direct', {
+      scope: 'project',
+      cwd: repoRoot,
+      homeDir
+    });
+
+    const resolved = resolveUserConfig({ cwd: repoRoot, homeDir });
+
+    expect(getConfigValue(resolved.config, 'output.document_language')).toBe('en');
+    expect(getConfigValue(resolved.config, 'agent_preferences.documentation.voice')).toBe('direct');
+  });
+
+  test('rejects unknown config scopes instead of silently writing project config', () => {
+    expect(() => writeConfigTemplate({ scope: 'team', cwd: repoRoot, homeDir })).toThrow(/Unknown config scope/);
+  });
+});

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');
+  });
+});