@haaaiawd/loom 0.8.0 → 0.10.0

package/cli/src/guide.js

@@ -6,7 +6,7 @@ import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { readCurrentPointer } from './version.js';
 import { loadIntentMap } from './intent-map.js';
-import { isAutoOn, writeHeartbeat, needsHumanReview } from './auto.js';
+import { isAutoOn, getAutoMode, writeHeartbeat, needsHumanReview } from './auto.js';
 
 /**
  * 检测文件是否还是模板（未填充真实内容）。
@@ -36,17 +36,78 @@ function isTemplate(filePath) {
 /**
  * 诊断项目当前阶段。
  * @param {string} projectDir — 项目根目录
- * @returns {{ stage: string, stage_num: number, details: object, auto: boolean, next_action: string, next_command: string, message: string, needs_human_review: boolean }}
- */
-export function guideProject(projectDir, options = {}) {
-  const cwd = projectDir || process.cwd();
-  const loomRoot = join(cwd, '.loom');
-  const auto = isAutoOn(loomRoot);
-  const result = diagnoseStage(cwd, loomRoot, auto);
-  // 统一后处理：写心跳 + 加 AUTO 提示词 + 判断是否需要人类 review
-  if (existsSync(loomRoot) && !options.dryRun) {
-    try {
-      writeHeartbeat(loomRoot, {
+ * @returns {{ stage: string, stage_num: number, details: object, auto: boolean, next_action: string, next_command: string, message: string, needs_human_review: boolean }}
+ */
+export function guideProject(projectDir, options = {}) {
+  const cwd = projectDir || process.cwd();
+  const loomRoot = join(cwd, '.loom');
+  const autoMode = getAutoMode(loomRoot);
+  const auto = autoMode !== 'manual'; // 向后兼容 boolean
+  const result = diagnoseStage(cwd, loomRoot, auto);
+  result.auto_mode = autoMode;
+
+  // 按 stage 补充可执行信息：要读什么、要产出什么、完成后跑什么校验
+  const current = result.details.version || 'v1';
+  const stageMeta = {
+    not_initialized: {
+      inputs: [],
+      outputs: ['.loom/v1/'],
+      verify_command: 'loom guide',
+    },
+    no_version: {
+      inputs: [],
+      outputs: ['.loom/v1/'],
+      verify_command: 'loom guide',
+    },
+    need_philosophy: {
+      inputs: ['meta/PHILOSOPHY_WEAVER.md', 'meta/BASELINE.md', 'dimensions/PART_DECOMPOSITION.md', 'dimensions/SEARCH_METHODOLOGY.md'],
+      outputs: [`.loom/${current}/00_PHILOSOPHY/PRODUCT_PHILOSOPHY.md`, `.loom/${current}/00_PHILOSOPHY/ENGINEERING_CREED.md`, `.loom/${current}/00_PHILOSOPHY/DECISION_RUBRIC.md`],
+      verify_command: 'loom philosophy check',
+    },
+    need_vision: {
+      inputs: ['roles/visionary.md', `.loom/${current}/00_PHILOSOPHY/`],
+      outputs: [`.loom/${current}/01_VISION.md`],
+      verify_command: 'loom guide',
+    },
+    need_architecture: {
+      inputs: ['roles/architect.md', `.loom/${current}/01_VISION.md`],
+      outputs: [`.loom/${current}/02_ARCHITECTURE.md`, `.loom/${current}/04_INTENT_MAP.json`],
+      verify_command: 'loom doctor',
+    },
+    intent_map_broken: {
+      inputs: [`.loom/${current}/04_INTENT_MAP.json`],
+      outputs: [`.loom/${current}/04_INTENT_MAP.json`],
+      verify_command: 'loom intent validate',
+    },
+    in_loop: {
+      inputs: ['roles/forge.md', 'roles/keeper.md', `.loom/${current}/04_INTENT_MAP.json`],
+      outputs: ['代码文件', `.loom/${current}/verifications/INT-*.json`],
+      verify_command: 'loom verify pending',
+    },
+    ready_for_loop: {
+      inputs: ['roles/forge.md', 'roles/keeper.md', `.loom/${current}/04_INTENT_MAP.json`],
+      outputs: ['代码文件', `.loom/${current}/verifications/INT-*.json`],
+      verify_command: 'loom verify pending',
+    },
+    all_done: {
+      inputs: [],
+      outputs: [],
+      verify_command: 'loom doctor',
+    },
+    unknown: {
+      inputs: [],
+      outputs: [],
+      verify_command: 'loom doctor',
+    },
+  };
+  const meta = stageMeta[result.stage] || {};
+  result.inputs = meta.inputs || [];
+  result.outputs = meta.outputs || [];
+  result.verify_command = meta.verify_command || null;
+  // 统一后处理：写心跳 + 加 AUTO 提示词 + 判断是否需要人类 review
+  if (existsSync(loomRoot) && !options.dryRun) {
+    try {
+      writeHeartbeat(loomRoot, {
         stage: result.stage,
         stage_num: result.stage_num,
         next_command: result.next_command,
@@ -57,13 +118,19 @@ export function guideProject(projectDir, options = {}) {
   result.needs_human_review = needsHumanReview(loomRoot, result.stage_num);
   // 在 message 末尾加 AUTO 提示
   if (result.stage_num > 0 && result.stage_num < 4) {
-    result.message += auto
-      ? '\n\n> ⚠ 这是设计阶段（哲学/愿景/架构），即使 AUTO 模式开启也需要人类 review 后再继续。'
-      : '\n\n> ⚠ AUTO 模式关闭——每步都需要人类确认后再继续。';
-  } else if (result.stage_num >= 4 && !auto) {
-    result.message += '\n\n> ⚠ AUTO 模式关闭——执行 next_command 后等人类确认再继续。';
-  } else if (result.stage_num >= 4 && auto) {
-    result.message += '\n\n> AUTO 模式开启——直接执行 next_command，无需人类确认。';
+    if (autoMode === 'auto-design') {
+      result.message += '\n\n> AUTO 模式 auto-design——设计阶段也自动执行，无需人类确认。';
+    } else if (autoMode === 'auto-loop') {
+      result.message += '\n\n> ⚠ 这是设计阶段（哲学/愿景/架构），auto-loop 模式下需要人类 review 后再继续。';
+    } else {
+      result.message += '\n\n> ⚠ AUTO 模式 manual——每步都需要人类确认后再继续。';
+    }
+  } else if (result.stage_num >= 4) {
+    if (auto) {
+      result.message += '\n\n> AUTO 模式开启——直接执行 next_command，无需人类确认。';
+    } else {
+      result.message += '\n\n> ⚠ AUTO 模式关闭——执行 next_command 后等人类确认再继续。';
+    }
   }
   return result;
 }
@@ -145,11 +212,11 @@ function diagnoseStage(cwd, loomRoot, auto) {
   }
 
   // 状态 4-7: Intent Map 已设计，根据 Intent 状态判断
-  let intentMap;
-  let intents;
-  try {
-    intentMap = loadIntentMap(versionDir);
-    intents = intentMap.intents;
+  let intentMap;
+  let intents;
+  try {
+    intentMap = loadIntentMap(versionDir);
+    intents = intentMap.intents;
   } catch (e) {
     return {
       stage: 'intent_map_broken',
@@ -220,7 +287,7 @@ function diagnoseStage(cwd, loomRoot, auto) {
   if (counts.needs_review > 0) {
     const reviewIds = allIntents.filter((i) => i.status === 'needs_review').map((i) => i.id);
     // 读 _meta.pass_count 收敛趟计数（最大 3 趟）
-    const passCount = intentMap._meta?.pass_count || 1;
+    const passCount = intentMap._meta?.pass_count || 1;
     const MAX_PASSES = 3;
     const isOverLimit = passCount > MAX_PASSES;
     const passMsg = ` [Pass ${passCount}/${MAX_PASSES}]`;

package/cli/src/philosophy.js

@@ -62,10 +62,13 @@ const REASON_KEYWORDS = ['萃取', '理由', '为什么', '因为', '启发', '
  * 从哲学文档内容中提取"灵感来源"章节的条目。
  * @param {string} content — MD 全文
  * @returns {Array<{ raw: string, name: string, urls: string[], hasReason: boolean }>}
+ *   如果返回空数组，调用方需区分"没有章节"和"有章节但没条目"——
+ *   用 hasInspirationSection() 单独判断。
  */
 function parseInspirationSources(content) {
-  // 匹配 "## 灵感来源" 或 "## Inspiration" 章节
-  const sectionMatch = content.match(/^##\s+(?:灵感来源|Inspiration|参考来源|References)/m);
+  // 匹配 "## 灵感来源" 或 "## Inspiration Sources" 等章节
+  // 支持 {#anchor} 后缀和多种标题变体
+  const sectionMatch = content.match(/^##\s+(?:灵感来源|Inspiration|参考来源|References?|参考文献|参考资料|Sources|Bibliography)/m);
   if (!sectionMatch) return [];
 
   const startIdx = sectionMatch.index + sectionMatch[0].length;
@@ -75,24 +78,29 @@ function parseInspirationSources(content) {
     ? content.slice(startIdx, startIdx + nextSection.index)
     : content.slice(startIdx);
 
-  // 解析每个 list item（- 或 * 开头）
+  // 解析每个 list item（- / * / 1. / 2. 等开头的无序或有序列表）
   const items = [];
   const lines = sectionText.split('\n');
   let currentItem = null;
 
+  // 匹配 - xxx / * xxx / 1. xxx / 2. xxx 等
+  const ITEM_RE = /^\s*(?:[-*]|\d+\.)\s+/;
+  // URL 匹配：https:// / file:// / local:./path / local:/abs/path
+  const URL_RE = /(?:https?:|file:)[\/]+[^\s）)]+|local:[^\s）)]+/g;
+
   for (const line of lines) {
-    if (/^\s*[-*]\s/.test(line)) {
+    if (ITEM_RE.test(line)) {
       // 新条目
       if (currentItem) items.push(currentItem);
-      const raw = line.replace(/^\s*[-*]\s/, '').trim();
-      const urls = [...raw.matchAll(/https?:\/\/[^\s）)]+/g)].map((m) => m[0]);
+      const raw = line.replace(ITEM_RE, '').trim();
+      const urls = [...raw.matchAll(URL_RE)].map((m) => m[0]);
       const name = raw.replace(/\*\*/g, '').split(/[（(——]/)[0].trim();
       const hasReason = REASON_KEYWORDS.some((kw) => raw.includes(kw));
       currentItem = { raw, name, urls, hasReason };
     } else if (currentItem && line.trim()) {
       // 多行条目的续行
       currentItem.raw += ' ' + line.trim();
-      const newUrls = [...line.matchAll(/https?:\/\/[^\s）)]+/g)].map((m) => m[0]);
+      const newUrls = [...line.matchAll(URL_RE)].map((m) => m[0]);
       currentItem.urls.push(...newUrls);
       if (REASON_KEYWORDS.some((kw) => line.includes(kw))) {
         currentItem.hasReason = true;
@@ -103,6 +111,14 @@ function parseInspirationSources(content) {
   return items;
 }
 
+/**
+ * 检查哲学文档是否有"灵感来源"章节（不管有没有条目）。
+ * 用来区分"没有章节"和"有章节但没条目"两种情况。
+ */
+function hasInspirationSection(content) {
+  return /^##\s+(?:灵感来源|Inspiration|参考来源|References?|参考文献|参考资料|Sources|Bibliography)/m.test(content);
+}
+
 /**
  * 判断 URL 是否为 Wikipedia 链接。
  */
@@ -173,12 +189,26 @@ export function validateInspirationSources(philosophyDir) {
     }
   }
 
-  // 如果没有任何文件包含灵感来源章节
+  // 如果没有任何文件提取到灵感来源条目
   if (allSources.length === 0) {
-    issues.push({
-      severity: 'high',
-      msg: '所有哲学文档都没有"灵感来源"章节。PHILOSOPHY_WEAVER.md 要求哲学文档必须包含灵感来源（参考了哪些机构、人物、流派——附 URL 和理由）。',
-    });
+    // 区分两种情况：完全没有章节 vs 有章节但没条目
+    const filesWithSection = [];
+    for (const file of files) {
+      const content = readFileSync(join(philosophyDir, file), 'utf-8');
+      if (hasInspirationSection(content)) filesWithSection.push(file);
+    }
+
+    if (filesWithSection.length > 0) {
+      issues.push({
+        severity: 'high',
+        msg: `${filesWithSection.join(', ')} 有"灵感来源"章节但没有可识别的条目。章节里可能是模板占位符。需要 Weaver 真正走搜索漏斗，填入至少 ${MIN_SOURCES} 个源（- **源名** — 理由。来源：URL 格式）。`,
+      });
+    } else {
+      issues.push({
+        severity: 'high',
+        msg: '所有哲学文档都没有"灵感来源"章节。PHILOSOPHY_WEAVER.md 要求哲学文档必须包含灵感来源（参考了哪些机构、人物、流派——附 URL 和理由）。支持的标题：灵感来源 / Inspiration / 参考来源 / References / 参考文献 / 参考资料 / Sources / Bibliography。',
+      });
+    }
   }
 
   return {
@@ -204,7 +234,7 @@ export function validatePartDecomposition(philosophyDir) {
 
   const files = listPhilosophyFiles(philosophyDir);
 
-  // 搜索"实现部分"相关章节——可能叫"实现部分清单""部分拆解""Part Decomposition"等
+  // 搜索"实现部分"相关章节——支持 {#anchor} 后缀和多种标题变体
   const PART_SECTION_PATTERNS = [
     /^##\s+实现部分清单/m,
     /^##\s+部分拆解/m,
@@ -212,11 +242,15 @@ export function validatePartDecomposition(philosophyDir) {
     /^##\s+Part Decomposition/m,
     /^##\s+Implementation Parts/m,
     /^##\s+拆解出的部分/m,
+    /^##\s+Implementation Decomposition/m,
+    /^##\s+Parts? /m,
   ];
 
-  // 搜索部分条目——通常是 "- **部分名**" 或 "├── 部分名" 或 "| 部分名 |"
+  // 搜索部分条目——支持无序列表、有序列表、树形符号
   const PART_ITEM_PATTERNS = [
-    /^\s*[-*]\s+\*\*(.+?)\*\*/gm,  // - **CLI 交互设计**
+    /^\s*[-*]\s+\*\*(.+?)\*\*/gm,    // - **CLI 交互设计**
+    /^\s*\d+\.\s+\*\*(.+?)\*\*/gm,   // 1. **CLI 交互设计**
+    /^\s*\d+\.\s+(.+)/gm,            // 1. CLI 交互设计
     /^\s*├──\s+(.+)/gm,              // ├── CLI 交互设计
     /^\s*└──\s+(.+)/gm,              // └── 产物设计
   ];
@@ -257,12 +291,12 @@ export function validatePartDecomposition(philosophyDir) {
   if (!foundSection) {
     issues.push({
       severity: 'high',
-      msg: '哲学文档没有"实现部分清单"章节。PHILOSOPHY_WEAVER.md Step 2 要求按 PART_DECOMPOSITION.md 拆解实现部分，并在哲学文档中显式列出。可能 Weaver 跳过了拆解步骤。',
+      msg: '哲学文档没有"实现部分清单"章节。PHILOSOPHY_WEAVER.md Step 2 要求按 PART_DECOMPOSITION.md 拆解实现部分，并在哲学文档中显式列出。支持的标题：实现部分清单 / 部分拆解 / 实现部分 / Part Decomposition / Implementation Parts / 拆解出的部分。',
     });
   } else if (parts.length < 2) {
     issues.push({
       severity: 'medium',
-      msg: `实现部分清单仅识别到 ${parts.length} 个部分。PART_DECOMPOSITION.md 建议小项目 3-5 个部分，大项目 6-10 个。可能拆解不充分。`,
+      msg: `找到"实现部分清单"章节但仅识别到 ${parts.length} 个部分。可能章节里是模板占位符，或条目格式不被识别（用 - **部分名** 或 ├── 部分名 格式）。PART_DECOMPOSITION.md 建议小项目 3-5 个部分，大项目 6-10 个。`,
     });
   }
 

package/cli/src/verify.js

@@ -92,14 +92,14 @@ export function writeVerification(verificationsDir, record) {
     data = { intent_id: record.intent_id, records: [] };
   }
 
-  // 计算轮次和连续 deviated 计数。规范要求中间出现 passed/blocked 后重置。
-  const round = data.records.length + 1;
-  const recordsWithCurrent = [...data.records, record];
-  let deviatedCount = 0;
-  for (let i = recordsWithCurrent.length - 1; i >= 0; i--) {
-    if (recordsWithCurrent[i].verdict !== 'deviated') break;
-    deviatedCount++;
-  }
+  // 计算轮次和连续 deviated 计数。规范要求中间出现 passed/blocked 后重置。
+  const round = data.records.length + 1;
+  const recordsWithCurrent = [...data.records, record];
+  let deviatedCount = 0;
+  for (let i = recordsWithCurrent.length - 1; i >= 0; i--) {
+    if (recordsWithCurrent[i].verdict !== 'deviated') break;
+    deviatedCount++;
+  }
 
   // 追加新记录
   data.records.push({
@@ -134,6 +134,36 @@ export function getVerificationHistory(verificationsDir, intentId) {
   return readJsonFile(filePath, '验证记录');
 }
 
+/**
+ * 快捷创建验证记录——Agent 不用手动构造完整 JSON。
+ * 内部用 summary 填充四个维度的 evidence，生成标准记录格式。
+ * @param {string} verificationsDir — verifications/ 目录路径
+ * @param {string} intentId — 如 "INT-001"
+ * @param {string} verdict — 'passed' | 'deviated' | 'blocked'
+ * @param {string} summary — 验证摘要（也会作为四个维度的 evidence）
+ * @param {object} [extras]
+ * @param {string} [extras.reproduction_command] — 复现命令
+ * @param {string} [extras.deviation_detail] — 偏离说明（deviated 时）
+ * @returns {{ filePath: string, round: number, deviated_count: number, should_escalate: boolean }}
+ */
+export function createQuickVerification(verificationsDir, intentId, verdict, summary, extras = {}) {
+  const timestamp = new Date().toISOString();
+  // 用 summary 填充四个维度的 evidence——快捷命令不要求 Agent 逐维度写
+  const dimensions = {};
+  for (const dim of REQUIRED_DIMENSIONS) {
+    dimensions[dim] = { verdict, evidence: summary };
+  }
+  return writeVerification(verificationsDir, {
+    intent_id: intentId,
+    verdict,
+    timestamp,
+    summary,
+    dimensions,
+    reproduction_command: extras.reproduction_command || null,
+    deviation_detail: extras.deviation_detail || null,
+  });
+}
+
 /**
  * 返回所有待验证的 Intent（有实现产物但还没验证记录的）。
  * 需要传入 Intent Map 来判断哪些 Intent 是 in_progress。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haaaiawd/loom",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "LOOM — 哲学驱动开发框架。Agent 通过 CLI 访问 Intent Map / 哲学 / 验证记录，不直接读文件",
   "type": "module",
   "bin": {
@@ -35,8 +35,8 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/Haaaiawd/loom.git"
-  },
-  "homepage": "https://github.com/Haaaiawd/loom#readme",
+    "url": "git+https://github.com/Haaaiawd/loom.git"
+  },
+  "homepage": "https://github.com/Haaaiawd/loom#readme",
   "author": "haaaiawd"
 }