@haaaiawd/loom 0.8.0 → 0.10.0

package/cli/bin/loom.js

@@ -12,15 +12,15 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 
 import { getNextIntent, getStatus, getDependencyGraph, getIntent, loadIntentMap, updateIntentStatus, getNarrative } from '../src/intent-map.js';
 import { getPhilosophy, listPhilosophyFiles, validateInspirationSources, validatePartDecomposition } from '../src/philosophy.js';
-import { writeVerification, getVerificationHistory, getPendingVerifications, listVerifications, getVerificationContract } from '../src/verify.js';
+import { writeVerification, createQuickVerification, getVerificationHistory, getPendingVerifications, listVerifications, getVerificationContract } from '../src/verify.js';
 import { initProject } from '../src/init.js';
 import { activateRole } from '../src/activate.js';
 import { listVersions, newVersion, useVersion, diffVersions } from '../src/version.js';
 import { doctor, contextSummary, traceIntent, reverseDep, reverseRef } from '../src/diagnostics.js';
 import { getHelpTopic, listHelpTopics } from '../src/help.js';
 import { guideProject } from '../src/guide.js';
-import { isAutoOn, autoOn, autoOff, autoStatus } from '../src/auto.js';
-import { generatePreviewPrompt, getPreviewStatus } from '../src/preview.js';
+import { isAutoOn, autoOn, autoOff, autoStatus, getAutoMode } from '../src/auto.js';
+import { generatePreviewPrompt, getPreviewStatus } from '../src/preview.js';
 
 // ─── 路径解析 ──────────────────────────────────────────
 // findLoomRoot / findVersionDir / readCurrentPointer 已提取到 shared/paths.js
@@ -126,8 +126,37 @@ try {
           console.log(`${id} status 已更新为 ${newStatus}`);
           break;
         }
+        case 'done': {
+          // loom intent done <id> — 自动走 pending→in_progress→completed，检查验证记录
+          const id = rest[0];
+          if (!id) die('用法: loom intent done <id>');
+          const verificationsDir = getVerificationsDir(versionDir);
+          // 检查有没有验证记录
+          const history = getVerificationHistory(verificationsDir, id);
+          if (!history || history.records.length === 0) {
+            die(`${id} 没有验证记录。先跑: loom verify pass ${id} --summary "..."`);
+          }
+          // 检查最新验证记录是否 passed
+          const latest = history.records[history.records.length - 1];
+          if (latest.verdict !== 'passed') {
+            die(`${id} 最新验证记录是 ${latest.verdict}（非 passed）。只有 passed 的 Intent 才能 done。`);
+          }
+          // 获取当前状态，自动走两步
+          const intent = getIntent(versionDir, id);
+          const currentStatus = intent.status;
+          if (currentStatus === 'completed') {
+            console.log(`${id} 已经是 completed，无需操作`);
+            break;
+          }
+          if (currentStatus === 'pending') {
+            updateIntentStatus(versionDir, id, 'in_progress');
+          }
+          updateIntentStatus(versionDir, id, 'completed');
+          console.log(`${id} 已完成（${currentStatus} → completed）`);
+          break;
+        }
         default:
-          die(`未知子命令: intent ${sub}\n用法: loom intent [next|status|graph|get <id>|narrative <id>|validate|trace <id>|reverse-dep <id>|reverse-ref <anchor>|update <id> --status <...>]`);
+          die(`未知子命令: intent ${sub}\n用法: loom intent [next|status|graph|get <id>|narrative <id>|validate|trace <id>|reverse-dep <id>|reverse-ref <anchor>|update <id> --status <...>|done <id>]`);
       }
       break;
     }
@@ -135,11 +164,10 @@ try {
     case 'init': {
       const result = initProject(cwd());
       console.log('LOOM 项目已初始化');
-      console.log(`  创建: ${result.created.length} 项`);
-      for (const c of result.created) console.log(`    + ${c}`);
-      if (result.skipped.length) {
-        console.log(`  跳过（已存在）: ${result.skipped.length} 项`);
-        for (const s of result.skipped) console.log(`    - ${s}`);
+      for (const c of result.created) console.log(`  [created] ${c}`);
+      for (const s of result.skipped) console.log(`  [skipped] ${s} (already exists)`);
+      if (result.created.length === 0 && result.skipped.length > 0) {
+        console.log('  所有文件已存在，无需操作。');
       }
       console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
       console.log('To Agent: 运行 loom guide 诊断当前阶段，按引导执行');
@@ -187,6 +215,17 @@ try {
           const allIssues = [...inspiration.issues, ...decomposition.issues];
           const allPassed = inspiration.passed && decomposition.passed;
 
+          // --json: 结构化输出，供 Agent 程序化消费
+          if (argv.includes('--json')) {
+            output({
+              passed: allPassed,
+              issues: allIssues,
+              sources: inspiration.sources.map(({ file, sources }) => ({ file, count: sources.length })),
+              parts: decomposition.parts,
+            });
+            exit(allPassed ? 0 : 1);
+          }
+
           if (allPassed) {
             console.log('✓ 哲学文档校验通过');
             console.log('  灵感来源:');
@@ -271,8 +310,34 @@ try {
           }
           break;
         }
+        case 'pass':
+        case 'fail': {
+          // loom verify pass <id> --summary "..." [--reproduction-command "..."]
+          // loom verify fail <id> --summary "..." [--deviation "..."] [--reproduction-command "..."]
+          const id = rest[0];
+          if (!id) die(`用法: loom verify ${sub} <id> --summary "..." [--reproduction-command "..."]${sub === 'fail' ? ' [--deviation "..."]' : ''}`);
+          const summaryIdx = argv.indexOf('--summary');
+          const reproIdx = argv.indexOf('--reproduction-command');
+          const deviationIdx = argv.indexOf('--deviation');
+          const summary = summaryIdx !== -1 ? argv[summaryIdx + 1] : null;
+          if (!summary) die(`缺少 --summary: loom verify ${sub} ${id} --summary "..."`);
+          const extras = {};
+          if (reproIdx !== -1 && argv[reproIdx + 1]) extras.reproduction_command = argv[reproIdx + 1];
+          if (sub === 'fail' && deviationIdx !== -1 && argv[deviationIdx + 1]) extras.deviation_detail = argv[deviationIdx + 1];
+          const verdict = sub === 'pass' ? 'passed' : 'deviated';
+          const result = createQuickVerification(verificationsDir, id, verdict, summary, extras);
+          console.log(`验证记录已写入: ${result.filePath}`);
+          console.log(`  轮次: ${result.round}, verdict: ${verdict}`);
+          if (verdict === 'deviated') {
+            console.log(`  deviated 累计: ${result.deviated_count} 轮`);
+            if (result.should_escalate) {
+              console.log(`  ⚠ 达到 3 轮上限，应升级为 blocked——Keeper 应执行: loom intent update ${id} --status blocked`);
+            }
+          }
+          break;
+        }
         default:
-          die(`未知子命令: verify ${sub}\n用法: loom verify [contract <id>|history <id>|pending|list|write --json-file <path>|--json <string>]`);
+          die(`未知子命令: verify ${sub}\n用法: loom verify [contract <id>|history <id>|pending|list|write --json-file <path>|--json <string>|pass <id> --summary "..."|fail <id> --summary "..."]`);
       }
       break;
     }
@@ -337,7 +402,11 @@ try {
         for (const issue of issues) {
           const icon = issue.severity === 'fatal' ? '☠' : issue.severity === 'high' ? '⚠' : '·';
           console.log(`  ${icon} [${issue.severity}] ${issue.type}: ${issue.msg}`);
+          if (issue.fix_hint) {
+            console.log(`    → 修复: ${issue.fix_hint}`);
+          }
         }
+        console.log(`\n参见 meta/PHILOSOPHY_WEAVER.md + dimensions/PART_DECOMPOSITION.md + dimensions/SEARCH_METHODOLOGY.md。`);
       }
       break;
     }
@@ -368,22 +437,39 @@ try {
       break;
     }
 
-    case 'guide': {
-      const dryRun = argv.includes('--dry-run');
-      const result = guideProject(cwd(), { dryRun });
-      console.log(`阶段 ${result.stage_num}: ${result.stage}`);
-      if (dryRun) {
-        console.log('诊断: dry-run（不写 heartbeat）');
-      }
-      if (result.auto) {
-        console.log(`模式: AUTO（自动执行，不等确认）`);
-      } else {
-        console.log(`模式: 手动（每步需用户确认）`);
+    case 'guide': {
+      const dryRun = argv.includes('--dry-run');
+      const jsonOut = argv.includes('--json');
+      const result = guideProject(cwd(), { dryRun });
+      if (jsonOut) {
+        output(result);
+        break;
+      }
+      console.log(`阶段 ${result.stage_num}: ${result.stage}`);
+      if (dryRun) {
+        console.log('诊断: dry-run（不写 heartbeat）');
       }
+      const modeDesc = {
+        'manual': '手动（每步需确认）',
+        'auto-loop': 'AUTO auto-loop（设计阶段需 review，Intent Loop 自动）',
+        'auto-design': 'AUTO auto-design（全部自动）',
+      };
+      console.log(`模式: ${modeDesc[result.auto_mode] || result.auto_mode}`);
       console.log(`\n${result.message}`);
       console.log(`\n下一步: ${result.next_action}`);
       console.log(`  → ${result.next_command}`);
-      if (!result.auto && result.stage_num > 0 && result.stage_num < 6) {
+      if (result.inputs && result.inputs.length > 0) {
+        console.log(`\n需要读取:`);
+        for (const f of result.inputs) console.log(`  - ${f}`);
+      }
+      if (result.outputs && result.outputs.length > 0) {
+        console.log(`\n需要产出:`);
+        for (const f of result.outputs) console.log(`  - ${f}`);
+      }
+      if (result.verify_command) {
+        console.log(`\n完成后校验: ${result.verify_command}`);
+      }
+      if (result.auto_mode === 'manual' && result.stage_num > 0 && result.stage_num < 6) {
         console.log(`\n提示: 开启 AUTO 模式可自动连续执行 — loom auto on`);
       }
       break;
@@ -392,76 +478,93 @@ try {
     case 'auto': {
       const loomRoot = findLoomRoot();
       switch (sub) {
-        case 'on':
-          autoOn(loomRoot);
-          console.log('AUTO 模式已开启。Agent 将自动连续执行，不等用户确认。');
+        case 'on': {
+          // loom auto on → auto-loop（默认）
+          // loom auto on --design → auto-design
+          const wantDesign = argv.includes('--design');
+          const mode = wantDesign ? 'auto-design' : 'auto-loop';
+          autoOn(loomRoot, mode);
+          if (mode === 'auto-design') {
+            console.log('AUTO 模式: auto-design（全部自动，含哲学/愿景/架构）');
+            console.log('Agent 自动连续执行所有阶段，不等人类确认。');
+          } else {
+            console.log('AUTO 模式: auto-loop（Intent Loop 自动，设计阶段需 review）');
+            console.log('  - stage 1-3（哲学/愿景/架构）：自动执行但需人类 review');
+            console.log('  - stage 4+（Intent Loop）：自动连续执行');
+          }
           console.log('核心契约: 持续运行，除非出意外否则不允许私自停止。');
           console.log('  - L3 human_review 由 Keeper 自主判定，不停下等人类');
           console.log('  - 唯一允许停下的情况: blocked（依赖阻塞/契约无法判定/连续 3 轮 deviated 升级）');
-          console.log('关闭: loom auto off');
+          console.log('切换: loom auto on --design | loom auto off');
           break;
+        }
         case 'off':
           autoOff(loomRoot);
-          console.log('AUTO 模式已关闭。每步需要用户确认。');
+          console.log('AUTO 模式: manual（每步需人类确认）');
           break;
         case 'status': {
           const status = autoStatus(loomRoot);
-          if (status.on) {
-            console.log(`AUTO 模式: 开启（自 ${status.since}）`);
-            console.log('  规则: stage 1-3（哲学/愿景/架构）需人类 review，stage 4+（Intent Loop）自动执行');
-            if (status.heartbeat) {
-              const hb = status.heartbeat;
-              console.log(`  心跳: ${hb.timestamp}`);
-              console.log(`    阶段: ${hb.stage} (stage ${hb.stage_num})`);
-              console.log(`    下一步: ${hb.next_action}`);
-              console.log(`    命令: ${hb.next_command}`);
-            } else {
-              console.log('  心跳: 尚未记录（运行 loom guide 后生成）');
-            }
-          } else {
-            console.log('AUTO 模式: 关闭（所有阶段都需人类确认）');
+          const modeDesc = {
+            'manual': 'manual（每步需人类确认）',
+            'auto-loop': 'auto-loop（Intent Loop 自动，设计阶段需 review）',
+            'auto-design': 'auto-design（全部自动，含哲学/愿景/架构）',
+          };
+          console.log(`AUTO 模式: ${modeDesc[status.mode] || status.mode}`);
+          if (status.mode === 'auto-loop') {
+            console.log('  规则: stage 1-3 需人类 review，stage 4+ 自动执行');
+          } else if (status.mode === 'auto-design') {
+            console.log('  规则: 全部阶段自动执行，不需人类 review');
+          }
+          if (status.heartbeat) {
+            const hb = status.heartbeat;
+            console.log(`  心跳: ${hb.timestamp}`);
+            console.log(`    阶段: ${hb.stage} (stage ${hb.stage_num})`);
+            console.log(`    下一步: ${hb.next_action}`);
+            console.log(`    命令: ${hb.next_command}`);
+          } else if (status.mode !== 'manual') {
+            console.log('  心跳: 尚未记录（运行 loom guide 后生成）');
           }
           break;
         }
         default:
-          die(`未知子命令: auto ${sub}\n用法: loom auto [on|off|status]`);
+          die(`未知子命令: auto ${sub}\n用法: loom auto [on [--design]|off|status]`);
       }
       break;
     }
 
-    case 'preview': {
-      const previewFile = join(cwd(), 'loom-preview.html');
-      if (argv.includes('--help') || argv.includes('-h')) {
-        console.log(`用法:
-  loom preview              打开新鲜 preview；过期时提示重新生成
-  loom preview --regen      输出生成提示词，让 Agent 重写 loom-preview.html
-  loom preview status       检查 preview 是否存在、是否新鲜
-  loom preview --stale      强行打开过期 preview
-  loom preview --help       显示本帮助`);
-        break;
-      }
-      const status = getPreviewStatus(cwd());
-      const hasPreview = status.exists;
-      const regenOnly = argv.includes('--regen') || argv.includes('-r');
-      const openStale = argv.includes('--stale');
-
-      if (sub === 'status') {
-        output(status);
-        break;
-      }
-
-      // 已有 HTML 且没指定 --regen：直接打开浏览器
-      if (hasPreview && !regenOnly) {
-        if (!status.fresh && !openStale) {
-          console.log('preview 已过期：.loom 源文件比 loom-preview.html 更新。');
-          console.log(`  preview: ${status.preview_mtime || '未知'}`);
-          console.log(`  最新源: ${status.source_latest_mtime || '未知'} ${status.latest_source_file ? `(${status.latest_source_file})` : ''}`);
-          console.log('\n下一步: loom preview --regen');
-          console.log('强行打开旧 preview: loom preview --stale');
-          break;
-        }
-        const { spawn } = await import('node:child_process');
-        const target = previewFile.replace(/\\/g, '/');
+    case 'preview': {
+      const previewFile = join(cwd(), 'loom-preview.html');
+      if (argv.includes('--help') || argv.includes('-h')) {
+        console.log(`用法:
+  loom preview              打开新鲜 preview；过期时提示重新生成
+  loom preview --regen      输出生成提示词，让 Agent 重写 loom-preview.html
+  loom preview status       检查 preview 是否存在、是否新鲜
+  loom preview --stale      强行打开过期 preview
+  loom preview --help       显示本帮助`);
+        break;
+      }
+      const status = getPreviewStatus(cwd());
+      const hasPreview = status.exists;
+      const regenOnly = argv.includes('--regen') || argv.includes('-r');
+      const openStale = argv.includes('--stale');
+
+      if (sub === 'status') {
+        output(status);
+        break;
+      }
+
+      // 已有 HTML 且没指定 --regen：直接打开浏览器
+      if (hasPreview && !regenOnly) {
+        if (!status.fresh && !openStale) {
+          console.log('preview 已过期：.loom 源文件比 loom-preview.html 更新。');
+          console.log(`  preview: ${status.preview_mtime || '未知'}`);
+          console.log(`  最新源: ${status.source_latest_mtime || '未知'} ${status.latest_source_file ? `(${status.latest_source_file})` : ''}`);
+          console.log('\n下一步: loom preview --regen');
+          console.log('强行打开旧 preview: loom preview --stale');
+          break;
+        }
+        const { spawn } = await import('node:child_process');
+        const target = previewFile.replace(/\\/g, '/');
         if (process.platform === 'win32') {
           spawn('cmd', ['/c', 'start', target], { detached: true, stdio: 'ignore' }).unref();
         } else if (process.platform === 'darwin') {
@@ -470,9 +573,9 @@ try {
           spawn('xdg-open', [target], { detached: true, stdio: 'ignore' }).unref();
         }
         console.log(`已打开浏览器: ${previewFile}`);
-        console.log(status.fresh ? `重新生成: loom preview --regen` : `已打开旧 preview。重新生成: loom preview --regen`);
-        break;
-      }
+        console.log(status.fresh ? `重新生成: loom preview --regen` : `已打开旧 preview。重新生成: loom preview --regen`);
+        break;
+      }
 
       // 没有 HTML 或指定 --regen：输出提示词让 AI 生成
       const prompt = generatePreviewPrompt();
@@ -508,10 +611,10 @@ To Human:
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
 用法:
-  loom init                     初始化项目（创建 .loom/v1/ 骨架 + 模板）
-  loom guide                    诊断当前阶段，输出下一步引导
-  loom guide --dry-run          只读诊断当前阶段，不写 heartbeat
-  loom auto on|off|status       AUTO 模式开关（on 时 Agent 自动连续执行）
+  loom init                     初始化项目（创建 .loom/v1/ 骨架 + 模板）
+  loom guide                    诊断当前阶段，输出下一步引导
+  loom guide --dry-run          只读诊断当前阶段，不写 heartbeat
+  loom auto on|off|status       AUTO 模式开关（on 时 Agent 自动连续执行）
   loom activate <role>          输出角色激活提示词（weaver|visionary|architect|forge|keeper）
 
   loom version list             列出所有版本（* 标记当前）
@@ -533,11 +636,11 @@ To Human:
 
   loom doctor                   项目健康检查（一致性+孤儿引用+循环依赖+僵尸）
   loom context                  上下文摘要（进度+下一步+待验证+风险）
-  loom preview                  打开新鲜 HTML；过期则提示重新生成
-  loom preview status           检查 preview 是否存在、是否新鲜
-  loom preview --regen          强制重新输出提示词（让 AI 重新生成 HTML）
-  loom preview --stale          强行打开过期 preview
-  loom help <topic>             分层指南（workflow|concepts|loop|version|doctor|preview）
+  loom preview                  打开新鲜 HTML；过期则提示重新生成
+  loom preview status           检查 preview 是否存在、是否新鲜
+  loom preview --regen          强制重新输出提示词（让 AI 重新生成 HTML）
+  loom preview --stale          强行打开过期 preview
+  loom help <topic>             分层指南（workflow|concepts|loop|version|doctor|preview）
 
   loom philosophy get <anchor>  按锚点加载哲学章节
   loom philosophy list          列出哲学文档文件

package/cli/src/auto.js

@@ -1,31 +1,54 @@
 // auto — AUTO 模式开关 + 心跳机制
-// 存储机制：.loom/auto 文件存在 = on，不存在 = off
+// 存储机制：.loom/auto 文件内容 = 模式名（auto-loop / auto-design），不存在 = manual
 // 心跳：每次 guide 调用时写 .loom/heartbeat.json（时间戳 + stage + next_command）
-// AUTO on（默认）：stage 4+（Intent Loop）自动跑，stage 1-3（哲学/愿景/架构）仍需人类 review
-// AUTO off：所有阶段都需人类确认，每步拆得更碎
+//
+// 三种模式：
+//   manual      — 每步停，所有阶段需人类 review
+//   auto-loop   — 只 Intent Loop（stage 4+）自动，stage 1-3 仍需人类 review（默认）
+//   auto-design — 哲学/愿景/架构也自动，全部阶段不需人类 review
 
 import { existsSync, writeFileSync, unlinkSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 
+const VALID_MODES = ['auto-loop', 'auto-design'];
+
 /**
- * 检查 AUTO 模式是否开启。
+ * 读取 .loom/auto 文件内容，返回模式名。
+ * 向后兼容：空文件 / 旧时间戳 / 未知内容 → auto-loop
+ * @param {string} loomRoot — .loom 目录路径
+ * @returns {string} 'manual' | 'auto-loop' | 'auto-design'
+ */
+export function getAutoMode(loomRoot) {
+  const path = join(loomRoot, 'auto');
+  if (!existsSync(path)) return 'manual';
+  const content = readFileSync(path, 'utf-8').trim();
+  if (VALID_MODES.includes(content)) return content;
+  return 'auto-loop'; // 旧格式兼容
+}
+
+/**
+ * 检查 AUTO 模式是否开启（非 manual）。
  * @param {string} loomRoot — .loom 目录路径
  * @returns {boolean}
  */
 export function isAutoOn(loomRoot) {
-  return existsSync(join(loomRoot, 'auto'));
+  return getAutoMode(loomRoot) !== 'manual';
 }
 
 /**
  * 开启 AUTO 模式。
  * @param {string} loomRoot — .loom 目录路径
+ * @param {string} mode — 'auto-loop' | 'auto-design'
  */
-export function autoOn(loomRoot) {
-  writeFileSync(join(loomRoot, 'auto'), new Date().toISOString(), 'utf-8');
+export function autoOn(loomRoot, mode = 'auto-loop') {
+  if (!VALID_MODES.includes(mode)) {
+    throw new Error(`非法 AUTO 模式: "${mode}" (合法: ${VALID_MODES.join(' | ')})`);
+  }
+  writeFileSync(join(loomRoot, 'auto'), mode, 'utf-8');
 }
 
 /**
- * 关闭 AUTO 模式。
+ * 关闭 AUTO 模式（切换到 manual）。
  * @param {string} loomRoot — .loom 目录路径
  */
 export function autoOff(loomRoot) {
@@ -36,14 +59,12 @@ export function autoOff(loomRoot) {
 /**
  * 获取 AUTO 状态描述。
  * @param {string} loomRoot — .loom 目录路径
- * @returns {{ on: boolean, since: string|null, heartbeat: object|null }}
+ * @returns {{ mode: string, heartbeat: object|null }}
  */
 export function autoStatus(loomRoot) {
-  const path = join(loomRoot, 'auto');
-  if (!existsSync(path)) return { on: false, since: null, heartbeat: null };
-  const since = readFileSync(path, 'utf-8').trim();
+  const mode = getAutoMode(loomRoot);
   const heartbeat = readHeartbeat(loomRoot);
-  return { on: true, since, heartbeat };
+  return { mode, heartbeat };
 }
 
 /**
@@ -79,15 +100,17 @@ export function readHeartbeat(loomRoot) {
 
 /**
  * 判断当前阶段是否需要人类 review。
- * AUTO on 时：stage 1-3（哲学/愿景/架构）需要人类 review，stage 4+ 自动跑
- * AUTO off 时：所有阶段都需要人类 review
+ * manual：全部需 review
+ * auto-loop：stage 1-3 需 review，stage 4+ 自动
+ * auto-design：全部自动
  * @param {string} loomRoot — .loom 目录路径
  * @param {number} stageNum — 阶段号
  * @returns {boolean} 是否需要人类 review
  */
 export function needsHumanReview(loomRoot, stageNum) {
-  const autoOn = isAutoOn(loomRoot);
-  if (!autoOn) return true; // AUTO off：所有阶段都需人类 review
-  // AUTO on：stage 1-3 需人类 review，stage 4+ 自动
+  const mode = getAutoMode(loomRoot);
+  if (mode === 'manual') return true;
+  if (mode === 'auto-design') return false;
+  // auto-loop：stage 1-3 需 review，stage 4+ 自动
   return stageNum > 0 && stageNum < 4;
 }