@gavin-hjw/sddflow 0.3.2 → 0.3.3

package/dist/cli/init.js

@@ -1,11 +1,10 @@
 import { Command } from 'commander';
 import inquirer from 'inquirer';
-import { checkDependencies, tryAutoInstall, checkOpenSpecInitialized, writeState } from '../core/dependency-check.js';
+import { checkDependencies, tryAutoInstall, writeState, validateComponentInstallation, validateSuperpowersSkills, printInitPrerequisiteFailures, verifyOpenSpecInitIntegrity, runOpenSpecInit, printIntegrityFailures, } from '../core/dependency-check.js';
 import { generateSkills } from '../core/skill-generator.js';
-import { TOOL_PATHS, DEPS } from '../core/constants.js';
+import { DEPS, SUPERPOWERS_REQUIRED_SKILLS, OPENSPEC_INIT_MARKERS } from '../core/constants.js';
+import path from 'path';
 import { logger } from '../utils/logger.js';
-import { exec } from '../utils/shell.js';
-const SUPPORTED_TOOLS = Object.keys(TOOL_PATHS);
 export const initCommand = new Command('init')
     .description('Initialize sddflow skills in the current project')
     .option('-t, --tools <tools>', 'Target tools, comma-separated', 'claude')
@@ -17,8 +16,8 @@ export const initCommand = new Command('init')
     logger.blank();
     logger.info(`sddflow init — ${installGlobally ? 'global skill setup' : 'workflow orchestrator setup'}`);
     logger.blank();
-    // Step 1: Check OpenSpec
-    logger.step('Checking OpenSpec ...');
+    // ── 阶段 1：检测 OpenSpec CLI + Superpowers 插件 ──
+    logger.step('[1/4] Checking OpenSpec CLI ...');
     let depStatus = checkDependencies({ cwd, tools });
     if (!depStatus.openspec.installed) {
         logger.warn('OpenSpec CLI not installed');
@@ -26,72 +25,105 @@ export const initCommand = new Command('init')
             {
                 type: 'confirm',
                 name: 'installOpenSpec',
-                message: `Auto-install? (npm install -g ${DEPS.openspec.npmPkg}@latest)`,
+                message: `Auto-install? (${DEPS.openspec.installHint})`,
                 default: true,
             },
         ]);
         if (installOpenSpec) {
             const ok = tryAutoInstall(DEPS.openspec.npmPkg);
-            depStatus = checkDependencies({ cwd, tools }); // recheck
+            depStatus = checkDependencies({ cwd, tools });
             if (ok)
                 depStatus.openspec.autoInstalled = true;
         }
-        else {
-            logger.warn('Skipped OpenSpec install — spec phase will use manual fallback');
-        }
     }
     else {
         logger.success(`OpenSpec CLI installed${depStatus.openspec.version ? ` (v${depStatus.openspec.version})` : ''}`);
     }
-    // Step 2: Check Superpowers
-    logger.step('Checking Superpowers ...');
-    if (!depStatus.superpowers.installed) {
-        logger.warn('Superpowers not installed');
-        logger.info(DEPS.superpowers.installHint);
-        logger.info('Re-run sddflow init after installing, or build phase will use manual fallback');
+    logger.step('[1/4] Checking Superpowers plugin ...');
+    if (depStatus.superpowers.pluginInstalled) {
+        logger.success('Superpowers plugin installed');
     }
     else {
-        logger.success(`Superpowers installed${depStatus.superpowers.path ? ` (${depStatus.superpowers.path})` : ''}`);
+        logger.warn('Superpowers plugin not found');
+    }
+    const componentFailures = validateComponentInstallation(depStatus, tools);
+    if (componentFailures.length > 0) {
+        printInitPrerequisiteFailures(componentFailures);
+        process.exit(1);
     }
+    // ── 阶段 2：检测 Superpowers 必需 skills ──
+    logger.step('[2/4] Checking Superpowers required skills ...');
+    for (const skill of depStatus.superpowers.skills) {
+        if (skill.installed) {
+            logger.success(`  /${skill.name}${skill.path ? ` (${skill.path})` : ''}`);
+        }
+        else {
+            logger.warn(`  /${skill.name} — missing`);
+        }
+    }
+    const skillFailures = validateSuperpowersSkills(depStatus, tools);
+    if (skillFailures.length > 0) {
+        printInitPrerequisiteFailures(skillFailures);
+        process.exit(1);
+    }
+    // ── 阶段 3：自动执行 openspec init ──
     if (installGlobally) {
-        logger.step('Skipping project OpenSpec initialization for global install');
+        logger.step('[3/4] Skipping project OpenSpec init for global install');
     }
     else {
-        // Step 3: Check if OpenSpec is initialized in project
-        logger.step('Checking project OpenSpec initialization ...');
-        if (!checkOpenSpecInitialized(cwd)) {
-            if (depStatus.openspec.installed) {
-                const { initOpenSpec } = await inquirer.prompt([
+        logger.step('[3/4] Running openspec init ...');
+        let integrity = verifyOpenSpecInitIntegrity(cwd, tools);
+        if (integrity.ok) {
+            logger.success('OpenSpec already initialized in this project');
+        }
+        else {
+            logger.info(`Running: openspec init --tools ${tools.join(',')}`);
+            const ok = runOpenSpecInit(cwd, tools);
+            if (!ok) {
+                printInitPrerequisiteFailures([
                     {
-                        type: 'confirm',
-                        name: 'initOpenSpec',
-                        message: 'OpenSpec not initialized in this project. Run openspec init?',
-                        default: true,
+                        id: 'openspec-init',
+                        name: 'OpenSpec Init',
+                        reason: 'openspec init 执行失败',
+                        installSteps: [
+                            `请手动执行: openspec init --tools ${tools.join(',')}`,
+                            `完成后重新运行: sddflow init --tools ${tools.join(',')}`,
+                        ],
                     },
                 ]);
-                if (initOpenSpec) {
-                    const toolsFlag = tools.map((t) => t).join(',');
-                    exec(`openspec init --tools ${toolsFlag}`, { stdio: 'inherit' });
-                    logger.success('OpenSpec project initialized');
-                }
-            }
-            else {
-                logger.info('OpenSpec not initialized — directories will be auto-created on first /sddflow proposal');
+                process.exit(1);
             }
+            logger.success('openspec init completed');
         }
-        else {
-            logger.success('OpenSpec project initialized');
+        // ── 阶段 4：校验 OpenSpec 初始化完整性 ──
+        logger.step('[4/4] Verifying OpenSpec init integrity ...');
+        integrity = verifyOpenSpecInitIntegrity(cwd, tools);
+        if (!integrity.ok) {
+            printIntegrityFailures(integrity, tools);
+            process.exit(1);
+        }
+        logger.success('OpenSpec init integrity check passed');
+        for (const tool of tools) {
+            const markers = OPENSPEC_INIT_MARKERS[tool] ?? [];
+            for (const marker of markers) {
+                const { fileExists: fe } = await import('../utils/shell.js');
+                const fp = path.join(cwd, marker);
+                if (fe(fp)) {
+                    logger.info(`  ✓ ${marker}`);
+                    break;
+                }
+            }
         }
     }
-    // Step 4: Generate skills
+    // ── 生成 sddflow skills ──
     logger.step('Generating sddflow skills ...');
+    depStatus = checkDependencies({ cwd, tools });
     generateSkills({ cwd, tools, depStatus, global: installGlobally });
     if (!installGlobally) {
-        // Step 5: Write state
         writeState(cwd, {
             openspec: depStatus.openspec.installed,
-            superpowers: depStatus.superpowers.installed,
-            openspecProjectInitialized: checkOpenSpecInitialized(cwd),
+            superpowers: depStatus.superpowers.allSkillsInstalled,
+            openspecProjectInitialized: verifyOpenSpecInitIntegrity(cwd, tools).ok,
             createdAt: new Date().toISOString(),
             tools,
         });
@@ -99,13 +131,12 @@ export const initCommand = new Command('init')
     logger.blank();
     logger.success('sddflow initialized!');
     logger.blank();
-    if (!depStatus.superpowers.installed) {
-        logger.warn('Note: Superpowers not installed — /sddflow build will use manual execution mode');
-        logger.info(`  Install with: ${DEPS.superpowers.installHint}`);
-        logger.blank();
+    logger.info(`Verified Superpowers skills (${SUPERPOWERS_REQUIRED_SKILLS.length}):`);
+    for (const skill of SUPERPOWERS_REQUIRED_SKILLS) {
+        logger.info(`  /${skill}`);
     }
+    logger.blank();
     logger.info('Available commands:');
-    logger.info('  /sddflow proposal      Quick requirement capture');
     logger.info('  /sddflow brainstorming  Deep design exploration');
     logger.info('  /sddflow spec           Generate specs + translate');
     logger.info('  /sddflow amend          Revise requirements before close');

package/dist/cli/status.js

@@ -1,7 +1,8 @@
 import { Command } from 'commander';
 import path from 'path';
 import fs from 'fs';
-import { checkDependencies, readState, checkOpenSpecInitialized } from '../core/dependency-check.js';
+import { checkDependencies, readState, verifyOpenSpecInitIntegrity, } from '../core/dependency-check.js';
+import { formatChangeWorkflowStatus, getChangeWorkflowStatus } from '../core/change-status.js';
 import { logger } from '../utils/logger.js';
 import { dirExists } from '../utils/shell.js';
 export const statusCommand = new Command('status')
@@ -12,7 +13,6 @@ export const statusCommand = new Command('status')
     logger.info('sddflow status');
     logger.blank();
     const state = readState(cwd);
-    // Dependencies
     logger.step('Dependencies:');
     const depStatus = checkDependencies({ cwd, tools: state?.tools });
     if (depStatus.openspec.installed) {
@@ -21,14 +21,21 @@ export const statusCommand = new Command('status')
     else {
         logger.warn('OpenSpec CLI — not installed');
     }
-    if (depStatus.superpowers.installed) {
-        logger.success(`Superpowers${depStatus.superpowers.path ? ` (${depStatus.superpowers.path})` : ''}`);
+    if (depStatus.superpowers.pluginInstalled) {
+        logger.success('Superpowers plugin');
     }
     else {
-        logger.warn('Superpowers — not installed (build phase will use manual mode)');
+        logger.warn('Superpowers plugin — not installed');
+    }
+    for (const skill of depStatus.superpowers.skills) {
+        if (skill.installed) {
+            logger.success(`  /${skill.name}${skill.path ? ` (${skill.path})` : ''}`);
+        }
+        else {
+            logger.warn(`  /${skill.name} — missing`);
+        }
     }
     logger.blank();
-    // Project state
     logger.step('Project:');
     if (state) {
         logger.success(`Initialized (${state.tools.join(', ')})`);
@@ -38,14 +45,17 @@ export const statusCommand = new Command('status')
         logger.warn('Not initialized — run sddflow init');
         return;
     }
-    if (checkOpenSpecInitialized(cwd)) {
-        logger.success('OpenSpec project initialized');
+    const integrity = verifyOpenSpecInitIntegrity(cwd, state.tools);
+    if (integrity.ok) {
+        logger.success('OpenSpec project initialized (integrity OK)');
     }
     else {
-        logger.warn('OpenSpec project not initialized');
+        logger.warn(`OpenSpec init incomplete — missing ${integrity.missing.length} file(s)`);
+        for (const file of integrity.missing) {
+            logger.info(`  - ${file}`);
+        }
     }
     logger.blank();
-    // Active changes
     logger.step('Active changes:');
     const changesDir = path.join(cwd, 'openspec', 'changes');
     if (!dirExists(changesDir)) {
@@ -59,20 +69,8 @@ export const statusCommand = new Command('status')
         return;
     }
     for (const entry of entries) {
-        const changeDir = path.join(changesDir, entry.name);
-        const hasPlanReady = fs.existsSync(path.join(changeDir, 'plan-ready.md'));
-        const hasProposal = fs.existsSync(path.join(changeDir, 'proposal.md'));
-        let status = '';
-        if (hasPlanReady) {
-            status = '→ ready for /sddflow build or /sddflow amend';
-        }
-        else if (hasProposal) {
-            status = '→ needs /sddflow spec';
-        }
-        else {
-            status = '→ needs /sddflow proposal';
-        }
-        logger.info(`  ${entry.name} ${status}`);
+        const workflowStatus = getChangeWorkflowStatus(cwd, entry.name);
+        logger.info(`  ${entry.name} ${formatChangeWorkflowStatus(workflowStatus)}`);
     }
     logger.blank();
 });

package/dist/cli/update.js

@@ -1,5 +1,5 @@
 import { Command } from 'commander';
-import { checkDependencies, readState, writeState, checkOpenSpecInitialized } from '../core/dependency-check.js';
+import { checkDependencies, readState, writeState, verifyOpenSpecInitIntegrity } from '../core/dependency-check.js';
 import { generateSkills } from '../core/skill-generator.js';
 import { logger } from '../utils/logger.js';
 export const updateCommand = new Command('update')
@@ -23,8 +23,8 @@ export const updateCommand = new Command('update')
     writeState(cwd, {
         ...state,
         openspec: depStatus.openspec.installed,
-        superpowers: depStatus.superpowers.installed,
-        openspecProjectInitialized: checkOpenSpecInitialized(cwd),
+        superpowers: depStatus.superpowers.allSkillsInstalled,
+        openspecProjectInitialized: verifyOpenSpecInitIntegrity(cwd, state.tools).ok,
     });
     logger.blank();
     logger.success('Skills updated');

package/dist/core/change-status.d.ts

@@ -0,0 +1,9 @@
+export type ChangeWorkflowStatus = 'needs_brainstorming' | 'needs_spec' | 'needs_spec_plan' | 'ready_for_build' | 'build_in_progress' | 'ready_for_close';
+export declare function findPlanFileForChange(cwd: string, changeName: string): string | null;
+export declare function getPlanCheckboxStats(content: string): {
+    total: number;
+    done: number;
+    complete: boolean;
+};
+export declare function getChangeWorkflowStatus(cwd: string, changeName: string): ChangeWorkflowStatus;
+export declare function formatChangeWorkflowStatus(status: ChangeWorkflowStatus): string;

package/dist/core/change-status.js

@@ -0,0 +1,66 @@
+import fs from 'fs';
+import path from 'path';
+import { dirExists } from '../utils/shell.js';
+const PLANS_DIR = 'docs/superpowers/plans';
+export function findPlanFileForChange(cwd, changeName) {
+    const plansDir = path.join(cwd, PLANS_DIR);
+    if (!dirExists(plansDir))
+        return null;
+    const suffix = `-${changeName}.md`;
+    const entries = fs.readdirSync(plansDir, { withFileTypes: true }).filter((e) => e.isFile());
+    const match = entries.find((e) => e.name.endsWith(suffix) || e.name.includes(changeName));
+    return match ? path.join(plansDir, match.name) : null;
+}
+export function getPlanCheckboxStats(content) {
+    const checkboxRe = /^-\s+\[([ xX])\]/gm;
+    let total = 0;
+    let done = 0;
+    let m;
+    while ((m = checkboxRe.exec(content)) !== null) {
+        total += 1;
+        if (m[1].toLowerCase() === 'x')
+            done += 1;
+    }
+    return {
+        total,
+        done,
+        complete: total > 0 && done === total,
+    };
+}
+export function getChangeWorkflowStatus(cwd, changeName) {
+    const changeDir = path.join(cwd, 'openspec', 'changes', changeName);
+    const hasProposal = fs.existsSync(path.join(changeDir, 'proposal.md'));
+    const hasPlanReady = fs.existsSync(path.join(changeDir, 'plan-ready.md'));
+    const planPath = findPlanFileForChange(cwd, changeName);
+    if (!hasProposal)
+        return 'needs_brainstorming';
+    if (!hasPlanReady)
+        return 'needs_spec';
+    if (!planPath)
+        return 'needs_spec_plan';
+    const planContent = fs.readFileSync(planPath, 'utf-8');
+    const { total, done, complete } = getPlanCheckboxStats(planContent);
+    if (total === 0)
+        return 'needs_spec_plan';
+    if (complete)
+        return 'ready_for_close';
+    if (done > 0)
+        return 'build_in_progress';
+    return 'ready_for_build';
+}
+export function formatChangeWorkflowStatus(status) {
+    switch (status) {
+        case 'needs_brainstorming':
+            return '→ needs /sddflow brainstorming';
+        case 'needs_spec':
+            return '→ needs /sddflow spec';
+        case 'needs_spec_plan':
+            return '→ needs /sddflow spec (missing plan-ready or docs/superpowers/plans)';
+        case 'ready_for_build':
+            return '→ ready for /sddflow build';
+        case 'build_in_progress':
+            return '→ build in progress (/sddflow build to resume)';
+        case 'ready_for_close':
+            return '→ ready for /sddflow close';
+    }
+}

package/dist/core/constants.d.ts

@@ -12,11 +12,23 @@ export declare const DEPS: {
     };
     readonly superpowers: {
         readonly name: "Superpowers";
-        readonly checkPath: "writing-plans/SKILL.md";
-        readonly installHint: "请在当前工具中安装 Superpowers writing-plans skill（Claude Code: /plugin install superpowers@claude-plugins-official）";
+        readonly installHint: "请在当前工具中安装 Superpowers 插件";
         readonly autoInstallable: false;
     };
 };
+/** sddflow 工作流依赖的 Superpowers skills */
+export declare const SUPERPOWERS_REQUIRED_SKILLS: readonly ["brainstorming", "writing-plans", "subagent-driven-development", "test-driven-development", "verification-before-completion", "finishing-a-development-branch"];
+export type SuperpowersRequiredSkill = (typeof SUPERPOWERS_REQUIRED_SKILLS)[number];
+/**
+ * openspec init 为各工具生成的 skill/command 标记文件。
+ * 只要其中任意一个存在，就视为 openspec init 已成功执行过。
+ * key = tool name，value = 相对项目根的路径列表（任意一个存在即可）
+ */
+export declare const OPENSPEC_INIT_MARKERS: Record<string, string[]>;
+/** 各工具安装 Superpowers 的具体指引 */
+export declare const SUPERPOWERS_INSTALL_HINTS: Record<string, string[]>;
+/** 各工具 Superpowers 插件缓存目录 */
+export declare const SUPERPOWERS_PLUGIN_CACHE_DIRS: Record<string, string>;
 export declare const TOOL_PATHS: Record<string, {
     skillsDir: string;
     commandsDir?: string;

package/dist/core/constants.js

@@ -12,11 +12,69 @@ export const DEPS = {
     },
     superpowers: {
         name: 'Superpowers',
-        checkPath: 'writing-plans/SKILL.md',
-        installHint: '请在当前工具中安装 Superpowers writing-plans skill（Claude Code: /plugin install superpowers@claude-plugins-official）',
+        installHint: '请在当前工具中安装 Superpowers 插件',
         autoInstallable: false,
     },
 };
+/** sddflow 工作流依赖的 Superpowers skills */
+export const SUPERPOWERS_REQUIRED_SKILLS = [
+    'brainstorming',
+    'writing-plans',
+    'subagent-driven-development',
+    'test-driven-development',
+    'verification-before-completion',
+    'finishing-a-development-branch',
+];
+/**
+ * openspec init 为各工具生成的 skill/command 标记文件。
+ * 只要其中任意一个存在，就视为 openspec init 已成功执行过。
+ * key = tool name，value = 相对项目根的路径列表（任意一个存在即可）
+ */
+export const OPENSPEC_INIT_MARKERS = {
+    claude: [
+        '.claude/skills/openspec-propose/SKILL.md',
+        '.claude/commands/opsx/propose.md',
+        '.claude/commands/openspec/proposal.md',
+        '.claude/commands/openspec/archive.md',
+    ],
+    cursor: [
+        '.cursor/skills/openspec-propose/SKILL.md',
+        '.cursor/commands/opsx/propose.md',
+        '.cursor/commands/openspec/proposal.md',
+        '.cursor/commands/openspec/archive.md',
+    ],
+    codex: [
+        '.codex/skills/openspec-propose/SKILL.md',
+        '.codex/commands/opsx/propose.md',
+        '.codex/commands/openspec/proposal.md',
+        '.codex/commands/openspec/archive.md',
+    ],
+    opencode: [
+        '.opencode/commands/opsx/propose.md',
+        '.opencode/commands/openspec/proposal.md',
+        '.opencode/commands/openspec/archive.md',
+    ],
+};
+/** 各工具安装 Superpowers 的具体指引 */
+export const SUPERPOWERS_INSTALL_HINTS = {
+    claude: [
+        '在 Claude Code 中执行: /plugin install superpowers@claude-plugins-official',
+    ],
+    cursor: [
+        '在 Cursor 中安装 Superpowers 插件（Settings → Plugins → superpowers）',
+    ],
+    codex: [
+        '在 Codex 中安装 Superpowers 插件',
+    ],
+    opencode: [
+        '在 OpenCode 中安装 Superpowers 插件',
+    ],
+};
+/** 各工具 Superpowers 插件缓存目录 */
+export const SUPERPOWERS_PLUGIN_CACHE_DIRS = {
+    claude: '.claude/plugins/cache/claude-plugins-official/superpowers',
+    cursor: '.cursor/plugins/cache/cursor-public/superpowers',
+};
 export const TOOL_PATHS = {
     claude: {
         skillsDir: '.claude/skills',

package/dist/core/dependency-check.d.ts

@@ -1,3 +1,9 @@
+import { type SuperpowersRequiredSkill } from './constants.js';
+export interface SuperpowersSkillStatus {
+    name: SuperpowersRequiredSkill;
+    installed: boolean;
+    path?: string;
+}
 export interface DepStatus {
     openspec: {
         installed: boolean;
@@ -5,17 +11,37 @@ export interface DepStatus {
         autoInstalled?: boolean;
     };
     superpowers: {
+        pluginInstalled: boolean;
+        skills: SuperpowersSkillStatus[];
+        allSkillsInstalled: boolean;
+        /** 兼容旧字段：等同 allSkillsInstalled */
         installed: boolean;
-        hint?: string;
-        path?: string;
-        checkedPaths: string[];
     };
 }
+export interface InitPrerequisiteFailure {
+    id: 'openspec-cli' | 'superpowers-plugin' | 'superpowers-skills' | 'openspec-init';
+    name: string;
+    reason: string;
+    installSteps: string[];
+}
+export interface IntegrityCheckResult {
+    ok: boolean;
+    missing: string[];
+}
 export interface CheckDependencyOptions {
     cwd?: string;
     tools?: string[];
 }
 export declare function checkDependencies(options?: CheckDependencyOptions): DepStatus;
+export declare function checkSuperpowersSkills(cwd: string, home: string, tools: string[]): SuperpowersSkillStatus[];
+/** 阶段 1：检测 OpenSpec CLI + Superpowers 插件是否已安装 */
+export declare function validateComponentInstallation(depStatus: DepStatus, tools: string[]): InitPrerequisiteFailure[];
+/** 阶段 2：检测 Superpowers 必需 skills 是否齐全 */
+export declare function validateSuperpowersSkills(depStatus: DepStatus, tools: string[]): InitPrerequisiteFailure[];
+export declare function verifyOpenSpecInitIntegrity(cwd: string, tools: string[]): IntegrityCheckResult;
+export declare function runOpenSpecInit(cwd: string, tools: string[]): boolean;
+export declare function printInitPrerequisiteFailures(failures: InitPrerequisiteFailure[], title?: string): void;
+export declare function printIntegrityFailures(result: IntegrityCheckResult, tools: string[]): void;
 export declare function tryAutoInstall(pkg: string): boolean;
 export declare function checkOpenSpecInitialized(cwd: string): boolean;
 export interface InitState {