@haaaiawd/anws 1.2.5 → 2.0.1

package/lib/diff.js

@@ -0,0 +1,270 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { c } = require('./output');
+
+async function pathExists(targetPath) {
+  return fs.access(targetPath).then(() => true).catch(() => false);
+}
+
+async function readTextOrEmpty(filePath) {
+  const exists = await pathExists(filePath);
+  if (!exists) return '';
+  return fs.readFile(filePath, 'utf8');
+}
+
+function normalize(text) {
+  return text.replace(/\r\n/g, '\n');
+}
+
+function toLines(text) {
+  const lines = normalize(text).split('\n');
+  while (lines.length > 0 && lines[lines.length - 1] === '') {
+    lines.pop();
+  }
+  return lines;
+}
+
+function createLineDiff(oldContent, newContent, maxPairs = 8) {
+  const before = toLines(oldContent);
+  const after = toLines(newContent);
+  const pairs = [];
+  let beforeIndex = 0;
+  let afterIndex = 0;
+
+  while (beforeIndex < before.length || afterIndex < after.length) {
+    const oldLine = before[beforeIndex];
+    const newLine = after[afterIndex];
+
+    if (oldLine === newLine) {
+      beforeIndex += 1;
+      afterIndex += 1;
+      continue;
+    }
+
+    const nextOldLine = before[beforeIndex + 1];
+    const nextNewLine = after[afterIndex + 1];
+
+    if (nextOldLine === newLine) {
+      pairs.push({
+        oldLineNumber: oldLine === undefined ? null : beforeIndex + 1,
+        newLineNumber: null,
+        oldText: oldLine === undefined ? '' : oldLine,
+        newText: '',
+        kind: 'removed'
+      });
+      beforeIndex += 1;
+      if (pairs.length >= maxPairs) break;
+      continue;
+    }
+
+    if (oldLine === nextNewLine) {
+      pairs.push({
+        oldLineNumber: null,
+        newLineNumber: newLine === undefined ? null : afterIndex + 1,
+        oldText: '',
+        newText: newLine === undefined ? '' : newLine,
+        kind: 'added'
+      });
+      afterIndex += 1;
+      if (pairs.length >= maxPairs) break;
+      continue;
+    }
+
+    pairs.push({
+      oldLineNumber: oldLine === undefined ? null : beforeIndex + 1,
+      newLineNumber: newLine === undefined ? null : afterIndex + 1,
+      oldText: oldLine === undefined ? '' : oldLine,
+      newText: newLine === undefined ? '' : newLine,
+      kind:
+        oldLine === undefined
+          ? 'added'
+          : newLine === undefined
+            ? 'removed'
+            : 'modified'
+    });
+
+    beforeIndex += 1;
+    afterIndex += 1;
+
+    if (pairs.length >= maxPairs) break;
+  }
+
+  return pairs;
+}
+
+function formatLineNumber(value) {
+  return value === null ? '-' : String(value);
+}
+
+function toLegacyManagedPath(rel) {
+  if (!rel.startsWith('.agents/')) return rel;
+  return `.agent/${rel.slice('.agents/'.length)}`;
+}
+
+async function resolveExistingManagedPath(cwd, rel) {
+  const primaryPath = path.join(cwd, rel);
+  if (await pathExists(primaryPath)) {
+    return { file: rel, absolutePath: primaryPath, sourceKind: 'current' };
+  }
+
+  const legacyRel = toLegacyManagedPath(rel);
+  if (legacyRel !== rel) {
+    const legacyPath = path.join(cwd, legacyRel);
+    if (await pathExists(legacyPath)) {
+      return { file: rel, absolutePath: legacyPath, sourceKind: 'legacy' };
+    }
+  }
+
+  return { file: rel, absolutePath: primaryPath, sourceKind: 'missing' };
+}
+
+async function collectManagedFileDiffs({
+  cwd,
+  managedFiles,
+  projectionPlan = [],
+  projectionEntries = [],
+  srcAgents,
+  shouldWriteRootAgents,
+  agentsUpdatePlan = null
+}) {
+  const results = [];
+  const normalizedProjectionEntries = projectionEntries.length > 0
+    ? projectionEntries
+    : projectionPlan.flatMap((item) => item.projectionEntries || []);
+  const normalizedManagedFiles = managedFiles && managedFiles.length > 0
+    ? managedFiles
+    : projectionPlan.flatMap((item) => item.managedFiles || []);
+  const projectionMap = new Map(normalizedProjectionEntries.map((item) => [item.outputPath, item]));
+
+  for (const rel of normalizedManagedFiles) {
+    if (rel === 'AGENTS.md' && !shouldWriteRootAgents) {
+      continue;
+    }
+
+    const entry = projectionMap.get(rel);
+    const srcPath = rel === 'AGENTS.md'
+      ? srcAgents
+      : path.join(path.join(__dirname, '..', 'templates'), entry.source);
+    const existing = rel === 'AGENTS.md'
+      ? { file: rel, absolutePath: path.join(cwd, rel), sourceKind: 'current' }
+      : await resolveExistingManagedPath(cwd, rel);
+    const destPath = existing.absolutePath;
+
+    const srcExists = await pathExists(srcPath);
+    const destExists = await pathExists(destPath);
+
+    if (!srcExists && !destExists) continue;
+
+    if (srcExists && !destExists) {
+      results.push({
+        file: rel,
+        type: 'added',
+        summary: [],
+        oldContent: '',
+        newContent: await readTextOrEmpty(srcPath)
+      });
+      continue;
+    }
+
+    if (!srcExists && destExists) {
+      results.push({
+        file: rel,
+        type: 'deleted',
+        summary: [],
+        oldContent: await readTextOrEmpty(destPath),
+        newContent: ''
+      });
+      continue;
+    }
+
+    const oldContent = await readTextOrEmpty(destPath);
+    let newContent = await readTextOrEmpty(srcPath);
+
+    if (rel === 'AGENTS.md' && shouldWriteRootAgents && destExists) {
+      if (agentsUpdatePlan && agentsUpdatePlan.mode === 'skip') {
+        continue;
+      }
+      newContent = agentsUpdatePlan ? agentsUpdatePlan.content : newContent;
+    }
+
+    if (normalize(oldContent) === normalize(newContent)) continue;
+
+    results.push({
+      file: rel,
+      type: 'modified',
+      summary: createLineDiff(oldContent, newContent),
+      oldContent,
+      newContent
+    });
+  }
+
+  return results;
+}
+
+function groupChanges(changes) {
+  return {
+    added: changes.filter((item) => item.type === 'added'),
+    modified: changes.filter((item) => item.type === 'modified'),
+    deleted: changes.filter((item) => item.type === 'deleted')
+  };
+}
+
+function printColorBlock(title, color, items, prefix) {
+  if (items.length === 0) return;
+  console.log(`  ${color}${title} (${items.length})${c.reset}`);
+  for (const item of items) {
+    console.log(`    ${prefix} ${item.file}`);
+  }
+  console.log('');
+}
+
+function printPreview({ fromVersion, toVersion, changes }) {
+  const grouped = groupChanges(changes);
+  const fromLabel = fromVersion ? `v${fromVersion}` : 'fresh-install';
+  const toLabel = `v${toVersion}`;
+
+  console.log('╔══════════════════════════════════════════════════════════════╗');
+  console.log(`║  ANWS UPDATE PREVIEW - ${fromLabel} → ${toLabel}`.padEnd(63, ' ') + '║');
+  console.log('╚══════════════════════════════════════════════════════════════╝');
+  console.log('');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log('📁 文件级变更');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log('');
+
+  printColorBlock('新增', c.green, grouped.added, '+');
+  printColorBlock('修改', c.yellow, grouped.modified, '~');
+  printColorBlock('删除', c.red, grouped.deleted, '-');
+
+  if (grouped.added.length === 0 && grouped.modified.length === 0 && grouped.deleted.length === 0) {
+    console.log('  Already up to date.');
+    console.log('');
+    return;
+  }
+
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log('📄 内容级变更详情');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log('');
+
+  for (const item of grouped.modified) {
+    console.log(`${c.yellow}${item.file}${c.reset}`);
+    console.log('──────────────────────────────────────────────────────────────');
+    for (const pair of item.summary) {
+      console.log(`  old ${formatLineNumber(pair.oldLineNumber).padStart(4, ' ')} | ${c.red}-${c.reset} ${pair.oldText}`);
+      console.log(`  new ${formatLineNumber(pair.newLineNumber).padStart(4, ' ')} | ${c.green}+${c.reset} ${pair.newText}`);
+      console.log('  ----');
+    }
+    console.log('');
+  }
+
+  console.log('执行 `anws update` 以应用以上变更。');
+}
+
+module.exports = {
+  collectManagedFileDiffs,
+  groupChanges,
+  printPreview
+};

package/lib/init.js

@@ -1,79 +1,123 @@
 'use strict';
 
-const fs = require('node:fs/promises');
 const path = require('node:path');
-const { copyDir } = require('./copy');
-const { MANAGED_FILES, USER_PROTECTED_FILES } = require('./manifest');
+const { buildProjectionPlan } = require('./manifest');
+const { getTarget, listTargets } = require('./adapters');
 const { resolveAgentsInstall, printLegacyMigrationWarning, pathExists } = require('./agents');
-const { success, warn, info, fileLine, skippedLine, blank, logo } = require('./output');
+const { ensureChangelogDir } = require('./changelog');
+const { ROOT_AGENTS_FILE, resolveCanonicalSource } = require('./resources');
+const { writeTargetFiles } = require('./copy');
+const { createInstallLock, dedupeTargets, detectInstallState, summarizeTargetState, writeInstallLock } = require('./install-state');
+const { selectMultiple, confirm } = require('./prompt');
+const { success, warn, info, fileLine, skippedLine, blank, logo, section } = require('./output');
 
-/**
- * anws init — 将工作流系统写入当前项目
- */
 async function init() {
   const cwd = process.cwd();
-  const srcRoot = path.join(__dirname, '..', 'templates', '.agent');
-  const destRoot = path.join(cwd, '.agent');
-  const srcAgents = path.join(__dirname, '..', 'templates', 'AGENTS.md');
-
-  const agentsDecision = await resolveAgentsInstall({
-    cwd,
-    askMigrate,
-    forceYes: !!global.__ANWS_FORCE_YES
-  });
+  logo();
+  const targets = await selectTargets();
+  const targetIds = Array.from(new Set(targets.map((item) => item.id)));
+  const targetPlans = buildProjectionPlan(targetIds);
+  const installState = await detectInstallState(cwd);
+  const srcAgents = ROOT_AGENTS_FILE;
+  const cliVersion = require(path.join(__dirname, '..', 'package.json')).version;
+
+  info('Initializing Anws...');
+  info(`Target IDEs: ${targets.map((item) => item.label).join(', ')}`);
+  if (installState.needsFallback) {
+    info('Install lock missing or unreadable. Falling back to scanned target state.');
+  }
+  if (installState.drift.hasDrift) {
+    warn(`Detected install-state drift. Missing on disk: ${installState.drift.missingOnDisk.join(', ') || 'none'}; untracked on disk: ${installState.drift.untrackedOnDisk.join(', ') || 'none'}.`);
+  }
+  blank();
 
-  // ── 冲突检测（T1.2.3 在此处插入冲突分支）──────────────────────────────────
-  const conflicting = await findConflicts(cwd);
-  if (conflicting.length > 0) {
-    const confirmed = await askOverwrite(conflicting.length);
-    if (!confirmed) {
-      blank();
-      info('Aborted. No files were changed.');
-      process.exit(0);
+  const written = [];
+  const skipped = [];
+  const successfulTargets = [];
+  const failedTargets = [];
+  const sessionWrittenFiles = new Set();
+
+  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: true,
+        shouldWarnMigration: false
+      };
+
+    const conflicting = await findConflicts(cwd, targetPlan.managedFiles, sessionWrittenFiles);
+    if (conflicting.length > 0) {
+      const confirmed = await askOverwrite(conflicting.length, target.label);
+      if (!confirmed) {
+        skipped.push(...targetPlan.managedFiles);
+        failedTargets.push({
+          targetId: target.id,
+          targetLabel: target.label,
+          reason: `Skipped ${conflicting.length} conflicting managed file(s)`
+        });
+        continue;
+      }
     }
-    // 仅覆盖托管文件（用户自有文件不受影响）
-    const { written: updated, skipped } = await overwriteManaged(srcRoot, cwd, {
+
+    const result = await writeTargetFiles(cwd, {
+      targetPlan,
+      protectedFiles: targetPlan.userProtectedFiles,
       srcAgents,
-      shouldWriteRootAgents: agentsDecision.shouldWriteRootAgents
+      shouldWriteRootAgents: agentsDecision.shouldWriteRootAgents,
+      resolveCanonicalSource
     });
+
+    written.push(...result.written);
+    for (const rel of result.written) {
+      sessionWrittenFiles.add(rel);
+    }
+    skipped.push(...result.skipped);
+    successfulTargets.push(summarizeTargetState(targetPlan, cliVersion));
+
     if (agentsDecision.shouldWarnMigration) {
       printLegacyMigrationWarning();
     }
-    printSummary(updated, skipped, 'updated');
-    return;
   }
-  // ── 无冲突:直接复制 ─────────────────────────────────────────────────────────
-
-  logo();
-  info('Initializing Antigravity Workflow System...');
-  blank();
 
-  const writtenFiles = await copyDir(srcRoot, destRoot);
-  const written = Array.isArray(writtenFiles) ? writtenFiles : [];
-
-  if (agentsDecision.shouldWriteRootAgents) {
-    const destAgents = path.join(cwd, 'AGENTS.md');
-    try {
-      await fs.copyFile(srcAgents, destAgents);
-      written.push(destAgents);
-    } catch (e) {
-      // 忽略
+  await ensureChangelogDir(cwd);
+  const existingTargets = installState.lockResult.lock?.targets || [];
+  const generatedAt = new Date().toISOString();
+  await writeInstallLock(cwd, createInstallLock({
+    cliVersion,
+    generatedAt,
+    targets: dedupeTargets([
+      ...existingTargets,
+      ...successfulTargets
+    ]),
+    lastUpdateSummary: {
+      successfulTargets: successfulTargets.map((item) => item.targetId),
+      failedTargets: failedTargets.map((item) => item.targetId),
+      updatedAt: generatedAt
     }
-  }
+  }));
 
-  if (agentsDecision.shouldWarnMigration) {
-    printLegacyMigrationWarning();
+  printTargetSummary(successfulTargets, failedTargets);
+
+  for (const rel of written) {
+    fileLine(rel.replace(/\\/g, '/'));
   }
 
-  // 打印文件列表
-  for (const absPath of written) {
-    const rel = path.relative(cwd, absPath).replace(/\\/g, '/');
-    fileLine(rel);
+  if (skipped.length > 0) {
+    blank();
+    info('Skipped (project-specific, preserved):');
+    for (const rel of skipped) {
+      skippedLine(rel.replace(/\\/g, '/'));
+    }
   }
 
   blank();
-  success(`Done! ${written.length} files written to .agent/`);
-  printNextSteps();
+  success(`Done! ${written.length} files written for ${successfulTargets.map((item) => item.targetLabel).join(', ') || 'selected targets'}.`);
+  printNextSteps(targets);
 }
 
 // ─── 辅助函数 ──────────────────────────────────────────────────────────────────
@@ -82,9 +126,12 @@ async function init() {
  * 找出 cwd 中已存在的托管文件列表。
  * @returns {Promise<string[]>} 已存在的托管文件相对路径数组
  */
-async function findConflicts(cwd) {
+async function findConflicts(cwd, managedFiles, sessionWrittenFiles = new Set()) {
   const conflicts = [];
-  for (const rel of MANAGED_FILES) {
+  for (const rel of managedFiles) {
+    if (sessionWrittenFiles.has(rel)) {
+      continue;
+    }
     const abs = path.join(cwd, rel);
     const exists = await pathExists(abs);
     if (exists) conflicts.push(rel);
@@ -97,26 +144,19 @@ async function findConflicts(cwd) {
  * 非 TTY 环境（如 CI）自动返回 false。
  * @returns {Promise<boolean>}
  */
-async function askOverwrite(count) {
+async function askOverwrite(count, label) {
   if (global.__ANWS_FORCE_YES) return true;
 
-  // 非 TTY 环境：默认不覆盖，防止 CI 挂起
   if (!process.stdin.isTTY) {
     warn(`${count} managed file(s) already exist. Non-TTY: skipping overwrite.`);
     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  ${count} managed file(s) already exist. Overwrite? [y/N] `,
-      (answer) => {
-        rl.close();
-        resolve(answer.trim().toLowerCase() === 'y');
-      }
-    );
+  return confirm({
+    message: `Overwrite ${count} managed file(s) for ${label}?`,
+    confirmLabel: 'Overwrite',
+    cancelLabel: 'Skip',
+    defaultValue: false
   });
 }
 
@@ -127,62 +167,14 @@ async function askMigrate() {
     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 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');
-      }
-    );
+  return confirm({
+    message: 'Legacy .agent/ directory detected. Migrate to .agents/?',
+    confirmLabel: 'Migrate',
+    cancelLabel: 'Keep legacy',
+    defaultValue: false
   });
 }
 
-/**
- * 仅覆盖 MANAGED_FILES 清单内的文件，用户自有文件不受影响。
- * USER_PROTECTED_FILES 中的文件即便冲突也跳过，保留用户修改。
- * @returns {{ written: string[], skipped: string[] }}
- */
-async function overwriteManaged(srcRoot, cwd, options = {}) {
-  const srcBase = path.dirname(srcRoot); // templates/
-  const written = [];
-  const skipped = [];
-  const shouldWriteRootAgents = options.shouldWriteRootAgents !== false;
-  const srcAgents = options.srcAgents || path.join(srcBase, 'AGENTS.md');
-
-  for (const rel of MANAGED_FILES) {
-    if (rel === 'AGENTS.md' && !shouldWriteRootAgents) {
-      skipped.push(rel);
-      continue;
-    }
-
-    // 受保护文件：文件已存在时跳过，交给用户自行维护
-    if (USER_PROTECTED_FILES.includes(rel)) {
-      const destPath = path.join(cwd, rel);
-      const exists = await pathExists(destPath);
-      if (exists) {
-        skipped.push(rel);
-        continue;
-      }
-    }
-
-    const srcPath = rel === 'AGENTS.md' ? srcAgents : path.join(srcBase, rel);
-    const destPath = path.join(cwd, rel);
-
-    await fs.mkdir(path.dirname(destPath), { recursive: true });
-    const srcExists = await pathExists(srcPath);
-    if (srcExists) {
-      await fs.copyFile(srcPath, destPath);
-      written.push(rel);
-    }
-  }
-
-  return { written, skipped };
-}
-
 /**
  * 打印操作摘要（更新场景）。
  * @param {string[]} files  已写入的文件
@@ -211,11 +203,44 @@ function printSummary(files, skipped = [], action) {
   }
 }
 
-function printNextSteps() {
+async function selectTargets() {
+  if (global.__ANWS_TARGET_IDS && global.__ANWS_TARGET_IDS.length > 0) {
+    return global.__ANWS_TARGET_IDS.map((targetId) => getTarget(targetId));
+  }
+
+  if (!process.stdin.isTTY) {
+    return [getTarget('antigravity')];
+  }
+
+  const targets = listTargets();
+
+  return selectMultiple({
+    message: 'Choose your target AI IDEs:',
+    options: targets.map((target) => ({ label: target.label, value: target.id })),
+    initialSelectedIndexes: [1]
+  }).then((selectedOptions) => selectedOptions.map((option) => getTarget(option.value)));
+}
+
+function printNextSteps(targets) {
   blank();
-  info('Next steps:');
-  info('  1. Read AGENTS.md to understand the system');
-  info('  2. Run /quickstart in your AI assistant to analyze and start the workflow');
+  section('Next steps', targets.some((target) => target.rootAgentFile)
+    ? [
+      '1. Read AGENTS.md to understand the system',
+      '2. Run /quickstart in your AI assistant to analyze and start the workflow'
+    ]
+    : [
+      '1. Review files written under the selected target directories',
+      '2. Run /quickstart in your AI assistant to analyze and start the workflow'
+    ]);
+}
+
+function printTargetSummary(successfulTargets, failedTargets) {
+  blank();
+  section('Target summary', [
+    ...successfulTargets.map((target) => `✔ ${target.targetLabel} (${target.targetId})`),
+    ...failedTargets.map((target) => `✖ ${target.targetLabel} (${target.targetId}) — ${target.reason}`)
+  ]);
 }
 
 module.exports = init;
+