@haaaiawd/anws 1.2.4 → 2.0.0

package/lib/adapters/index.js

@@ -0,0 +1,157 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+const TARGETS = {
+  windsurf: {
+    id: 'windsurf',
+    label: 'Windsurf',
+    rootAgentFile: false,
+    projectionTypes: {
+      workflow: ['workflows'],
+      skill: ['skills']
+    },
+    projections: {
+      workflows: '.windsurf/workflows',
+      skills: '.windsurf/skills'
+    },
+    detect: ['.windsurf/workflows/genesis.md']
+  },
+  antigravity: {
+    id: 'antigravity',
+    label: 'Antigravity',
+    rootAgentFile: true,
+    projectionTypes: {
+      workflow: ['workflows'],
+      skill: ['skills']
+    },
+    projections: {
+      workflows: '.agents/workflows',
+      skills: '.agents/skills'
+    },
+    detect: ['.agents/workflows/genesis.md', '.agent/workflows/genesis.md']
+  },
+  cursor: {
+    id: 'cursor',
+    label: 'Cursor',
+    rootAgentFile: false,
+    projectionTypes: {
+      workflow: ['commands'],
+      skill: ['skills']
+    },
+    projections: {
+      commands: '.cursor/commands',
+      skills: '.cursor/skills'
+    },
+    detect: ['.cursor/commands/genesis.md']
+  },
+  claude: {
+    id: 'claude',
+    label: 'Claude',
+    rootAgentFile: false,
+    projectionTypes: {
+      workflow: ['commands'],
+      skill: ['skills']
+    },
+    projections: {
+      commands: '.claude/commands',
+      skills: '.claude/skills'
+    },
+    detect: ['.claude/commands/genesis.md']
+  },
+  copilot: {
+    id: 'copilot',
+    label: 'GitHub Copilot',
+    rootAgentFile: false,
+    projectionTypes: {
+      workflow: ['prompts'],
+      skill: ['skills']
+    },
+    projections: {
+      prompts: '.github/prompts',
+      skills: '.github/skills'
+    },
+    detect: ['.github/prompts/genesis.prompt.md']
+  },
+  codex: {
+    id: 'codex',
+    label: 'Codex (Preview)',
+    rootAgentFile: false,
+    projectionTypes: {
+      workflow: ['skills'],
+      skill: ['skills']
+    },
+    projections: {
+      skills: '.codex/skills'
+    },
+    detect: ['.codex/skills/anws-system/SKILL.md']
+  },
+  opencode: {
+    id: 'opencode',
+    label: 'OpenCode',
+    rootAgentFile: false,
+    projectionTypes: {
+      workflow: ['commands'],
+      skill: ['skills']
+    },
+    projections: {
+      commands: '.opencode/commands',
+      skills: '.opencode/skills'
+    },
+    detect: ['.opencode/commands/genesis.md']
+  }
+};
+
+function listTargets() {
+  return Object.values(TARGETS);
+}
+
+function getTarget(targetId) {
+  if (!targetId) {
+    throw new Error('targetId is required');
+  }
+
+  const target = TARGETS[targetId];
+  if (!target) {
+    throw new Error(`Unsupported target: ${targetId}. Supported targets: ${listTargets().map((item) => item.id).join(', ')}`);
+  }
+
+  return target;
+}
+
+async function pathExists(targetPath) {
+  return fs.access(targetPath).then(() => true).catch(() => false);
+}
+
+async function detectInstalledTarget(cwd) {
+  const targets = await detectInstalledTargets(cwd);
+  return targets[0] || null;
+}
+
+async function detectInstalledTargets(cwd) {
+  const installedTargets = [];
+
+  for (const target of listTargets()) {
+    for (const relPath of target.detect) {
+      if (await pathExists(path.join(cwd, relPath))) {
+        installedTargets.push(target);
+        break;
+      }
+    }
+  }
+
+  return installedTargets;
+}
+
+module.exports = {
+  TARGETS,
+  detectInstalledTarget,
+  detectInstalledTargets,
+  getTarget,
+  listTargets
+};
+
+
+
+

package/lib/agents.js

@@ -0,0 +1,185 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { warn, blank } = require('./output');
+const AUTO_BEGIN_RE = /<!-- AUTO:BEGIN[\s\S]*?-->/;
+const AUTO_END_RE = /<!-- AUTO:END -->/;
+const LEGACY_HEADINGS = [
+  '## 📍 当前状态',
+  '## 🌳 项目结构',
+  '## 🧭 导航指南'
+];
+
+async function pathExists(targetPath) {
+  return fs.access(targetPath).then(() => true).catch(() => false);
+}
+
+async function getAgentsState(cwd) {
+  const legacyPath = path.join(cwd, '.agent', 'rules', 'agents.md');
+  const rootPath = path.join(cwd, 'AGENTS.md');
+
+  return {
+    legacyPath,
+    rootPath,
+    legacyExists: await pathExists(legacyPath),
+    rootExists: await pathExists(rootPath)
+  };
+}
+
+async function resolveAgentsInstall({ cwd, askMigrate, forceYes = false }) {
+  const state = await getAgentsState(cwd);
+
+  if (!state.legacyExists) {
+    return { ...state, shouldWriteRootAgents: true, shouldWarnMigration: false };
+  }
+
+  const migrate = forceYes ? true : await askMigrate();
+  return {
+    ...state,
+    shouldWriteRootAgents: migrate,
+    shouldWarnMigration: migrate
+  };
+}
+
+function getAutoBlockRange(content) {
+  const beginMatch = content.match(AUTO_BEGIN_RE);
+  const endMatch = content.match(AUTO_END_RE);
+
+  if (!beginMatch || !endMatch) return null;
+
+  const beginIndex = beginMatch.index;
+  const endIndex = endMatch.index;
+  const beginEnd = beginIndex + beginMatch[0].length;
+  const endEnd = endIndex + endMatch[0].length;
+
+  if (beginIndex > endIndex) return null;
+
+  return {
+    beginIndex,
+    beginEnd,
+    endIndex,
+    endEnd
+  };
+}
+
+function hasAutoBlock(content) {
+  return getAutoBlockRange(content) !== null;
+}
+
+function isRecognizedLegacyAgents(content) {
+  // 检查主标题
+  if (!content.includes('# AGENTS.md - AI 协作协议')) return false;
+  
+  // 检查三个核心 section 标题（允许标题后包含额外文字）
+  return LEGACY_HEADINGS.every((heading) => content.includes(heading));
+}
+
+function extractSection(content, heading) {
+  const headingIndex = content.indexOf(heading);
+  if (headingIndex === -1) return null;
+
+  const afterHeading = content.slice(headingIndex + heading.length);
+  const sectionBreaks = [];
+  const nextRule = afterHeading.indexOf('\n---');
+  const nextHeading = afterHeading.indexOf('\n## ');
+  if (nextRule !== -1) sectionBreaks.push(nextRule);
+  if (nextHeading !== -1) sectionBreaks.push(nextHeading);
+
+  const relativeEnd = sectionBreaks.length > 0
+    ? Math.min(...sectionBreaks)
+    : afterHeading.length;
+
+  return content.slice(headingIndex, headingIndex + heading.length + relativeEnd).trimEnd();
+}
+
+function replaceSection(content, heading, replacement) {
+  const current = extractSection(content, heading);
+  if (!current) return content;
+  return content.replace(current, replacement);
+}
+
+function migrateLegacyAgentsContent({ templateContent, existingContent }) {
+  const templateRange = getAutoBlockRange(templateContent);
+  if (!templateRange) {
+    return {
+      mode: 'replace',
+      content: templateContent
+    };
+  }
+
+  let autoBody = templateContent.slice(templateRange.beginEnd, templateRange.endIndex);
+  for (const heading of LEGACY_HEADINGS) {
+    const legacySection = extractSection(existingContent, heading);
+    if (legacySection) {
+      autoBody = replaceSection(autoBody, heading, legacySection);
+    }
+  }
+
+  return {
+    mode: 'migrate',
+    content: `${templateContent.slice(0, templateRange.beginEnd)}${autoBody}${templateContent.slice(templateRange.endIndex)}`
+  };
+}
+
+function mergeAgentsContent({ templateContent, existingContent }) {
+  const templateRange = getAutoBlockRange(templateContent);
+  const existingRange = getAutoBlockRange(existingContent);
+
+  if (!templateRange || !existingRange) {
+    return {
+      mode: 'replace',
+      content: templateContent
+    };
+  }
+
+  const templatePrefix = templateContent.slice(0, templateRange.beginEnd);
+  const templateSuffix = templateContent.slice(templateRange.endIndex);
+  const existingMiddle = existingContent.slice(existingRange.beginEnd, existingRange.endIndex);
+
+  return {
+    mode: 'merge',
+    content: `${templatePrefix}${existingMiddle}${templateSuffix}`
+  };
+}
+
+function planAgentsUpdate({ templateContent, existingContent }) {
+  if (!existingContent) {
+    return {
+      mode: 'replace',
+      content: templateContent
+    };
+  }
+
+  if (hasAutoBlock(existingContent)) {
+    return mergeAgentsContent({ templateContent, existingContent });
+  }
+
+  if (isRecognizedLegacyAgents(existingContent)) {
+    return migrateLegacyAgentsContent({ templateContent, existingContent });
+  }
+
+  return {
+    mode: 'skip',
+    content: existingContent,
+    warning: 'Root AGENTS.md does not contain AUTO markers and does not match a recognized legacy template. anws update will preserve it unchanged. Please migrate it manually or re-run after adding markers.'
+  };
+}
+
+function printLegacyMigrationWarning() {
+  blank();
+  warn('Please manually copy your custom rules from .agent/rules/agents.md to the root AGENTS.md');
+  warn('After copying, you can safely delete the old .agent/rules/agents.md file.');
+  blank();
+}
+
+module.exports = {
+  getAgentsState,
+  hasAutoBlock,
+  isRecognizedLegacyAgents,
+  mergeAgentsContent,
+  planAgentsUpdate,
+  resolveAgentsInstall,
+  printLegacyMigrationWarning,
+  pathExists
+};

package/lib/changelog.js

@@ -0,0 +1,187 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { groupChanges } = require('./diff');
+
+const README_CONTENT = `# ⚠️ 重要：请勿删除此目录！
+
+## 这个目录是做什么的？
+
+\`.anws/changelog/\` 存放每次 \`anws update\` 生成的升级记录。
+
+## 为什么不能删除？
+
+1. **AI 升级判断依赖此目录**
+   - AI 需要读取历史升级记录来判断变更级别
+   - 删除后将导致 AI 无法准确判断升级影响
+
+2. **业务文档升级的依据**
+   - 升级记录包含详细的变更详情
+   - AI 根据这些记录升级你的业务文档
+
+3. **回滚依据**
+   - 如果升级出现问题，可以参考历史记录回滚
+
+## 文件命名规则
+
+- \`v1.4.0.md\` - v1.4.0 的变更记录
+- \`v1.5.0.md\` - v1.5.0 的变更记录
+
+## 可以删除单个文件吗？
+
+**不建议**。每个文件都是升级历史的一部分，删除会影响 AI 的判断能力。
+`;
+
+async function ensureChangelogDir(cwd) {
+  const changelogDir = path.join(cwd, '.anws', 'changelog');
+  await fs.mkdir(changelogDir, { recursive: true });
+  await fs.writeFile(path.join(changelogDir, '.gitkeep'), '', 'utf8');
+  await fs.writeFile(path.join(changelogDir, 'README.md'), README_CONTENT, 'utf8');
+  return changelogDir;
+}
+
+function compareSemver(a, b) {
+  const aParts = String(a).split('.').map((item) => Number(item));
+  const bParts = String(b).split('.').map((item) => Number(item));
+
+  for (let index = 0; index < 3; index += 1) {
+    const left = aParts[index] || 0;
+    const right = bParts[index] || 0;
+    if (left > right) return 1;
+    if (left < right) return -1;
+  }
+
+  return 0;
+}
+
+function formatFileList(title, items) {
+  const lines = [`### ${title}`];
+  if (items.length === 0) {
+    lines.push('- 无');
+    return lines.join('\n');
+  }
+
+  for (const item of items) {
+    lines.push(`- \`${item.file}\``);
+  }
+
+  return lines.join('\n');
+}
+
+function formatDetail(item) {
+  if (item.type === 'added') {
+    return [
+      `### \`${item.file}\``,
+      '- **新增文件**',
+      '- **说明**: 该文件在旧版本中不存在，因此无前后逐行对比。'
+    ].join('\n');
+  }
+
+  if (item.type === 'deleted') {
+    return [
+      `### \`${item.file}\``,
+      '- **删除文件**',
+      '- **说明**: 该文件在新版本中不存在，因此无前后逐行对比。'
+    ].join('\n');
+  }
+
+  if (item.summary.length === 0) {
+    return [
+      `### \`${item.file}\``,
+      '- **说明**: 检测到内容变更，但未能提取到摘要。'
+    ].join('\n');
+  }
+
+  return [
+    `### \`${item.file}\``,
+    '```diff',
+    ...item.summary.flatMap((pair) => [
+      `- [old:${pair.oldLineNumber === null ? '-' : pair.oldLineNumber}] ${pair.oldText}`,
+      `+ [new:${pair.newLineNumber === null ? '-' : pair.newLineNumber}] ${pair.newText}`
+    ]),
+    '```'
+  ].join('\n');
+}
+
+async function generateChangelog({ cwd, version, changes, targetSummary = null }) {
+  const changelogDir = await ensureChangelogDir(cwd);
+  const grouped = groupChanges(changes);
+  const now = new Date();
+  const timestamp = now.toISOString().replace('T', ' ').slice(0, 19);
+  const filePath = path.join(changelogDir, `v${version}.md`);
+
+  const content = [
+    `# 升级记录: v${version}`,
+    '',
+    '> ⚠️ **此文件由 `anws update` 自动生成，请勿删除！**',
+    '> 删除后将导致 AI 无法获取历史升级信息，影响后续升级判断。',
+    '',
+    '## 元信息',
+    `- **升级版本**: ${version}`,
+    `- 升级时间: ${timestamp}`,
+    '- **升级类型**: 由 `/upgrade` 工作流判断 (Minor/Major)',
+    ...(targetSummary
+      ? [
+          `- **成功 Targets**: ${targetSummary.successfulTargets.length > 0 ? targetSummary.successfulTargets.join(', ') : '无'}`,
+          `- **失败 Targets**: ${targetSummary.failedTargets.length > 0 ? targetSummary.failedTargets.join(', ') : '无'}`
+        ]
+      : []),
+    '',
+    '## 变更摘要',
+    `- 新增文件: ${grouped.added.length}`,
+    `- 修改文件: ${grouped.modified.length}`,
+    `- 删除文件: ${grouped.deleted.length}`,
+    '',
+    '## 文件级变更清单',
+    '',
+    formatFileList('新增文件', grouped.added),
+    '',
+    formatFileList('修改文件', grouped.modified),
+    '',
+    formatFileList('删除文件', grouped.deleted),
+    '',
+    '## 内容级变更详情',
+    '',
+    ...(changes.length > 0 ? changes.map(formatDetail).flatMap((section) => [section, '']) : ['- 无变更', ''])
+  ].join('\n');
+
+  await fs.writeFile(filePath, content, 'utf8');
+  return filePath;
+}
+
+async function detectUpgrade({ cwd, version }) {
+  const changelogDir = path.join(cwd, '.anws', 'changelog');
+
+  try {
+    const files = await fs.readdir(changelogDir);
+    const latest = files
+      .filter((name) => /^v\d+\.\d+\.\d+\.md$/.test(name))
+      .sort((left, right) => {
+        const leftVersion = left.slice(1, -3);
+        const rightVersion = right.slice(1, -3);
+        return compareSemver(leftVersion, rightVersion);
+      })
+      .pop();
+
+    if (!latest) {
+      return { needUpgrade: true, fromVersion: null, toVersion: version, latestVersion: null };
+    }
+
+    const fromVersion = latest.slice(1, -3);
+    return {
+      needUpgrade: compareSemver(fromVersion, version) !== 0,
+      fromVersion,
+      toVersion: version,
+      latestVersion: fromVersion
+    };
+  } catch {
+    return { needUpgrade: true, fromVersion: null, toVersion: version, latestVersion: null };
+  }
+}
+
+module.exports = {
+  detectUpgrade,
+  ensureChangelogDir,
+  generateChangelog
+};

package/lib/copy.js

@@ -35,4 +35,75 @@ async function copyDir(srcDir, destDir) {
   return written;
 }
 
-module.exports = { copyDir };
+async function pathExists(targetPath) {
+  return fs.access(targetPath).then(() => true).catch(() => false);
+}
+
+async function writeTargetFiles(cwd, options = {}) {
+  const targetPlan = options.targetPlan || {};
+  const protectedFiles = options.protectedFiles || targetPlan.userProtectedFiles || [];
+  const projectionEntries = targetPlan.projectionEntries || [];
+  const shouldWriteRootAgents = options.shouldWriteRootAgents !== false;
+  const srcAgents = options.srcAgents;
+  const agentsUpdatePlan = options.agentsUpdatePlan;
+  const resolveCanonicalSource = options.resolveCanonicalSource;
+  const projectionMap = new Map(projectionEntries.map((item) => [item.outputPath, item]));
+  const written = [];
+  const skipped = [];
+
+  for (const rel of targetPlan.managedFiles || []) {
+    if (rel === 'AGENTS.md' && !shouldWriteRootAgents) {
+      skipped.push(rel);
+      continue;
+    }
+
+    if (rel === 'AGENTS.md') {
+      const destPath = path.join(cwd, rel);
+      await fs.mkdir(path.dirname(destPath), { recursive: true });
+
+      if (agentsUpdatePlan && agentsUpdatePlan.mode === 'skip') {
+        skipped.push(rel);
+        continue;
+      }
+
+      if (agentsUpdatePlan && agentsUpdatePlan.content) {
+        await fs.writeFile(destPath, agentsUpdatePlan.content, 'utf8');
+        written.push(rel);
+        continue;
+      }
+
+      if (await pathExists(srcAgents)) {
+        await fs.copyFile(srcAgents, destPath);
+        written.push(rel);
+        continue;
+      }
+    }
+
+    if (protectedFiles.includes(rel)) {
+      const destPath = path.join(cwd, rel);
+      if (await pathExists(destPath)) {
+        skipped.push(rel);
+        continue;
+      }
+    }
+
+    const entry = projectionMap.get(rel);
+    const destPath = path.join(cwd, rel);
+    await fs.mkdir(path.dirname(destPath), { recursive: true });
+
+    const srcPath = resolveCanonicalSource(entry.source);
+    if (await pathExists(srcPath)) {
+      await fs.copyFile(srcPath, destPath);
+      written.push(rel);
+    }
+  }
+
+  return {
+    targetId: targetPlan.targetId,
+    targetLabel: targetPlan.targetLabel,
+    written,
+    skipped
+  };
+}
+
+module.exports = { copyDir, writeTargetFiles };