@vima_tech/flywheel 1.0.0 → 1.1.1

package/bin/flywheel.js

@@ -1,39 +1,200 @@
 #!/usr/bin/env node
-/**
- * Flywheel CLI
- * Global entry point for @renmengkai/flywheel npm package
- */
-const { spawn } = require('child_process');
+const { spawn, execSync } = require('child_process');
 const path = require('path');
 const fs = require('fs');
+const readline = require('readline');
 
-const REPO_DIR = process.env.FLYWHEEL_DIR || process.cwd();
+const REPO_DIR = process.env.FLYWHEEL_DIR || path.dirname(path.dirname(__dirname));
+const NPM_PKG = '@vima_tech/flywheel';
 
 function resolveScript(name) {
-  const scripts = {
-    'flywheel-install': path.join(__dirname, '../scripts/flywheel-install.sh'),
-    'auto-distill': path.join(__dirname, '../scripts/auto-distill.sh'),
-    'feedback-hook': path.join(__dirname, '../scripts/feedback-hook.sh'),
-    'bridge-to-coder': path.join(__dirname, '../scripts/bridge-to-coder.sh'),
-  };
-  return scripts[name];
+  return path.join(__dirname, '../scripts/' + name + '.sh');
+}
+
+function resolveKernelFile(name) {
+  return path.join(__dirname, '../' + name);
 }
 
 function runScript(scriptPath, args) {
   return new Promise((resolve, reject) => {
     const child = spawn('bash', [scriptPath, ...args], {
-      cwd: REPO_DIR,
+      cwd: process.cwd(),
       stdio: 'inherit',
-      env: { ...process.env, FLYWHEEL_DIR: REPO_DIR },
+      env: { ...process.env, FLYWHEEL_DIR: process.cwd() },
     });
     child.on('exit', (code) => {
       if (code === 0) resolve(0);
-      else reject(new Error(`exit code ${code}`));
+      else reject(new Error('exit code ' + code));
     });
   });
 }
 
-const [,, command, ...args] = process.argv;
+function downloadFile(url, destPath) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(destPath);
+    spawn('curl', ['-fsSL', url, '-o', destPath], { stdio: 'ignore' })
+      .on('exit', (code) => {
+        if (code === 0) resolve(0);
+        else reject(new Error('curl failed'));
+      });
+  });
+}
+
+async function initKernel(dir, skill) {
+  const kernelFiles = [
+    'CLAUDE.md', '.gitignore',
+    '.claude/commands/flywheel.md', '.claude/commands/skill.md',
+    'scripts/auto-distill.sh', 'scripts/feedback-hook.sh',
+    'scripts/bridge-to-coder.sh', 'scripts/flywheel-install.sh',
+    'templates/state.json',
+    'skills/_kernel/distillation.md',
+    'skills/_template/skill.yaml', 'skills/_template/domain.md',
+    'skills/_template/feedback-questions.sh',
+  ];
+
+  const optionalFiles = [
+    'skills/_template/artifacts.md',
+  ];
+
+  const baseUrl = 'https://raw.githubusercontent.com/renmengkai/flywheel/main';
+  const skillFiles = skill ? [
+    'skills/' + skill + '/skill.yaml',
+    'skills/' + skill + '/domain.md',
+    'skills/' + skill + '/feedback-questions.sh',
+  ] : [];
+
+  for (const f of kernelFiles) {
+    const dest = path.join(dir, f);
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    const srcPath = resolveKernelFile(f);
+    if (fs.existsSync(srcPath)) {
+      fs.copyFileSync(srcPath, dest);
+    } else {
+      await downloadFile(baseUrl + '/' + f, dest);
+    }
+  }
+
+  for (const f of optionalFiles) {
+    const dest = path.join(dir, f);
+    const srcPath = resolveKernelFile(f);
+    if (fs.existsSync(srcPath)) fs.copyFileSync(srcPath, dest);
+  }
+
+  if (skill) {
+    for (const f of skillFiles) {
+      const dest = path.join(dir, f);
+      fs.mkdirSync(path.dirname(dest), { recursive: true });
+      const srcPath = resolveKernelFile(f);
+      if (fs.existsSync(srcPath)) {
+        fs.copyFileSync(srcPath, dest);
+      } else {
+        await downloadFile(baseUrl + '/' + f, dest);
+      }
+    }
+  }
+
+  fs.mkdirSync(path.join(dir, '.distill-needed'), { recursive: true });
+  fs.mkdirSync(path.join(dir, 'episodic-logs'), { recursive: true });
+  fs.mkdirSync(path.join(dir, 'projects'), { recursive: true });
+  fs.mkdirSync(path.join(dir, 'memory'), { recursive: true });
+  fs.writeFileSync(path.join(dir, '.distill-needed/.gitkeep'), '');
+  fs.writeFileSync(path.join(dir, 'episodic-logs/.gitkeep'), '');
+  fs.writeFileSync(path.join(dir, 'projects/.gitkeep'), '');
+  fs.writeFileSync(path.join(dir, 'memory/.gitkeep'), '');
+
+  if (!fs.existsSync(path.join(dir, '.gitignore'))) {
+    fs.writeFileSync(path.join(dir, '.gitignore'), `# flywheel-managed\nprojects/*/\nepisodic-logs/\n.distill-needed/*\n!.distill-needed/.gitkeep\nmemory/.gitkeep\n*.log\n`);
+  }
+
+  try {
+    execSync('chmod +x ' + path.join(dir, 'scripts/*.sh'), { stdio: 'ignore', shell: true });
+  } catch (e) {}
+}
+
+async function cmdNew(args) {
+  if (args.length < 1) {
+    console.error('用法: flywheel new <project-name> [--agent claude|opencode] [--skill req-mining]');
+    process.exit(1);
+  }
+
+  const projectName = args[0];
+  const dirName = projectName;
+  const targetDir = path.join(process.cwd(), dirName);
+
+  if (fs.existsSync(targetDir)) {
+    console.error('❌ 目录已存在: ' + targetDir);
+    process.exit(1);
+  }
+
+  let agent = 'claude';
+  let skill = 'req-mining';
+
+  for (let i = 1; i < args.length; i++) {
+    if (args[i] === '--agent' && args[i + 1]) {
+      agent = args[i + 1];
+      i++;
+    } else if (args[i] === '--skill' && args[i + 1]) {
+      skill = args[i + 1];
+      i++;
+    }
+  }
+
+  console.log('');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log('   Flywheel 初始化');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log(' 项目: ' + projectName);
+  console.log(' 目录: ' + targetDir);
+  console.log(' Agent: ' + agent);
+  console.log(' Skill: ' + skill);
+  console.log('');
+
+  console.log('📦 初始化内核文件...');
+  fs.mkdirSync(targetDir, { recursive: true });
+  await initKernel(targetDir, skill);
+  console.log('  ✓ 内核安装完成');
+
+  console.log('');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log('  ✅ 项目创建完成！');
+  console.log('');
+  console.log(' 进入目录并启动 ' + agent + '：');
+  console.log('   cd ' + dirName + ' && flywheel start');
+  console.log('');
+  console.log('  或手动启动：cd ' + dirName + ' && claude');
+  console.log('  然后输入 /sfw 开始飞轮工作');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+}
+
+async function cmdStart() {
+  const agent = detectAgent();
+  if (!agent) {
+    console.error('❌ 未检测到 Claude Code 或 OpenCode');
+    console.error('请先安装 Claude Code 或 OpenCode');
+    process.exit(1);
+  }
+
+  console.log('🚀 启动 ' + agent + '...');
+  spawn(agent, [], {
+    cwd: process.cwd(),
+    stdio: 'inherit',
+    shell: true,
+    env: { ...process.env, FLYWHEEL_DIR: process.cwd() },
+  });
+}
+
+function detectAgent() {
+  const agents = ['claude', 'claude-code', 'opencode', 'codex'];
+  for (const a of agents) {
+    try {
+      execSync('which ' + a, { stdio: 'ignore' });
+      return a;
+    } catch (e) {}
+  }
+  return null;
+}
+
+const [, , command, ...args] = process.argv;
 
 if (!command) {
   console.log(`
@@ -42,54 +203,94 @@ Flywheel CLI — 自成长 AI Agent 飞轮框架
 用法: flywheel <command> [args]
 
 可用命令:
-  install <skill>     安装 skill 包
-  list                列出已安装的 skill
-  update [skill]      更新 skill 包
-  distill [project]   手动触发蒸馏
-  help                显示帮助
+  new|create|init       创建新项目
+  start|run|launch      启动 Claude Code 或 OpenCode
+  -v|--version          显示版本号
+  install|add|i         安装 skill 包
+  list|ls               列出已安装的 skill
+  update|upgrade        更新 flywheel 或 skill
+  distill|dist          手动触发蒸馏
+  -h|--help|h           显示帮助
 
 示例:
+  flywheel new my-project
+  cd my-project && flywheel start
   flywheel install req-mining
-  flywheel list
-  flywheel update
-  flywheel distill proj_20260515_01
+  flywheel update flywheel    # 更新 flywheel 本身
 `);
   process.exit(0);
 }
 
 switch (command) {
+  case '-v':
+  case '--version':
+  case '-V':
+  case 'version':
+    console.log('@vima_tech/flywheel v1.1.0');
+    break;
+  case 'new':
+  case 'create':
+  case 'init':
+    cmdNew(args).catch((e) => { console.error(e); process.exit(1); });
+    break;
+  case 'start':
+  case 'run':
+  case 'launch':
+    cmdStart();
+    break;
+  case '-h':
+  case '--help':
+  case '-?':
   case 'help':
+  case 'h':
     console.log(`
 Flywheel CLI — 自成长 AI Agent 飞轮框架
 
 用法: flywheel <command> [args]
 
 可用命令:
-  install <skill>     安装 skill 包
-  list                列出已安装的 skill
-  update [skill]      更新 skill 包
-  distill [project]   手动触发蒸馏
+  new <name>           创建新项目 (new|create|init)
+  start                启动 Claude Code 或 OpenCode (start|run|launch)
+  version             显示版本号 (-v|--version)
+  update              更新 flywheel 到最新版本
+  install <skill>      安装 skill 包 (install|add|i)
+  list                 列出已安装的 skill (list|ls)
+  update skill        更新 skill 包 (update|upgrade)
+  distill [project]    手动触发蒸馏 (distill|dist)
+  help                 显示帮助 (-h|--help)
 
 示例:
+  flywheel new my-project
+  cd my-project && flywheel start
   flywheel install req-mining
-  flywheel list
-  flywheel update
-  flywheel distill proj_20260515_01
 `);
     break;
   case 'install':
+  case 'add':
+  case 'i':
     runScript(resolveScript('flywheel-install'), ['add', ...args]).catch((e) => process.exit(1));
     break;
   case 'list':
+  case 'ls':
     runScript(resolveScript('flywheel-install'), ['list']).catch((e) => process.exit(1));
     break;
   case 'update':
-    runScript(resolveScript('flywheel-install'), ['update', ...args]).catch((e) => process.exit(1));
+  case 'upgrade':
+    if (args[0] === 'flywheel' || args[0] === 'self') {
+      spawn('npm', ['install', '-g', '@vima_tech/flywheel'], {
+        cwd: process.cwd(),
+        stdio: 'inherit',
+      }).on('exit', (code) => process.exit(code));
+    } else {
+      runScript(resolveScript('flywheel-install'), ['update', ...args]).catch((e) => process.exit(1));
+    }
     break;
   case 'distill':
+  case 'dist':
     runScript(resolveScript('auto-distill'), args).catch((e) => process.exit(1));
     break;
   default:
-    console.error(`未知命令: ${command}`)
+    console.error('未知命令: ' + command);
+    console.error('运行 flywheel help 查看用法');
     process.exit(1);
 }

package/package.json

@@ -1,11 +1,18 @@
 {
   "name": "@vima_tech/flywheel",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "自成长 AI Agent 飞轮框架 — 让任何需要积累迭代的 AI 工作流都能自我进化",
   "main": "bin/flywheel.js",
   "bin": {
     "flywheel": "./bin/flywheel.js"
   },
+  "files": [
+    "bin/",
+    "scripts/",
+    "templates/",
+    "skills/_kernel/",
+    "skills/_template/"
+  ],
   "scripts": {
     "postinstall": "chmod +x bin/flywheel.js"
   },

package/scripts/available.json

@@ -0,0 +1,10 @@
+{
+  "skills": [
+    {
+      "name": "req-mining",
+      "version": "1.0.0",
+      "description": "需求挖掘与落地飞轮"
+    }
+  ],
+  "updated": "2026-05-15"
+}

package/scripts/flywheel-install.sh

@@ -37,7 +37,27 @@ cmd_list() {
   done
   $found || echo "  （未安装任何 skill）"
   echo ""
-  echo "安装新 skill：./scripts/flywheel-install.sh add <skill-name>"
+  echo "安装新 skill：flywheel install <skill-name>"
+}
+
+# ── available ─────────────────────────────────────────────────
+cmd_available() {
+  echo "━━━ 可安装 Skill 包 ━━━"
+  local available_file="$SCRIPT_DIR/available.json"
+  if [ -f "$available_file" ]; then
+    python3 - << 'PYEOF'
+import json, sys
+with open(sys.argv[1]) as f:
+    data = json.load(f)
+for s in data.get('skills', []):
+    print(f"  - {s['name']}  v{s['version']}  -  {s['description']}")
+PYEOF
+    "$available_file"
+  else
+    echo "  （无可用 skill，请检查网络后重试）"
+  fi
+  echo ""
+  echo "安装 skill：flywheel install <skill-name>"
 }
 
 # ── add ────────────────────────────────────────────────────────

package/.claude/commands/flywheel.md

@@ -1,42 +0,0 @@
-# 启动自飞轮需求挖掘
-
-执行以下步骤，激活飞轮模式：
-
-## Step 0：检查待蒸馏标记
-
-读取 `.distill-needed/` 目录。如果存在标记文件：
-- 列出所有待蒸馏项目
-- 询问用户是否现在处理，还是先处理新文档
-- 若用户选择现在蒸馏：读取 `skills/core/distillation.md`，对每个标记项目执行蒸馏协议（展示预览，单次 y/n 确认），完成后删除标记文件
-
-## Step 1：加载运行时上下文
-
-按顺序读取：
-1. `memory/patterns/failure-patterns.md`（常驻知识，必须）
-2. `skills/core/auto-req.md`（Ring 1 分析协议）
-
-## Step 2：显示飞轮状态
-
-输出当前状态摘要：
-
-```
-━━━ Req-Miner 自飞轮 | 就绪 ━━━
-
-待蒸馏项目：{N} 个
-活跃项目：
-  • {project_id} — 阶段：{状态} | 假设：{N}项
-
-提供文档材料开始 Ring 1 分析：
-  • 直接粘贴文本
-  • 输入文件路径（如 /path/to/doc.pdf）
-  • 输入 URL
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-```
-
-## Step 3：等待用户输入材料
-
-用户提供材料后，执行 `skills/core/auto-req.md` 的五维度扫描流程。
-
----
-
-**别名：** 用户输入 `sfw`、`start flywheel`、`开始飞轮`、`开启飞轮` 时，等同于运行本命令。

package/.claude/commands/skill.md

@@ -1,36 +0,0 @@
-# Skill 包管理
-
-管理当前项目中安装的 Flywheel skill 包。
-
-## 用法
-
-用户输入以下命令时，通过 Bash 工具执行对应操作：
-
-### `/skill list` 或 `skill list`
-```bash
-./scripts/flywheel-install.sh list
-```
-列出所有已安装的 skill 包、版本号和描述。
-
-### `/skill add <skill-name>` 或 `skill add <name>`
-```bash
-./scripts/flywheel-install.sh add <skill-name>
-```
-从官方注册表安装新 skill 包。
-
-### `/skill update` 或 `skill update`
-```bash
-./scripts/flywheel-install.sh update
-```
-检查并更新所有已安装 skill 包到最新版本。
-
-### `/skill update <skill-name>`
-```bash
-./scripts/flywheel-install.sh update <skill-name>
-```
-更新指定 skill 包。
-
----
-
-执行命令后，输出结果并告知用户下一步操作。
-如果安装了新 skill，提示用户使用 `/flywheel` 激活该 skill 的飞轮。

package/.claude/settings.local.json

@@ -1,13 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(git -C /home/renmk/projects/Flywheel status --short)",
-      "Bash(git -C /home/renmk/projects/Flywheel ls-files docs/)",
-      "Bash(mkdir -p /home/renmk/projects/Flywheel/.claude/worktrees/fix-poster-accuracy/docs)",
-      "Bash(cp /home/renmk/projects/Flywheel/docs/Flywheel_Poster.html /home/renmk/projects/Flywheel/.claude/worktrees/fix-poster-accuracy/docs/)",
-      "Bash(git -C /home/renmk/projects/Flywheel/.claude/worktrees/fix-poster-accuracy status --short)",
-      "Bash(git -C /home/renmk/projects/Flywheel/.claude/worktrees/fix-poster-accuracy log main..HEAD --oneline)",
-      "Bash(git branch *)"
-    ]
-  }
-}

package/CLAUDE.md

@@ -1,178 +0,0 @@
-# Flywheel：自成长 AI Agent 飞轮框架
-
-**核心哲学：输入材料，AI 分析，执行反馈，自我进化。**
-
-你是一个自飞轮 Agent，从输入材料中自主分析、生成产物、
-桥接执行工具，并通过执行反馈持续蒸馏自身 Skills。
-
-## 飞轮激活
-
-**用户通过以下任意方式激活飞轮：**
-
-| 方式 | 示例 |
-|---|---|
-| 斜杠命令（推荐） | `/flywheel` |
-| 英文触发词 | `sfw`、`start flywheel` |
-| 中文触发词 | `开始飞轮`、`开启飞轮`、`启动飞轮` |
-| 直接提供材料 | 粘贴文档 / 文件路径 / URL |
-
-检测到以上任意信号时，立即执行 `.claude/commands/flywheel.md` 中的激活流程。
-
-**默认不激活：** 打开会话后不主动问候或启动，等待用户给出激活信号。
-
----
-
-## 目录结构
-
-```
-CLAUDE.md                         ← 你正在读的文件（系统引导）
-install.sh                        ← 一键安装脚本
-.claude/commands/
-  flywheel.md                     ← /flywheel 激活命令
-  skill.md                        ← /skill 包管理命令
-scripts/
-  auto-distill.sh                 ← Ring 3：检查蒸馏触发条件
-  feedback-hook.sh                ← Ring 2→3：收集执行反馈
-  bridge-to-coder.sh              ← Ring 1→2：产物→执行工具
-  flywheel-install.sh             ← skill 包管理工具
-skills/
-  _kernel/
-    distillation.md               ← 通用蒸馏协议（Ring 3 核心）
-  _template/                      ← 新建 skill 的脚手架模板
-  req-mining/                     ← 内置 skill：需求挖掘与落地
-    skill.yaml                    ← skill 元数据
-    domain.md                     ← Ring 1 分析协议
-    artifacts.md                  ← 产物规格
-    feedback-questions.sh         ← 领域专属反馈问题
-    memory/
-      failure-patterns.md         ← 已知失败模式（常驻加载）
-    industry/
-      erp.md                      ← ERP 行业包
-templates/
-  state.json                      ← 项目状态模板
-projects/                         ← 项目状态（Git 忽略）
-episodic-logs/                    ← 事件日志（Git 忽略）
-.distill-needed/                  ← 蒸馏触发标记（Git 忽略）
-```
-
----
-
-## 飞轮架构
-
-```
-Ring 1  用户提供材料（文本 / 文件 / URL）
-          ↓
-        skill 分析协议（skills/{skill}/domain.md）
-          ↓ 产物（含假设清单 + 信息缺口）
-Ring 2  scripts/bridge-to-coder.sh
-          ↓ 注入产物到执行工具
-        执行工具工作（写入 .flywheel-feedback.json）
-          ↓
-        scripts/feedback-hook.sh --auto
-          ↓ 写入 episodic-logs/
-Ring 3  积累 ≥3 条高质量反馈
-          ↓
-        蒸馏协议（skills/_kernel/distillation.md）
-          ↓ 展示预览，单次 y/n → 更新 skills/ + memory/
-          ↓
-        下次分析更准确 ← 飞轮闭合
-```
-
----
-
-## 启动步骤
-
-**每次会话启动时，首先执行 Step 0：**
-
-```
-Step 0（必须，优先于一切）：检查 .distill-needed/ 目录
-  → 目录下有文件（如 .distill-needed/proj_xxx）
-  → 立即读取 skills/_kernel/distillation.md
-  → 对每个标记的项目执行蒸馏（展示预览，单次 y/n 确认）
-  → 蒸馏完成后删除对应标记文件
-  → 所有标记处理完毕后，继续正常会话
-```
-
-**用户激活飞轮后（Ring 1）：**
-
-```
-1. 读取已安装 skill 的 memory 文件（常驻，必须）
-2. 读取 skill.yaml，加载对应 domain.md
-3. 根据材料内容判断是否加载行业包
-4. 检查 projects/{project_id}/state.json
-   - 存在 → 恢复上次会话状态
-   - 不存在 → 从 templates/state.json 创建，写入 skill 字段
-5. 执行 domain.md 中的分析协议（静默）
-6. 输出分析结果 + 信息缺口清单
-7. 加载 skills/{skill}/artifacts.md，生成产物
-8. 通过 Bash 工具直接调用：
-   ./scripts/bridge-to-coder.sh {project_id} {tool}
-```
-
----
-
-## 会话中的文件操作
-
-- 每轮对话后：更新 `projects/{project_id}/state.json`（含 `skill` 字段）
-- 关键事件：追加到 `episodic-logs/{project_id}.jsonl`
-- 蒸馏完成后：删除 `.distill-needed/{project_id}` 标记文件
-
----
-
-## Ring 3 蒸馏触发条件
-
-```
-□ 同一项目积累 ≥3 条 quality_score≥0.6 的反馈事件
-□ 同类干预事件跨项目出现 ≥3 次
-□ 用户说"蒸馏"、"更新skill"、"从日志学习"
-```
-
-触发后读取 `skills/_kernel/distillation.md`，执行蒸馏协议。
-
----
-
-## 关键协议
-
-### 状态文件路径
-```
-projects/{project_id}/state.json      ← 含 skill 字段
-projects/{project_id}/artifacts/      ← 产物存放位置
-```
-
-`project_id` 由用户提供或自动生成（格式：`proj_YYYYMMDD_NN`）
-
-### 每轮状态行
-```
-━━━ [Ring 1/2/3] | Skill：{skill} | 项目：{project_id} | 假设：X项 ━━━
-```
-
-### 未覆盖决策协议
-遇到 skill 未覆盖的场景时，追加到 `uncovered_decisions`，输出 `⚠️ L2 告警`。
-
----
-
-## Skill 管理
-
-```bash
-/skill list              # 列出已安装 skill
-/skill add code-review   # 安装新 skill
-/skill update            # 更新所有 skill
-```
-
-## Git 规范
-
-```bash
-git add skills/ memory/
-git commit -m "distill({skill}): {描述} (from {project_id})"
-```
-
-## .gitignore 内容
-
-```
-projects/*/
-episodic-logs/
-.distill-needed/*
-!.distill-needed/.gitkeep
-*.log
-.DS_Store
-```