cc-devflow 4.2.0 → 4.4.1

package/lib/compiler/skills-registry.js

@@ -11,7 +11,6 @@
 const fs = require('fs');
 const path = require('path');
 const matter = require('gray-matter');
-const { discoverSkillEntries } = require('./skill-discovery.js');
 
 // ============================================================
 // Constants
@@ -19,24 +18,197 @@ const { discoverSkillEntries } = require('./skill-discovery.js');
 const REGISTRY_VERSION = '1.0';
 const REGISTRY_OUTPUT_PATH = 'devflow/.generated/skills-registry.json';
 
+function toRepoRelativePath(absolutePath) {
+  return path.relative(process.cwd(), absolutePath).split(path.sep).join('/');
+}
+
+function normalizeBundledReadPaths(value, skillDir) {
+  return normalizeStringList(value).map((entry) => {
+    if (path.isAbsolute(entry)) {
+      return entry;
+    }
+
+    const bundledPath = path.join(skillDir, entry);
+    if (fs.existsSync(bundledPath)) {
+      return toRepoRelativePath(bundledPath);
+    }
+
+    return entry;
+  });
+}
+
+function normalizeStringList(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+
+  return value
+    .map((item) => String(item || '').trim())
+    .filter(Boolean);
+}
+
+function normalizeReroutes(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+
+  return value
+    .map((item) => {
+      if (!item || typeof item !== 'object') {
+        return null;
+      }
+
+      const when = String(item.when || '').trim();
+      const target = String(item.target || '').trim();
+      if (!when || !target) {
+        return null;
+      }
+
+      return { when, target };
+    })
+    .filter(Boolean);
+}
+
+function normalizeRecoveryModes(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+
+  return value
+    .map((item) => {
+      if (!item || typeof item !== 'object') {
+        return null;
+      }
+
+      const name = String(item.name || '').trim();
+      const when = String(item.when || '').trim();
+      const action = String(item.action || '').trim();
+      if (!name || !when || !action) {
+        return null;
+      }
+
+      return { name, when, action };
+    })
+    .filter(Boolean);
+}
+
+function normalizeToolBudget(value) {
+  const source = value && typeof value === 'object' ? value : {};
+  const normalized = {};
+
+  for (const key of ['read_files', 'search_steps', 'shell_commands']) {
+    const next = Number(source[key]);
+    if (Number.isFinite(next) && next >= 0) {
+      normalized[key] = next;
+    }
+  }
+
+  return normalized;
+}
+
+function normalizeEffects(value) {
+  return normalizeStringList(value);
+}
+
+function normalizeWrites(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+
+  return value
+    .map((item) => {
+      if (typeof item === 'string') {
+        const pathValue = item.trim();
+        if (!pathValue) {
+          return null;
+        }
+
+        return {
+          path: pathValue,
+          durability: 'durable',
+          required: true
+        };
+      }
+
+      if (!item || typeof item !== 'object') {
+        return null;
+      }
+
+      const pathValue = String(item.path || '').trim();
+      if (!pathValue) {
+        return null;
+      }
+
+      const durability = String(item.durability || 'durable').trim();
+      const when = String(item.when || '').trim();
+      const exclusiveGroup = String(item.exclusive_group || item.exclusiveGroup || '').trim();
+      const required =
+        typeof item.required === 'boolean'
+          ? item.required
+          : !when && !exclusiveGroup;
+
+      const normalized = {
+        path: pathValue,
+        durability,
+        required
+      };
+
+      if (when) {
+        normalized.when = when;
+      }
+
+      if (exclusiveGroup) {
+        normalized.exclusiveGroup = exclusiveGroup;
+      }
+
+      return normalized;
+    })
+    .filter(Boolean);
+}
+
 // ============================================================
 // generateSkillsRegistry - 保留向后兼容
 // ============================================================
 function generateSkillsRegistry(skillsDir) {
   const registry = [];
-  const skillEntries = discoverSkillEntries(skillsDir);
+  const absoluteDir = path.resolve(skillsDir);
+
+  if (!fs.existsSync(absoluteDir)) {
+    return registry;
+  }
+
+  const entries = fs.readdirSync(absoluteDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith('_')) {
+      continue;
+    }
+
+    const skillDir = path.join(absoluteDir, entry.name);
+    const skillMdPath = path.join(skillDir, 'SKILL.md');
+
+    if (!fs.existsSync(skillMdPath)) {
+      continue;
+    }
 
-  for (const entry of skillEntries) {
     try {
-      const skillMdContent = fs.readFileSync(entry.skillMdPath, 'utf8');
+      const skillMdContent = fs.readFileSync(skillMdPath, 'utf8');
       const parsed = matter(skillMdContent);
 
       registry.push({
         name: parsed.data.name || entry.name,
         description: parsed.data.description || '',
         type: parsed.data.type || 'utility',
-        path: entry.skillDir,
-        triggers: []
+        path: skillDir,
+        triggers: normalizeStringList(parsed.data.triggers),
+        reads: normalizeBundledReadPaths(parsed.data.reads, skillDir),
+        writes: normalizeWrites(parsed.data.writes),
+        effects: normalizeEffects(parsed.data.effects),
+        entryGate: normalizeStringList(parsed.data.entry_gate),
+        exitCriteria: normalizeStringList(parsed.data.exit_criteria),
+        reroutes: normalizeReroutes(parsed.data.reroutes),
+        recoveryModes: normalizeRecoveryModes(parsed.data.recovery_modes),
+        toolBudget: normalizeToolBudget(parsed.data.tool_budget)
       });
     } catch (error) {
       console.warn(`Warning: Failed to parse skill ${entry.name}: ${error.message}`);
@@ -66,12 +238,29 @@ async function generateSkillsRegistryV2(skillsDir) {
     }
   }
 
-  // 扫描技能目录（支持分组与非分组结构）
-  const entries = discoverSkillEntries(absoluteDir);
+  // 扫描技能目录
+  if (!fs.existsSync(absoluteDir)) {
+    return createRegistry(skills);
+  }
+
+  const entries = fs.readdirSync(absoluteDir, { withFileTypes: true });
 
   for (const entry of entries) {
+    // 跳过非目录和 _ 前缀目录
+    if (!entry.isDirectory() || entry.name.startsWith('_')) {
+      continue;
+    }
+
+    const skillDir = path.join(absoluteDir, entry.name);
+    const skillMdPath = path.join(skillDir, 'SKILL.md');
+
+    // 必须有 SKILL.md
+    if (!fs.existsSync(skillMdPath)) {
+      continue;
+    }
+
     try {
-      const skillEntry = parseSkillEntry(entry.name, entry.skillDir, entry.skillMdPath, skillRules);
+      const skillEntry = parseSkillEntry(entry.name, skillDir, skillMdPath, skillRules);
       if (skillEntry) {
         skills.push(skillEntry);
       }
@@ -100,8 +289,16 @@ function parseSkillEntry(skillName, _skillDir, skillMdPath, skillRules) {
     type: ruleConfig.type || parsed.data.type || 'utility',
     enforcement: ruleConfig.enforcement || 'suggest',
     priority: ruleConfig.priority || 'medium',
-    skillPath: path.relative(process.cwd(), skillMdPath),
-    triggers: buildTriggers(ruleConfig)
+    skillPath: toRepoRelativePath(skillMdPath),
+    triggers: buildTriggers(ruleConfig, parsed.data.triggers),
+    reads: normalizeBundledReadPaths(parsed.data.reads, path.dirname(skillMdPath)),
+    writes: normalizeWrites(parsed.data.writes),
+    effects: normalizeEffects(parsed.data.effects),
+    entryGate: normalizeStringList(parsed.data.entry_gate),
+    exitCriteria: normalizeStringList(parsed.data.exit_criteria),
+    reroutes: normalizeReroutes(parsed.data.reroutes),
+    recoveryModes: normalizeRecoveryModes(parsed.data.recovery_modes),
+    toolBudget: normalizeToolBudget(parsed.data.tool_budget)
   };
 
   return entry;
@@ -110,14 +307,15 @@ function parseSkillEntry(skillName, _skillDir, skillMdPath, skillRules) {
 // ============================================================
 // buildTriggers - 构建触发器结构
 // ============================================================
-function buildTriggers(ruleConfig) {
+function buildTriggers(ruleConfig, frontmatterTriggers = []) {
   const triggers = {};
+  const promptKeywords = normalizeStringList(frontmatterTriggers);
 
   // Prompt triggers
-  if (ruleConfig.promptTriggers) {
+  if (ruleConfig.promptTriggers || promptKeywords.length > 0) {
     triggers.prompt = {
-      keywords: ruleConfig.promptTriggers.keywords || [],
-      intentPatterns: ruleConfig.promptTriggers.intentPatterns || []
+      keywords: [...new Set([...(ruleConfig.promptTriggers?.keywords || []), ...promptKeywords])],
+      intentPatterns: ruleConfig.promptTriggers?.intentPatterns || []
     };
   }
 

package/lib/compiler/transformer.js

@@ -1,7 +1,7 @@
 /**
  * T028: Transformer Module
  *
- * Transforms CommandIR for target platforms:
+ * Transforms PromptIR for target platforms:
  * - Expands {SCRIPT:alias} to "bash <path>"
  * - Inlines {TEMPLATE:alias} with template file content
  * - Inlines {GUIDE:alias} with guide file content

package/lib/skill-runtime/CLAUDE.md

@@ -0,0 +1,19 @@
+# skill-runtime/
+> L2 | 父级: ../../CLAUDE.md
+
+职责分组
+入口层: `cli.js` 负责命令分发，`index.js` 提供给测试和内部脚本的稳定聚合入口。
+基础层: `schemas.js`、`store.js`、`paths.js` 管住契约、持久化与路径规则，避免执行层重复造轮子。
+状态层: `artifacts.js`、`lifecycle.js`、`query.js`、`review.js`、`team-state.js` 维护运行时真相源与只读查询。
+规划与交接: `planner.js`、`intent.js`、`delegation.js` 把任务解析、handoff 生成和 team/workspace 委派收口成统一语义。
+阶段操作: `operations/` 是唯一 stage 入口目录；具体阶段边界见 `operations/CLAUDE.md`。
+测试布局: `__tests__/` 紧贴模块放置单元、回归与集成测试；顶层 `test/` 不再承载 `skill-runtime` 私有测试。
+
+更新规则
+只在职责边界变化时更新此头部，不为每个新增文件补一条手写目录索引。
+新增文件优先归入现有分组；如果放不进去，先反思分层是否失真，再决定是否扩展分组。
+测试命名要表达语义，例如 `*.integration.test.js`、`*.tdd.test.js`；文档不维护穷举名单。
+
+法则: 职责先于文件名·分组先于清单·父级链接稳定
+
+[PROTOCOL]: 变更职责边界或目录约定时更新此头部，然后检查 CLAUDE.md

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

@@ -0,0 +1,210 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const { runAutopilot } = require('../operations/autopilot');
+const { runApprove } = require('../operations/approve');
+const {
+  getTasksMarkdownPath,
+  getTaskManifestPath,
+  getReportCardPath,
+  getReleaseNotePath,
+  getRuntimeStatePath,
+  getCheckpointPath
+} = require('../store');
+const {
+  getIntentResumeIndexPath,
+  getIntentPrBriefPath
+} = require('../artifacts');
+
+jest.setTimeout(20000);
+
+function writeJson(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function markManifestReviewsPassed(repoRoot, changeId) {
+  const manifestPath = getTaskManifestPath(repoRoot, changeId);
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+  manifest.tasks = manifest.tasks.map((task) => ({
+    ...task,
+    reviews: {
+      spec: 'pass',
+      code: 'pass'
+    }
+  }));
+  fs.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+}
+
+describe('runAutopilot', () => {
+  test('stops at the approval gate after planning without writing approval-phase handoff markdown', async () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-autopilot-'));
+
+    writeJson(path.join(repoRoot, 'package.json'), {
+      name: 'autopilot-smoke',
+      version: '1.0.0',
+      scripts: {
+        lint: 'node -e "process.exit(0)"',
+        typecheck: 'node -e "process.exit(0)"',
+        test: 'node -e "process.exit(0)"'
+      }
+    });
+
+    fs.mkdirSync(path.dirname(getTasksMarkdownPath(repoRoot, 'REQ-123')), { recursive: true });
+    fs.writeFileSync(
+      getTasksMarkdownPath(repoRoot, 'REQ-123'),
+      [
+        '- [ ] T001 启动 autopilot 闭环 (src/a.ts)',
+        '- [ ] T002 多文件委派任务 [P] (src/a.ts,src/b.ts)'
+      ].join('\n')
+    );
+
+    const result = await runAutopilot({
+      repoRoot,
+      changeId: 'REQ-123',
+      goal: 'Ship thin autopilot loop'
+    });
+
+    const runtimeState = JSON.parse(fs.readFileSync(getRuntimeStatePath(repoRoot, 'REQ-123'), 'utf8'));
+
+    expect(result.executed).toEqual(['init', 'snapshot', 'plan']);
+    expect(result.currentStage).toBe('approve');
+    expect(runtimeState.changeKey).toBe('REQ-123-change');
+    expect(fs.existsSync(getReportCardPath(repoRoot, 'REQ-123'))).toBe(false);
+    expect(fs.existsSync(getIntentPrBriefPath(repoRoot, 'REQ-123'))).toBe(false);
+    expect(fs.existsSync(getIntentResumeIndexPath(repoRoot, 'REQ-123'))).toBe(false);
+  });
+
+  test('resumes after approval, executes delegated work, and prepares a PR from checkpoints', async () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-autopilot-workers-'));
+
+    writeJson(path.join(repoRoot, 'package.json'), {
+      name: 'autopilot-worker-smoke',
+      version: '1.0.0',
+      scripts: {
+        lint: 'node -e "process.exit(0)"',
+        typecheck: 'node -e "process.exit(0)"',
+        test: 'node -e "process.exit(0)"'
+      }
+    });
+
+    fs.mkdirSync(path.dirname(getTasksMarkdownPath(repoRoot, 'REQ-123')), { recursive: true });
+    fs.writeFileSync(
+      getTasksMarkdownPath(repoRoot, 'REQ-123'),
+      [
+        '- [ ] T001 直接执行任务 (src/a.ts)',
+        '- [ ] T002 委派实现任务 [P] (src/a.ts,src/b.ts)'
+      ].join('\n')
+    );
+
+    await runAutopilot({
+      repoRoot,
+      changeId: 'REQ-123',
+      goal: 'Ship thin autopilot loop with delegated workers'
+    });
+
+    await runApprove({
+      repoRoot,
+      changeId: 'REQ-123',
+      executionMode: 'delegate'
+    });
+
+    const firstRun = await runAutopilot({
+      repoRoot,
+      changeId: 'REQ-123',
+      workerCommand: 'printf "delegate-ok"'
+    });
+
+    const manifest = JSON.parse(fs.readFileSync(getTaskManifestPath(repoRoot, 'REQ-123'), 'utf8'));
+    const delegatedCheckpoint = JSON.parse(fs.readFileSync(getCheckpointPath(repoRoot, 'REQ-123', 'T002'), 'utf8'));
+    const report = JSON.parse(fs.readFileSync(getReportCardPath(repoRoot, 'REQ-123'), 'utf8'));
+
+    expect(firstRun.executed).toEqual(expect.arrayContaining(['delegate', 'worker-run', 'dispatch', 'verify']));
+    expect(firstRun.currentStage).toBe('verify');
+    expect(manifest.tasks.find((task) => task.id === 'T002').status).toBe('passed');
+    expect(delegatedCheckpoint.outputExcerpt).toContain('delegate-ok');
+    expect(report.review.status).toBe('blocked');
+    expect(fs.existsSync(getIntentPrBriefPath(repoRoot, 'REQ-123'))).toBe(false);
+
+    markManifestReviewsPassed(repoRoot, 'REQ-123');
+
+    const secondRun = await runAutopilot({
+      repoRoot,
+      changeId: 'REQ-123',
+      from: 'verify',
+      skipReview: true
+    });
+
+    const prBrief = fs.readFileSync(getIntentPrBriefPath(repoRoot, 'REQ-123'), 'utf8');
+
+    expect(secondRun.executed).toEqual(expect.arrayContaining(['verify', 'prepare-pr']));
+    expect(secondRun.currentStage).toBe('prepare-pr');
+    expect(prBrief).toContain('execution/tasks/T002/checkpoint.json');
+  });
+
+  test('runs release after prepare-pr when requested for an approved plan', async () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-autopilot-release-'));
+
+    writeJson(path.join(repoRoot, 'package.json'), {
+      name: 'autopilot-release-smoke',
+      version: '1.0.0',
+      scripts: {
+        lint: 'node -e "process.exit(0)"',
+        typecheck: 'node -e "process.exit(0)"',
+        test: 'node -e "process.exit(0)"'
+      }
+    });
+
+    fs.mkdirSync(path.dirname(getTasksMarkdownPath(repoRoot, 'REQ-123')), { recursive: true });
+    fs.writeFileSync(
+      getTasksMarkdownPath(repoRoot, 'REQ-123'),
+      '- [ ] T001 发布前收尾 (src/a.ts)'
+    );
+
+    await runAutopilot({
+      repoRoot,
+      changeId: 'REQ-123',
+      goal: 'Ship thin autopilot loop and release'
+    });
+
+    await runApprove({
+      repoRoot,
+      changeId: 'REQ-123',
+      executionMode: 'direct'
+    });
+
+    const firstRun = await runAutopilot({
+      repoRoot,
+      changeId: 'REQ-123',
+      release: true
+    });
+
+    const manifest = JSON.parse(fs.readFileSync(getTaskManifestPath(repoRoot, 'REQ-123'), 'utf8'));
+    const report = JSON.parse(fs.readFileSync(getReportCardPath(repoRoot, 'REQ-123'), 'utf8'));
+
+    expect(firstRun.currentStage).toBe('verify');
+    expect(report.review.status).toBe('blocked');
+    expect(fs.existsSync(getReleaseNotePath(repoRoot, 'REQ-123'))).toBe(false);
+
+    markManifestReviewsPassed(repoRoot, 'REQ-123');
+
+    const result = await runAutopilot({
+      repoRoot,
+      changeId: 'REQ-123',
+      from: 'verify',
+      release: true,
+      skipReview: true
+    });
+
+    const runtimeState = JSON.parse(fs.readFileSync(getRuntimeStatePath(repoRoot, 'REQ-123'), 'utf8'));
+    const releaseNote = fs.readFileSync(getReleaseNotePath(repoRoot, 'REQ-123'), 'utf8');
+
+    expect(result.executed).toEqual(expect.arrayContaining(['verify', 'prepare-pr', 'release']));
+    expect(result.lifecycleStatus).toBe('released');
+    expect(runtimeState.status).toBe('released');
+    expect(releaseNote).toContain('Release Note - REQ-123');
+    expect(fs.existsSync(getIntentPrBriefPath(repoRoot, 'REQ-123'))).toBe(false);
+    expect(fs.existsSync(getIntentResumeIndexPath(repoRoot, 'REQ-123'))).toBe(false);
+  });
+});