@haaaiawd/anws 1.2.5 → 2.0.0

package/lib/update.js

@@ -2,85 +2,186 @@
 
 const fs = require('node:fs/promises');
 const path = require('node:path');
-const { MANAGED_FILES, USER_PROTECTED_FILES } = require('./manifest');
-const { resolveAgentsInstall, printLegacyMigrationWarning, pathExists } = require('./agents');
-const { success, warn, error, info, fileLine, skippedLine, blank, logo } = require('./output');
-
-/**
- * anws update — 将当前项目的托管文件更新到最新版本
- */
-async function update() {
+const { buildProjectionPlan } = require('./manifest');
+const { getTarget } = require('./adapters');
+const { planAgentsUpdate, resolveAgentsInstall, printLegacyMigrationWarning, pathExists } = require('./agents');
+const { collectManagedFileDiffs, printPreview } = require('./diff');
+const { detectUpgrade, generateChangelog } = require('./changelog');
+const { writeTargetFiles } = require('./copy');
+const { createInstallLock, dedupeTargets, detectInstallState, summarizeTargetState, writeInstallLock } = require('./install-state');
+const { confirm } = require('./prompt');
+const { ROOT_AGENTS_FILE, resolveCanonicalSource } = require('./resources');
+const { success, warn, error, info, fileLine, skippedLine, blank, logo, section } = require('./output');
+
+async function update(options = {}) {
   const cwd = process.cwd();
-  const agentDir = path.join(cwd, '.agent');
+  const check = !!options.check;
+  const legacyAgentDir = path.join(cwd, '.agent');
+  const { version } = require(path.join(__dirname, '..', 'package.json'));
+  const installState = await detectInstallState(cwd);
+  const legacyAgentExists = await pathExists(legacyAgentDir);
+  const isLegacyMigration = installState.selectedTargets.length === 0 && legacyAgentExists;
+  const selectedTargetIds = isLegacyMigration ? ['antigravity'] : installState.selectedTargets;
+  const targetPlans = buildProjectionPlan(selectedTargetIds);
 
-  // 检查 .agent/ 是否存在
-  const agentExists = await pathExists(agentDir);
-  if (!agentExists) {
+  if (selectedTargetIds.length === 0 && !legacyAgentExists) {
     logo();
-    error('No .agent/ found in current directory.');
+    error('No supported Anws target layout found in current directory.');
     info('Run `anws init` first to set up the workflow system.');
     process.exit(1);
   }
 
-  // 询问确认
-  const confirmed = await askUpdate();
-  if (!confirmed) {
+  const srcAgents = ROOT_AGENTS_FILE;
+
+  if (isLegacyMigration) {
+    logo();
+    blank();
+    printLegacyMigrationNotice();
     blank();
-    info('Aborted. No files were changed.');
-    process.exit(0);
   }
 
-  logo();
-  // 仅覆盖托管文件；USER_PROTECTED_FILES 永远跳过
-  const srcRoot = path.join(__dirname, '..', 'templates', '.agent');
-  const srcAgents = path.join(__dirname, '..', 'templates', 'AGENTS.md');
-  const agentsDecision = await resolveAgentsInstall({
-    cwd,
-    askMigrate,
-    forceYes: !!global.__ANWS_FORCE_YES
-  });
+  const versionState = await detectUpgrade({ cwd, version });
+  const targetContexts = [];
 
-  if (!agentsDecision.shouldWriteRootAgents && agentsDecision.legacyExists) {
-    info('Keeping legacy .agent/rules/agents.md. Will not pull root AGENTS.md.');
-  }
-  if (agentsDecision.shouldWarnMigration) {
-    printLegacyMigrationWarning();
-  }
+  for (const targetPlan of targetPlans) {
+    const target = getTarget(targetPlan.targetId);
+    const agentsDecision = target.id === 'antigravity'
+      ? await resolveAgentsInstall({
+        cwd,
+        askMigrate,
+        forceYes: !!global.__ANWS_FORCE_YES
+      })
+      : {
+        shouldWriteRootAgents: false,
+        shouldWarnMigration: false,
+        rootExists: false,
+        legacyExists: false
+      };
 
-  const updated = [];
-  const skipped = [];
+    if (!agentsDecision.shouldWriteRootAgents && agentsDecision.legacyExists) {
+      info('Keeping legacy .agent/rules/agents.md. Will not pull root AGENTS.md.');
+    }
+    if (agentsDecision.shouldWarnMigration) {
+      printLegacyMigrationWarning();
+    }
 
-  for (const rel of MANAGED_FILES) {
-    if (rel === 'AGENTS.md' && !agentsDecision.shouldWriteRootAgents) {
-      skipped.push(rel);
-      continue;
+    let agentsUpdatePlan = null;
+    if (agentsDecision.shouldWriteRootAgents && agentsDecision.rootExists) {
+      const templateContent = await fs.readFile(srcAgents, 'utf8');
+      const existingContent = await fs.readFile(path.join(cwd, 'AGENTS.md'), 'utf8');
+      agentsUpdatePlan = planAgentsUpdate({ templateContent, existingContent });
+
+      if (agentsUpdatePlan.warning) {
+        warn(agentsUpdatePlan.warning);
+      }
     }
 
-    if (USER_PROTECTED_FILES.includes(rel)) {
-      if (!(rel === 'AGENTS.md' && agentsDecision.shouldWriteRootAgents && !agentsDecision.rootExists)) {
-        skipped.push(rel);
-        continue;
+    const rawChanges = await collectManagedFileDiffs({
+      cwd,
+      projectionPlan: [targetPlan],
+      srcAgents,
+      shouldWriteRootAgents: agentsDecision.shouldWriteRootAgents,
+      agentsUpdatePlan
+    });
+    const changes = rawChanges.filter((item) => {
+      if (item.file !== 'AGENTS.md') return true;
+      if (agentsUpdatePlan && agentsUpdatePlan.mode === 'skip') return false;
+      return agentsDecision.shouldWriteRootAgents;
+    });
+
+    targetContexts.push({
+      target,
+      targetPlan,
+      agentsDecision,
+      agentsUpdatePlan,
+      changes
+    });
+  }
+
+  const changes = targetContexts.flatMap((context) => context.changes);
+
+  if (check) {
+    if (!versionState.needUpgrade) {
+      if (!isLegacyMigration) {
+        logo();
+        blank();
       }
+      info(`Already up to date. Latest recorded version is v${versionState.latestVersion || version}.`);
+      printTargetSelection(installState, targetContexts.map((context) => context.target));
+      return;
     }
+    if (!isLegacyMigration) {
+      logo();
+      blank();
+    }
+    printTargetSelection(installState, targetContexts.map((context) => context.target));
+    printPreview({
+      fromVersion: versionState.fromVersion,
+      toVersion: versionState.toVersion,
+      changes
+    });
+    return;
+  }
 
-    const srcPath = rel === 'AGENTS.md' ? srcAgents : path.join(path.dirname(srcRoot), rel);
-    const destPath = path.join(cwd, rel);
+  if (!versionState.needUpgrade) {
+    if (!isLegacyMigration) {
+      logo();
+      blank();
+    }
+    info(`Already up to date. Latest recorded version is v${versionState.latestVersion || version}.`);
+    return;
+  }
 
-    const srcExists = await pathExists(srcPath);
-    if (!srcExists) continue;
+  if (!isLegacyMigration) {
+    logo();
+    blank();
+  }
 
-    await fs.mkdir(path.dirname(destPath), { recursive: true });
-    await fs.copyFile(srcPath, destPath);
-    updated.push(rel);
+  const confirmed = await askUpdate({
+    installState,
+    targets: targetContexts.map((context) => context.target)
+  });
+  if (!confirmed) {
+    blank();
+    info('Aborted. No files were changed.');
+    return;
+  }
+
+  const updated = [];
+  const skipped = [];
+  const successfulTargets = [];
+  const failedTargets = [];
+
+  for (const context of targetContexts) {
+    try {
+      const result = await writeTargetFiles(cwd, {
+        targetPlan: context.targetPlan,
+        protectedFiles: context.targetPlan.userProtectedFiles,
+        srcAgents,
+        shouldWriteRootAgents: context.agentsDecision.shouldWriteRootAgents,
+        agentsUpdatePlan: context.agentsUpdatePlan,
+        resolveCanonicalSource
+      });
+
+      updated.push(...result.written);
+      skipped.push(...result.skipped);
+      successfulTargets.push(summarizeTargetState(context.targetPlan, version));
+    } catch (error) {
+      failedTargets.push({
+        targetId: context.target.id,
+        targetLabel: context.target.label,
+        reason: error.message
+      });
+    }
   }
 
-  // 打印摘要
   blank();
   info('Updated files:');
   blank();
   for (const rel of updated) {
     fileLine(rel.replace(/\\/g, '/'));
   }
+
   if (skipped.length > 0) {
     blank();
     info('Skipped (project-specific, preserved):');
@@ -89,16 +190,50 @@ async function update() {
     }
   }
 
-  blank();
-  success(`Done! ${updated.length} file(s) updated${skipped.length > 0 ? `, ${skipped.length} skipped` : ''}.`);
-  info('Managed files have been updated to the latest version.');
-  info('Your custom files in .agent/ were not touched.');
+  printTargetUpdateSummary(successfulTargets, failedTargets);
+
+  const changelogPath = await generateChangelog({
+    cwd,
+    version,
+    changes,
+    targetSummary: {
+      successfulTargets: successfulTargets.map((item) => `${item.targetLabel} (${item.targetId})`),
+      failedTargets: failedTargets.map((item) => `${item.targetLabel} (${item.targetId})`)
+    }
+  });
+  const generatedAt = new Date().toISOString();
+  await writeInstallLock(cwd, createInstallLock({
+    cliVersion: version,
+    generatedAt,
+    targets: dedupeTargets([
+      ...(installState.lockResult.lock?.targets || []),
+      ...successfulTargets
+    ]),
+    lastUpdateSummary: {
+      successfulTargets: successfulTargets.map((item) => item.targetId),
+      failedTargets: failedTargets.map((item) => item.targetId),
+      updatedAt: generatedAt
+    }
+  }));
+
+  let legacyCleanupLine = '';
+  if (isLegacyMigration) {
+    legacyCleanupLine = 'Legacy .agent/ was preserved. You can review and delete it manually after migration.';
+    const deleted = await maybeDeleteLegacyDir(legacyAgentDir);
+    if (deleted) {
+      legacyCleanupLine = 'Legacy .agent/ directory was deleted after confirmation.';
+    }
+  }
+
+  printUpdateCompletionSummary({
+    updatedCount: updated.length,
+    skippedCount: skipped.length,
+    changelogPath: path.relative(cwd, changelogPath).replace(/\\/g, '/'),
+    legacyCleanupLine
+  });
 }
 
-/**
- * 交互式确认更新操作（默认 N）。
- */
-async function askUpdate() {
+async function askUpdate({ installState, targets }) {
   if (global.__ANWS_FORCE_YES) return true;
 
   if (!process.stdin.isTTY) {
@@ -106,23 +241,15 @@ async function askUpdate() {
     return false;
   }
 
-  const readline = require('node:readline');
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-
-  return new Promise((resolve) => {
-    rl.question(
-      '\n\u26a0 This will overwrite all managed .agent/ files. Continue? [y/N] ',
-      (answer) => {
-        rl.close();
-        resolve(answer.trim().toLowerCase() === 'y');
-      }
-    );
+  return confirm({
+    message: buildUpdateConfirmationMessage(targets),
+    contextLines: buildUpdateConfirmationContextLines(installState, targets),
+    confirmLabel: 'Continue',
+    cancelLabel: 'Cancel',
+    defaultValue: false
   });
 }
 
-/**
- * 询问用户是否同意迁移 agents.md
- */
 async function askMigrate() {
   if (global.__ANWS_FORCE_YES) return true;
 
@@ -130,18 +257,99 @@ async function askMigrate() {
     return false;
   }
 
-  const readline = require('node:readline');
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return confirm({
+    message: 'Legacy .agent/ directory detected. Migrate to .agents/?',
+    confirmLabel: 'Migrate',
+    cancelLabel: 'Keep legacy',
+    defaultValue: false
+  });
+}
+
+async function maybeDeleteLegacyDir(legacyAgentDir) {
+  const exists = await pathExists(legacyAgentDir);
+  if (!exists) return false;
+
+  if (global.__ANWS_FORCE_YES) {
+    return false;
+  }
+
+  if (!process.stdin.isTTY) {
+    return false;
+  }
 
-  return new Promise((resolve) => {
-    rl.question(
-      '\n\u26a0 Legacy .agent/rules/agents.md detected. Do you want to migrate to root AGENTS.md? [y/N] ',
-      (answer) => {
-        rl.close();
-        resolve(answer.trim().toLowerCase() === 'y');
-      }
-    );
+  const shouldDelete = await confirm({
+    message: 'Legacy .agent/ directory has been preserved. Delete it now?',
+    confirmLabel: 'Delete',
+    cancelLabel: 'Keep',
+    defaultValue: false
   });
+
+  if (!shouldDelete) return false;
+
+  await fs.rm(legacyAgentDir, { recursive: true, force: true });
+  return true;
+}
+
+function buildUpdateConfirmationMessage(targets) {
+  const labels = targets.map((target) => target.label).filter(Boolean);
+  if (labels.length === 0) {
+    return 'This will overwrite all managed files for the detected target layout.';
+  }
+  return `This will overwrite all managed files for: ${labels.join(', ')}.`;
+}
+
+function buildUpdateConfirmationContextLines(installState, targets) {
+  const lines = [
+    `Matched targets: ${targets.map((target) => `${target.label} (${target.id})`).join(', ') || 'none'}`,
+    installState.needsFallback ? 'State source: directory scan fallback' : 'State source: install-lock + directory scan'
+  ];
+  if (installState.drift.hasDrift) {
+    lines.push(`State drift detected. Missing on disk: ${installState.drift.missingOnDisk.join(', ') || 'none'}; untracked on disk: ${installState.drift.untrackedOnDisk.join(', ') || 'none'}.`);
+  }
+  return lines;
+}
+
+function printLegacyMigrationNotice() {
+  section('Legacy migration', [
+    'Legacy .agent/ directory detected.',
+    'anws update will migrate managed files into the Antigravity target structure.',
+    'Your old .agent/ directory will be preserved for manual review.'
+  ], { minWidth: 60 });
+}
+
+function printTargetSelection(installState, targets) {
+  blank();
+  section('Target selection', [
+    `Matched targets: ${targets.map((target) => `${target.label} (${target.id})`).join(', ') || 'none'}`,
+    installState.needsFallback ? 'State source: directory scan fallback' : 'State source: install-lock + directory scan',
+    ...(installState.drift.hasDrift
+      ? [`State drift detected. Missing on disk: ${installState.drift.missingOnDisk.join(', ') || 'none'}; untracked on disk: ${installState.drift.untrackedOnDisk.join(', ') || 'none'}.`]
+      : [])
+  ]);
+}
+
+function printTargetUpdateSummary(successfulTargets, failedTargets) {
+  blank();
+  section('Update summary by target', [
+    ...successfulTargets.map((target) => `✔ ${target.targetLabel} (${target.targetId})`),
+    ...failedTargets.map((target) => `✖ ${target.targetLabel} (${target.targetId}) — ${target.reason}`)
+  ]);
+}
+
+function printUpdateCompletionSummary({ updatedCount, skippedCount, changelogPath, legacyCleanupLine }) {
+  blank();
+  section('Update completed', [
+    `✔ Done! ${updatedCount} file(s) updated${skippedCount > 0 ? `, ${skippedCount} skipped` : ''}.`,
+    'Managed files have been updated to the latest version.',
+    'Your custom files outside the selected target projections were not touched.',
+    ...(legacyCleanupLine ? [legacyCleanupLine] : []),
+    `Generated upgrade record: ${changelogPath}`,
+    'Run `/upgrade` in your AI IDE to update your architecture docs.'
+  ], { minWidth: 60 });
 }
 
 module.exports = update;
+
+
+
+

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@haaaiawd/anws",
-  "version": "1.2.5",
-  "description": "A spec-driven workflow framework for AI-assisted development. Empowers prompt engineers to build production-ready software through structured PRD → Architecture → Task decomposition. Designed for Antigravity to enforce design-first principles and prevent architectural drift in vibe coding.",
+  "version": "2.0.0",
+  "description": "Anws — A spec-driven workflow framework for AI-assisted development. Empowers prompt engineers to build production-ready software through structured PRD → Architecture → Task decomposition. Works with Claude Code, GitHub Copilot, Cursor, Windsurf, and any tool that reads AGENTS.md.",
   "keywords": [
-    "antigravity",
+    "anws",
     "agentic-ai",
     "workflow-orchestration",
     "spec-driven",
@@ -11,12 +11,16 @@
     "vibe-coding",
     "prompt-engineering",
     "devops-for-ai",
-    "skills-framework"
+    "skills-framework",
+    "claude-code",
+    "github-copilot",
+    "cursor",
+    "windsurf"
   ],
-  "homepage": "https://github.com/Haaaiawd/Antigravity-Workflow-System",
+  "homepage": "https://github.com/Haaaiawd/Anws",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/Haaaiawd/Antigravity-Workflow-System.git"
+    "url": "git+https://github.com/Haaaiawd/Anws.git"
   },
   "author": "haaaiawd <1134180104@qq.com>",
   "license": "MIT",

package/templates/.agents/skills/concept-modeler/SKILL.md

@@ -0,0 +1,176 @@
+---
+name: concept-modeler
+description: 当用户需求模糊、术语不清晰时使用。通过交互式追问澄清领域概念，提取实体、流程和暗物质。由 /genesis Step 1 调用。
+---
+
+# 领域建模师 (Domain Modeler)
+
+> "如果你描述不清楚，你就造不出来。" —— Eric Evans
+
+本技能通过**交互式追问**将用户的"感觉词"转化为清晰的领域模型。
+
+---
+
+## 🎯 使命与定位
+
+**这个技能是什么**: 通过与用户交互，澄清模糊需求，建立领域模型（实体、流程、暗物质）。
+
+**何时调用**:
+- `/genesis` Step 1: 需求澄清阶段
+- 用户需求使用模糊术语（"同步"、"列表"、"管理"）
+- 需要建立 Ubiquitous Language
+
+**何时不调用**:
+- 需求已经清晰、术语已定义
+- 纯技术实现讨论（无需领域建模）
+
+---
+
+## ⚠️ 核心原则
+
+> [!IMPORTANT]
+> **一次只问一个问题，不一次性输出所有问题。**
+>
+> **为什么？** 用户一次只能思考一个问题。逐个追问能获得更准确的答案，也避免用户被问题淹没。
+
+---
+
+## 🧭 交互流程 (Interactive Process)
+
+### Step 1: 扫描模糊区域
+
+**目标**: 识别需求中的模糊术语和缺失信息。
+
+> [!IMPORTANT]
+> 你**必须**先扫描用户需求，识别以下类别的模糊点：
+>
+> | 类别 | 检查问题 |
+> | :--- | :--- |
+> | **实体模糊** | "列表"是什么？`Wishlist`？`ShoppingCart`？`TodoList`？ |
+> | **动词模糊** | "同步"是单向/双向？实时/批量？失败策略？ |
+> | **暗物质** | 用户只描述 Happy Path——错误处理？持久化？认证？ |
+> | **边界模糊** | 谁能访问？数据量多大？并发要求？ |
+
+**内部产出**: 生成候选问题队列（最多 5 个），按影响排序。**不输出队列**。
+
+---
+
+### Step 2: 交互式追问循环
+
+**目标**: 逐个澄清模糊点，每次只问一个问题。
+
+> [!IMPORTANT]
+> **追问规则**：
+> - 最多问 **5 个问题**
+> - 每个问题必须是**多选题**或**短回答（≤5 词）**
+> - 每次只输出**一个问题**
+
+#### 2.1 多选题格式
+
+对于有多种明确选项的问题：
+
+```markdown
+**推荐:** 选项 B - 实时双向同步能保证数据一致性，适合用户多设备场景。
+
+| 选项 | 描述 |
+| :--- | :--- |
+| A | 单向同步（仅上传） |
+| B | 实时双向同步 |
+| C | 批量定时同步 |
+| 自定义 | 提供简短描述（≤5 词） |
+
+回复选项字母（如 "B"），说 "yes" 或 "推荐" 接受推荐，或提供自定义答案。
+```
+
+#### 2.2 短回答格式
+
+对于需要用户自定义的问题：
+
+```markdown
+**建议:** 用户愿望清单 - 这是电商场景最常见的术语。
+
+格式: 简短回答（≤5 词）。说 "yes" 或 "建议" 接受建议，或提供你的答案。
+```
+
+#### 2.3 停止条件
+
+停止追问当：
+- 所有关键模糊点已澄清
+- 用户说 "done"、"好了"、"继续"
+- 已问满 5 个问题
+
+---
+
+### Step 3: 增量更新模型
+
+**目标**: 每次获得答案后，立即更新领域模型。
+
+> [!IMPORTANT]
+> **每个答案接受后立即更新**，不要等所有问题结束。
+
+**更新规则**：
+1. 实体澄清 → 更新 `entities` 列表
+2. 动词澄清 → 更新 `flows` 列表
+3. 暗物质识别 → 更新 `missing_components` 列表
+4. 术语统一 → 记录到 `glossary`
+
+---
+
+## 📤 输出格式
+
+**输出路径**: `.anws/v{N}/concept_model.json`
+
+```json
+{
+  "glossary": {
+    "Wishlist": "用户的愿望清单，可添加商品但不直接结算",
+    "Sync": "实时双向同步，保证多设备数据一致"
+  },
+  "entities": [
+    { "name": "Wishlist", "type": "聚合根", "necessity": "必须", "description": "用户的愿望清单" },
+    { "name": "WishlistItem", "type": "实体", "necessity": "必须", "description": "愿望清单中的商品项" }
+  ],
+  "flows": [
+    { "from": "User", "action": "添加", "to": "Wishlist", "data": "Product ID", "trigger": "用户点击" },
+    { "from": "Wishlist", "action": "同步", "to": "RemoteServer", "data": "全量数据", "mode": "实时双向" }
+  ],
+  "missing_components": [
+    { "component": "同步冲突解决", "category": "错误处理", "priority": "高", "reason": "多设备同时修改" },
+    { "component": "离线队列", "category": "可靠性", "priority": "中", "reason": "网络断开时暂存操作" }
+  ],
+  "clarifications": [
+    { "question": "同步是实时的还是批量的？", "answer": "实时双向同步" }
+  ]
+}
+```
+
+---
+
+## 🛡️ 老师傅守则
+
+1. **不要假设**: 永远不要假设你理解了用户的词汇。追问确认。
+2. **一次一个**: 用户一次只能思考一个问题。不要输出问题列表。
+3. **推荐优先**: 给出推荐选项 + 理由，让用户更容易决策。
+4. **增量更新**: 每个答案立即写入文件，避免上下文丢失。
+5. **术语统一**: 一旦确定术语，全程使用该术语，避免同义词。
+6. **工具优先提问**: 如果当前环境提供 `ask question` 等结构化提问工具，优先使用工具发起问题，而不是让用户手动输入整段回复。
+
+---
+
+## 📋 完成标准
+
+<completion_criteria>
+- ✅ 澄清了关键模糊术语（记录到 glossary）
+- ✅ 识别了核心实体和关系
+- ✅ 发现了用户没说的暗物质组件
+- ✅ 领域模型保存到 `.anws/v{N}/concept_model.json`
+- ✅ 用户确认术语理解正确
+</completion_criteria>
+
+---
+
+## Collaboration
+
+*   **Before**: 用户提供的模糊需求描述
+*   **After**: `spec-writer` 基于澄清后的需求生成 PRD
+*   **Synergy**: 你的领域模型为后续架构设计提供清晰的术语基础