@gavin-hjw/sddflow 0.3.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Emerson Towne
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,152 @@
+# @gavin-hjw/sddflow
+
+[中文文档](./README.zh-CN.md)
+
+OpenSpec + Superpowers workflow orchestrator — bridging requirements specs and engineering execution, eliminating the format gap.
+
+## Installation
+
+```bash
+npm install -g @gavin-hjw/sddflow
+```
+
+## Usage
+
+### Initialize a project
+
+```bash
+cd your-project
+sddflow init --tools claude
+```
+
+`init` will automatically:
+1. Detect and guide OpenSpec CLI installation
+2. Detect Superpowers and show install instructions
+3. Check if OpenSpec is initialized in the project
+4. Generate sddflow skills to the selected tools' local skill directories, such as `.claude/skills/sddflow/`, `.codex/skills/sddflow/`, `.cursor/skills/sddflow/`, or `.opencode/commands/sddflow/`
+
+Supported tools: `claude`, `codex`, `cursor`, `opencode` (comma-separated, e.g. `--tools claude,codex`)
+
+### Install skills globally
+
+```bash
+sddflow init --tools claude -g
+sddflow init --tools claude,codex,cursor,opencode --global
+```
+
+With `-g` / `--global`, `sddflow` installs skills under the selected tools' home directories:
+
+| Tool | Global skill path |
+|------|-------------------|
+| `claude` | `~/.claude/skills/sddflow/` |
+| `codex` | `~/.codex/skills/sddflow/` |
+| `cursor` | `~/.cursor/skills/sddflow/` |
+| `opencode` | `~/.opencode/commands/sddflow/` |
+
+### Check status
+
+```bash
+sddflow status
+```
+
+Shows dependency installation status and active changes in the project.
+
+### Update skills
+
+```bash
+sddflow update
+```
+
+Re-generates project skills after upgrading the npm package.
+
+## Workflow Commands
+
+Canonical usage is `/sddflow <phase>`. For Claude Code, Codex, and Cursor,
+`sddflow` also generates visible phase aliases such as `/sddflow-spec` or
+`$sddflow-spec` so typing `sddflow` in the command/skill picker surfaces the
+available phases. OpenCode keeps its native command-tree form under
+`/sddflow/spec`, `/sddflow/build`, and so on.
+
+| Command | Phase | Description |
+|---------|-------|-------------|
+| `/sddflow proposal` | proposal | Lightweight capture — 3-5 questions to converge on requirements |
+| `/sddflow brainstorming` | brainstorming | Deep design — multi-round tradeoff exploration |
+| `/sddflow spec` | spec | Call OpenSpec to generate specs + auto-translate to plan-ready.md |
+| `/sddflow amend` | amend | Revise requirements/specs before close and update plan-ready.md |
+| `/sddflow build` | build | Call Superpowers to execute implementation |
+| `/sddflow close` | close | Verify consistency + archive |
+
+## Dependency Strategy
+
+```
+Best with: OpenSpec + Superpowers
+Works without them: yes, with manual-file fallback
+```
+
+| Dependency | Install | Fallback when missing |
+|------------|---------|----------------------|
+| OpenSpec | `npm install -g @fission-ai/openspec@latest` | Manually create `openspec/changes/` directories and files |
+| Superpowers | `/plugin install superpowers@claude-plugins-official` | Manually break down plan-ready.md steps in build phase |
+
+### Dual-layer dependency check
+
+| Layer | Mechanism | When missing |
+|-------|-----------|-------------|
+| **Init time** | Detect OpenSpec CLI from `PATH`; detect project OpenSpec in `./openspec/`; detect Superpowers in the selected tools' local/global skill dirs | Non-blocking, skills still generated |
+| **Runtime** | Dependency check injected into SKILL.md | Build phase falls back to manual step-by-step execution |
+
+## Architecture
+
+```
+User Requirements
+   │
+   ├── Quick ──→ /sddflow proposal ──┐
+   │           3-5 questions          │
+   │                                  ├─→ proposal.md
+   └── Deep ───→ /sddflow brainstorming ─┘ (openspec/changes/<name>/)
+               Multi-round exploration
+                                     │
+                          ┌──────────▼───────────┐
+                          │  /sddflow spec         │
+                          │  OpenSpec generates     │
+                          └──────────┬───────────┘
+                                     │
+                          ┌──────────▼───────────┐
+                          │   Translation Layer    │
+                          │  Requirements → Eng    │
+                          └──────────┬───────────┘
+                                     │
+                                plan-ready.md
+                                     │
+                          ┌──────────▼───────────┐
+                          │  /sddflow build       │
+                          │  Superpowers execution │
+                          │  TDD + checkpoint      │
+                          └──────────┬───────────┘
+                                     │
+                          ┌──────────▼───────────┐
+                          │  /sddflow amend       │
+                          │  Requirement revision  │
+                          │  (only when needed)    │
+                          └──────────┬───────────┘
+                                     │
+                          ┌──────────▼───────────┐
+                          │  /sddflow close       │
+                          │  Verify + archive      │
+                          └──────────────────────┘
+```
+
+## Acknowledgments
+
+sddflow orchestrates two open-source projects:
+
+| Project | Repository | License | Usage |
+|---------|-----------|---------|-------|
+| [OpenSpec](https://github.com/Fission-AI/OpenSpec) | `@fission-ai/openspec` | MIT | Generates structured spec files (proposal.md, design.md, specs/, tasks.md). sddflow calls its CLI and reads its output format. |
+| [Superpowers](https://github.com/obra/superpowers) | `superpowers` plugin | MIT | Provides `writing-plans` skill for detailed implementation planning. sddflow delegates build-phase execution to its workflow. |
+
+sddflow is a **standalone orchestrator** — it does not bundle, fork, or embed code from either project. Dependencies are detected at init/runtime, with manual fallback when either is not installed.
+
+## License
+
+MIT

package/README.zh-CN.md

@@ -0,0 +1,151 @@
+# @gavin-hjw/sddflow
+
+[English](./README.md)
+
+OpenSpec + Superpowers 工作流协调器，串联需求规格与工程执行，消除格式鸿沟。
+
+## 安装
+
+```bash
+npm install -g @gavin-hjw/sddflow
+```
+
+## 使用
+
+### 初始化项目
+
+```bash
+cd your-project
+sddflow init --tools claude
+```
+
+`init` 会自动：
+1. 检测并引导安装 OpenSpec CLI
+2. 检测 Superpowers 并提示安装方式
+3. 检测项目 OpenSpec 初始化状态
+4. 生成 sddflow skills 到所选工具的项目级 skill 目录，如 `.claude/skills/sddflow/`、`.codex/skills/sddflow/`、`.cursor/skills/sddflow/` 或 `.opencode/commands/sddflow/`
+
+支持的工具：`claude`、`codex`、`cursor`、`opencode`（逗号分隔，如 `--tools claude,codex`）
+
+### 安装到全局 skills
+
+```bash
+sddflow init --tools claude -g
+sddflow init --tools claude,codex,cursor,opencode --global
+```
+
+加 `-g` / `--global` 后，`sddflow` 会把 skills 安装到所选工具的全局目录：
+
+| 工具 | 全局 skill 路径 |
+|------|-----------------|
+| `claude` | `~/.claude/skills/sddflow/` |
+| `codex` | `~/.codex/skills/sddflow/` |
+| `cursor` | `~/.cursor/skills/sddflow/` |
+| `opencode` | `~/.opencode/commands/sddflow/` |
+
+### 查看状态
+
+```bash
+sddflow status
+```
+
+显示依赖安装状态和项目中的活跃变更。
+
+### 更新 skills
+
+```bash
+sddflow update
+```
+
+升级 npm 包后运行，重新生成项目内的 skills 文件。
+
+## 工作流命令
+
+规范调用方式是 `/sddflow <阶段>`。为了改善补全体验，Claude Code、
+Codex 和 Cursor 会额外生成可见的阶段别名，例如 `/sddflow-spec` 或
+`$sddflow-spec`，这样在命令/skill 选择器里输入 `sddflow` 时能看到可用阶段。
+OpenCode 保持原生命令树形式，例如 `/sddflow/spec`、`/sddflow/build`。
+
+| 命令 | 阶段 | 说明 |
+|------|------|------|
+| `/sddflow proposal` | proposal | 轻量提问，3-5 问快速收敛需求 |
+| `/sddflow brainstorming` | brainstorming | 深度设计，多轮方案探索 |
+| `/sddflow spec` | spec | 调用 OpenSpec 生成规格 + 自动翻译 |
+| `/sddflow amend` | amend | close 前修订需求/规格并更新 plan-ready.md |
+| `/sddflow build` | build | 调用 Superpowers 执行实现 |
+| `/sddflow close` | close | 验证一致性 + 归档 |
+
+## 依赖策略
+
+```
+Best with: OpenSpec + Superpowers
+Works without them: yes, with manual-file fallback
+```
+
+| 依赖 | 安装方式 | 缺失时降级 |
+|------|----------|-----------|
+| OpenSpec | `npm install -g @fission-ai/openspec@latest` | 手动创建 `openspec/changes/` 目录和文件 |
+| Superpowers | `/plugin install superpowers@claude-plugins-official` | build 阶段手动拆解 plan-ready.md 步骤执行 |
+
+### 双层依赖保障
+
+| 层 | 机制 | 缺失时 |
+|----|------|--------|
+| **init 时** | 从 `PATH` 检测 OpenSpec CLI；从 `./openspec/` 检测当前项目 OpenSpec；从所选工具的本地/全局 skill 目录检测 Superpowers | 不阻断，继续生成 skills |
+| **运行时** | SKILL.md 注入依赖检测段 | build 阶段降级为手动拆解步骤执行 |
+
+## 架构
+
+```
+用户需求
+   │
+   ├── 轻量 ──→ /sddflow proposal ──┐
+   │          3-5问快速收敛          │
+   │                                 ├─→ proposal.md
+   └── 深度 ──→ /sddflow brainstorming ─┘ (openspec/changes/<name>/)
+               多轮方案探索
+                                     │
+                          ┌──────────▼───────────┐
+                          │  /sddflow spec        │
+                          │  OpenSpec 生成规格      │
+                          └──────────┬───────────┘
+                                     │
+                          ┌──────────▼───────────┐
+                          │   翻译层 (核心)        │
+                          │  需求视角 → 工程视角    │
+                          └──────────┬───────────┘
+                                     │
+                                plan-ready.md
+                                     │
+                          ┌──────────▼───────────┐
+                          │  /sddflow build       │
+                          │  Superpowers 执行      │
+                          │  TDD 铁律 + 断点恢复   │
+                          └──────────┬───────────┘
+                                     │
+                          ┌──────────▼───────────┐
+                          │  /sddflow amend      │
+                          │  需求变更修订          │
+                          │  （仅需要时）           │
+                          └──────────┬───────────┘
+                                     │
+                          ┌──────────▼───────────┐
+                          │  /sddflow close       │
+                          │  验证一致性 + 归档      │
+                          └──────────────────────┘
+```
+
+## 致谢
+
+sddflow 编排了以下两个开源项目：
+
+| 项目 | 仓库 | 许可证 | 使用方式 |
+|------|------|--------|----------|
+| [OpenSpec](https://github.com/Fission-AI/OpenSpec) | `@fission-ai/openspec` | MIT | 生成结构化规格文件（proposal.md、design.md、specs/、tasks.md）。sddflow 调用其 CLI 并读取其输出格式。 |
+| [Superpowers](https://github.com/obra/superpowers) | `superpowers` 插件 | MIT | 提供 `writing-plans` skill 用于生成详细实现计划。sddflow 在 build 阶段委托其工作流执行。 |
+
+sddflow 是**独立编排器** — 不捆绑、不分叉、不嵌入任何项目的代码。依赖在 init/运行时检测，任一缺失时降级为手动模式。
+
+## License
+
+MIT

package/bin/sddflow.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { run } from '../dist/cli/index.js';
+
+run();

package/dist/cli/index.d.ts

@@ -0,0 +1 @@
+export declare function run(): void;

package/dist/cli/index.js

@@ -0,0 +1,18 @@
+import { Command } from 'commander';
+import { createRequire } from 'module';
+import { initCommand } from './init.js';
+import { statusCommand } from './status.js';
+import { updateCommand } from './update.js';
+const require = createRequire(import.meta.url);
+const pkg = require('../../package.json');
+export function run() {
+    const program = new Command();
+    program
+        .name('sddflow')
+        .description('OpenSpec + Superpowers workflow orchestrator (SDDFlow)')
+        .version(pkg.version);
+    program.addCommand(initCommand);
+    program.addCommand(statusCommand);
+    program.addCommand(updateCommand);
+    program.parse();
+}

package/dist/cli/init.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const initCommand: Command;

package/dist/cli/init.js

@@ -0,0 +1,115 @@
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import { checkDependencies, tryAutoInstall, checkOpenSpecInitialized, writeState } from '../core/dependency-check.js';
+import { generateSkills } from '../core/skill-generator.js';
+import { TOOL_PATHS, DEPS } from '../core/constants.js';
+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')
+    .option('-g, --global', 'Install skills globally under home tool directories')
+    .action(async (options) => {
+    const cwd = process.cwd();
+    const tools = options.tools.split(',').map((t) => t.trim());
+    const installGlobally = Boolean(options.global);
+    logger.blank();
+    logger.info(`sddflow init — ${installGlobally ? 'global skill setup' : 'workflow orchestrator setup'}`);
+    logger.blank();
+    // Step 1: Check OpenSpec
+    logger.step('Checking OpenSpec ...');
+    let depStatus = checkDependencies({ cwd, tools });
+    if (!depStatus.openspec.installed) {
+        logger.warn('OpenSpec CLI not installed');
+        const { installOpenSpec } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'installOpenSpec',
+                message: `Auto-install? (npm install -g ${DEPS.openspec.npmPkg}@latest)`,
+                default: true,
+            },
+        ]);
+        if (installOpenSpec) {
+            const ok = tryAutoInstall(DEPS.openspec.npmPkg);
+            depStatus = checkDependencies({ cwd, tools }); // recheck
+            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');
+    }
+    else {
+        logger.success(`Superpowers installed${depStatus.superpowers.path ? ` (${depStatus.superpowers.path})` : ''}`);
+    }
+    if (installGlobally) {
+        logger.step('Skipping project OpenSpec initialization 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([
+                    {
+                        type: 'confirm',
+                        name: 'initOpenSpec',
+                        message: 'OpenSpec not initialized in this project. Run openspec init?',
+                        default: true,
+                    },
+                ]);
+                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');
+            }
+        }
+        else {
+            logger.success('OpenSpec project initialized');
+        }
+    }
+    // Step 4: Generate skills
+    logger.step('Generating sddflow skills ...');
+    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),
+            createdAt: new Date().toISOString(),
+            tools,
+        });
+    }
+    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('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');
+    logger.info('  /sddflow build          Execute implementation');
+    logger.info('  /sddflow close          Verify + archive');
+    logger.blank();
+});

package/dist/cli/status.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const statusCommand: Command;

package/dist/cli/status.js

@@ -0,0 +1,78 @@
+import { Command } from 'commander';
+import path from 'path';
+import fs from 'fs';
+import { checkDependencies, readState, checkOpenSpecInitialized } from '../core/dependency-check.js';
+import { logger } from '../utils/logger.js';
+import { dirExists } from '../utils/shell.js';
+export const statusCommand = new Command('status')
+    .description('Show dependency status and active changes')
+    .action(() => {
+    const cwd = process.cwd();
+    logger.blank();
+    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) {
+        logger.success(`OpenSpec CLI${depStatus.openspec.version ? ` v${depStatus.openspec.version}` : ''}`);
+    }
+    else {
+        logger.warn('OpenSpec CLI — not installed');
+    }
+    if (depStatus.superpowers.installed) {
+        logger.success(`Superpowers${depStatus.superpowers.path ? ` (${depStatus.superpowers.path})` : ''}`);
+    }
+    else {
+        logger.warn('Superpowers — not installed (build phase will use manual mode)');
+    }
+    logger.blank();
+    // Project state
+    logger.step('Project:');
+    if (state) {
+        logger.success(`Initialized (${state.tools.join(', ')})`);
+        logger.info(`  Created at: ${state.createdAt}`);
+    }
+    else {
+        logger.warn('Not initialized — run sddflow init');
+        return;
+    }
+    if (checkOpenSpecInitialized(cwd)) {
+        logger.success('OpenSpec project initialized');
+    }
+    else {
+        logger.warn('OpenSpec project not initialized');
+    }
+    logger.blank();
+    // Active changes
+    logger.step('Active changes:');
+    const changesDir = path.join(cwd, 'openspec', 'changes');
+    if (!dirExists(changesDir)) {
+        logger.info('  None');
+        return;
+    }
+    const entries = fs.readdirSync(changesDir, { withFileTypes: true })
+        .filter((d) => d.isDirectory() && d.name !== 'archive');
+    if (entries.length === 0) {
+        logger.info('  None');
+        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}`);
+    }
+    logger.blank();
+});

package/dist/cli/update.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const updateCommand: Command;

package/dist/cli/update.js

@@ -0,0 +1,32 @@
+import { Command } from 'commander';
+import { checkDependencies, readState, writeState, checkOpenSpecInitialized } from '../core/dependency-check.js';
+import { generateSkills } from '../core/skill-generator.js';
+import { logger } from '../utils/logger.js';
+export const updateCommand = new Command('update')
+    .description('Regenerate sddflow skills in the current project')
+    .action(() => {
+    const cwd = process.cwd();
+    const state = readState(cwd);
+    if (!state) {
+        logger.error('Project not initialized — run sddflow init first');
+        return;
+    }
+    logger.blank();
+    logger.info('sddflow update — regenerating skills');
+    logger.blank();
+    const depStatus = checkDependencies({ cwd, tools: state.tools });
+    generateSkills({
+        cwd,
+        tools: state.tools,
+        depStatus,
+    });
+    writeState(cwd, {
+        ...state,
+        openspec: depStatus.openspec.installed,
+        superpowers: depStatus.superpowers.installed,
+        openspecProjectInitialized: checkOpenSpecInitialized(cwd),
+    });
+    logger.blank();
+    logger.success('Skills updated');
+    logger.blank();
+});

package/dist/core/constants.d.ts

@@ -0,0 +1,23 @@
+export declare const PKG_NAME = "@gavin-hjw/sddflow";
+export declare const PKG_BIN = "sddflow";
+export declare const SKILL_NAME = "sddflow";
+export declare const COMMAND_PREFIX = "/sddflow";
+export declare const DEPS: {
+    readonly openspec: {
+        readonly name: "OpenSpec";
+        readonly cliCmd: "openspec";
+        readonly npmPkg: "@fission-ai/openspec";
+        readonly installHint: "npm install -g @fission-ai/openspec@latest";
+        readonly autoInstallable: true;
+    };
+    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 autoInstallable: false;
+    };
+};
+export declare const TOOL_PATHS: Record<string, {
+    skillsDir: string;
+    commandsDir?: string;
+}>;

package/dist/core/constants.js

@@ -0,0 +1,34 @@
+export const PKG_NAME = '@gavin-hjw/sddflow';
+export const PKG_BIN = 'sddflow';
+export const SKILL_NAME = 'sddflow';
+export const COMMAND_PREFIX = '/sddflow';
+export const DEPS = {
+    openspec: {
+        name: 'OpenSpec',
+        cliCmd: 'openspec',
+        npmPkg: '@fission-ai/openspec',
+        installHint: 'npm install -g @fission-ai/openspec@latest',
+        autoInstallable: true,
+    },
+    superpowers: {
+        name: 'Superpowers',
+        checkPath: 'writing-plans/SKILL.md',
+        installHint: '请在当前工具中安装 Superpowers writing-plans skill（Claude Code: /plugin install superpowers@claude-plugins-official）',
+        autoInstallable: false,
+    },
+};
+export const TOOL_PATHS = {
+    claude: {
+        skillsDir: '.claude/skills',
+        commandsDir: '.claude/commands',
+    },
+    codex: {
+        skillsDir: '.codex/skills',
+    },
+    cursor: {
+        skillsDir: '.cursor/skills',
+    },
+    opencode: {
+        skillsDir: '.opencode/commands',
+    },
+};