@chinhae/atw-cli 0.5.0 → 0.7.0

package/dist/commands/update.js

@@ -20,20 +20,23 @@ const BATCH_FLAG_HINT = "Pass --force to overwrite, --skip-all to keep your vers
 // Import templates for comparison
 import { getAllScripts, getAllAgents, 
 // Configuration
-configYamlTemplate, gitignoreTemplate, bundledWorkflowFor, } from "../templates/atw/index.js";
+configYamlTemplate, gitignoreTemplate, bundledWorkflowFor, getModeAtwFiles, } from "../templates/atw/index.js";
 import { agentsMdFor } from "../templates/markdown/index.js";
 import { COPILOT_INSTRUCTIONS_BLOCK_END, COPILOT_INSTRUCTIONS_BLOCK_START, COPILOT_INSTRUCTIONS_PATH, getCopilotInstructions, } from "../templates/copilot/index.js";
 import { ALL_MANAGED_DIRS, getConfiguredPlatforms, collectPlatformTemplates, } from "../configurators/index.js";
 import { replacePythonCommandLiterals } from "../configurators/shared.js";
 import { preserveCodexAgentModelKeys } from "../configurators/codex.js";
+import { preserveOmpProjectConfig } from "../configurators/omp.js";
 import { ensureGitattributes } from "../configurators/workflow.js";
 import { pruneOrphanManifestKeys } from "../utils/manifest-prune.js";
 import { loadProjectMode } from "../utils/project-mode.js";
 import { fetchRegistrySpecTemplates, collectDirectoryFiles, removeDirectory, parseRegistrySource, probeRegistryIndex, downloadTemplateById, } from "../utils/template-fetcher.js";
 import { loadSpecRegistryConfig } from "../utils/registry-config.js";
 import { fetchOptionalSkills, getInstalledOptionalSkillDirs, installOptionalSkills, loadOptionalSkillRecord, } from "../utils/optional-skills.js";
+import { syncVerifyEntriesAfterInstall } from "./verify.js";
 import { cleanupEmptyDirs, ATW_BLOCK_END, ATW_BLOCK_START, } from "../utils/managed-paths.js";
 export { cleanupEmptyDirs, ATW_BLOCK_END, ATW_BLOCK_START, } from "../utils/managed-paths.js";
+import { isAtwInitialized } from "../utils/initialized.js";
 const CLAUDE_SETTINGS_PATH = ".claude/settings.json";
 const LEGACY_UNTRACKED_AGENTS_MD_BLOCK_HASHES = new Set([
     // Older installs wrote AGENTS.md without hash-tracking it.
@@ -42,12 +45,26 @@ const LEGACY_UNTRACKED_AGENTS_MD_BLOCK_HASHES = new Set([
     // false "modified by you" conflict.
     "c1f511b1cfc1902f2147da159f09cc51f380b0c9e341cdb3ac5dea5233f3e307",
 ]);
+// `.atw/.gitignore` is never hash-tracked (EXCLUDE_FROM_HASH), so a copy that
+// is byte-identical to an earlier template is recognised by these hashes and
+// upgraded like an unedited file instead of being reported as "modified by you".
+const LEGACY_ATW_GITIGNORE_HASHES = new Set([
+    // The only content released before the verify skill evidence line: every
+    // tag v0.1.0–v0.6.0 ships this same templates/atw/gitignore.txt, written
+    // verbatim by init (checked with `git show <tag>:…/gitignore.txt`).
+    "3bc42434cbe61c937a1c26ea3c880b496bfad4e7d683750169e27ade509aa798",
+    // Second version, with verify/*/evidence/ (commit 6a7d491, unreleased but
+    // installed in this repo), before the task folders' verify-evidence/ lines.
+    "cf51d374198c4a2bac0cba41e59fdacb95cff70be781636de92f3dbd68945c2e",
+]);
 // Paths that should never be touched (true user data)
 // spec/ is user-customized content created during init; update should never modify it
 const PROTECTED_PATHS = [
     `${DIR_NAMES.WORKFLOW}/${DIR_NAMES.WORKSPACE}`, // workspace/
     `${DIR_NAMES.WORKFLOW}/${DIR_NAMES.TASKS}`, // tasks/
     `${DIR_NAMES.WORKFLOW}/${DIR_NAMES.SPEC}`, // spec/
+    `${DIR_NAMES.WORKFLOW}/${DIR_NAMES.VERIFY}`, // verify/
+    `${DIR_NAMES.WORKFLOW}/${DIR_NAMES.SKILL_NOTES}`, // skill-notes/
     `${DIR_NAMES.WORKFLOW}/.developer`,
     `${DIR_NAMES.WORKFLOW}/.current-task`,
 ];
@@ -113,6 +130,9 @@ function buildCopilotInstructionsTemplate(cwd) {
     return buildManagedBlockTemplate(cwd, COPILOT_INSTRUCTIONS_PATH, getCopilotInstructions(), COPILOT_INSTRUCTIONS_BLOCK_START, COPILOT_INSTRUCTIONS_BLOCK_END);
 }
 function isKnownUntrackedTemplate(relativePath, existingContent) {
+    if (relativePath === `${DIR_NAMES.WORKFLOW}/.gitignore`) {
+        return LEGACY_ATW_GITIGNORE_HASHES.has(computeHash(existingContent));
+    }
     if (relativePath !== FILE_NAMES.AGENTS) {
         return false;
     }
@@ -137,6 +157,110 @@ function isSafeUntrackedCopilotInstructionsMerge(relativePath, existingContent,
 function isProtectedPath(filePath) {
     return PROTECTED_PATHS.some((pp) => filePath === pp || filePath.startsWith(pp.endsWith("/") ? pp : pp + "/"));
 }
+/** Temporary name of a case-only rename between its two steps. */
+const CASE_RENAME_SUFFIX = ".atw-case-rename";
+/** The current template path that differs from `relativePath` only in case. */
+function caseOnlyVariant(relativePath, currentTemplatePaths) {
+    const lower = relativePath.toLowerCase();
+    for (const candidate of currentTemplatePaths) {
+        if (candidate !== relativePath && candidate.toLowerCase() === lower) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+/**
+ * Receipt rule for a case-only rename, used both in memory and on disk: the
+ * old name's record moves to the new name unless the new name already has
+ * one. Both describe the same file; the new name's is the later write.
+ */
+function moveCaseRenameRecord(hashes, from, to) {
+    const result = { ...hashes };
+    const recorded = result[from];
+    if (recorded !== undefined && result[to] === undefined) {
+        result[to] = recorded;
+    }
+    Reflect.deleteProperty(result, from);
+    return result;
+}
+/**
+ * Finish case-only renames a previous run left between its two steps: the
+ * file sits under `<old>.atw-case-rename` and neither name exists. Runs before
+ * the change analysis so the file is judged under its new name; a dry run only
+ * reports. A temp file next to an existing file is left alone and reported.
+ */
+function finishInterruptedCaseRenames(migrations, cwd, currentTemplatePaths, hashes, dryRun) {
+    let result = hashes;
+    for (const item of migrations) {
+        if (item.type !== "safe-file-delete")
+            continue;
+        const to = caseOnlyVariant(item.from, currentTemplatePaths);
+        if (!to)
+            continue;
+        const temp = path.join(cwd, item.from + CASE_RENAME_SUFFIX);
+        if (!fs.existsSync(temp))
+            continue;
+        const target = path.join(cwd, to);
+        if (fs.existsSync(path.join(cwd, item.from)) || fs.existsSync(target)) {
+            console.log(chalk.yellow(`  ! ${item.from}${CASE_RENAME_SUFFIX} is left from an interrupted rename, but ${to} exists; compare the two and delete the one you do not need`));
+            continue;
+        }
+        console.log(chalk.cyan(`  ↻ ${item.from}${CASE_RENAME_SUFFIX} → ${to} (finishing an interrupted case-only rename)`));
+        result = moveCaseRenameRecord(result, item.from, to);
+        if (!dryRun) {
+            fs.renameSync(temp, target);
+            saveHashes(cwd, moveCaseRenameRecord(loadHashes(cwd), item.from, to));
+        }
+    }
+    return result;
+}
+/** Whether a file with exactly this name (case included) is in its directory. */
+function existsWithExactName(fullPath) {
+    try {
+        return fs
+            .readdirSync(path.dirname(fullPath))
+            .includes(path.basename(fullPath));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The current template path that differs from `relativePath` only in case and
+ * is the same file on disk — which happens only on a case-insensitive
+ * filesystem (macOS and Windows by default), where `UI.md` and `ui.md` name
+ * one file.
+ */
+function findCaseOnlyTwin(cwd, relativePath, currentTemplatePaths) {
+    const candidate = caseOnlyVariant(relativePath, currentTemplatePaths);
+    if (!candidate)
+        return undefined;
+    try {
+        const a = fs.statSync(path.join(cwd, relativePath));
+        const b = fs.statSync(path.join(cwd, candidate));
+        return a.ino === b.ino && a.dev === b.dev ? candidate : undefined;
+    }
+    catch (error) {
+        // 只有「新名字不存在」说明是两个文件；别的读不了的错误不能当成不是同一个文件
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}
+/**
+ * Move the receipt entry of each case-only rename to the new name in memory,
+ * so `analyzeChanges` judges the file under its new name by the hash recorded
+ * for it: pristine → auto-update, edited → the usual conflict prompt.
+ */
+function applyCaseRenamesToHashes(classified, hashes) {
+    let result = hashes;
+    for (const c of classified) {
+        if (c.action !== "case-rename" || !c.caseRenameTo)
+            continue;
+        result = moveCaseRenameRecord(result, c.item.from, c.caseRenameTo);
+    }
+    return result;
+}
 /**
  * Collect and classify safe-file-delete migrations
  *
@@ -169,8 +293,9 @@ bypassUpdateSkip = false) {
     const results = [];
     for (const item of safeDeletes) {
         const fullPath = path.join(cwd, item.from);
-        // Check: file exists?
-        if (!fs.existsSync(fullPath)) {
+        // Check: file exists? On a case-insensitive disk `UI.md` also "exists"
+        // once the file is `ui.md`, so the exact name has to be in the listing.
+        if (!fs.existsSync(fullPath) || !existsWithExactName(fullPath)) {
             results.push({ item, action: "skip-missing" });
             continue;
         }
@@ -188,7 +313,21 @@ bypassUpdateSkip = false) {
         if (!bypassUpdateSkip &&
             skipPaths.some((skip) => item.from === skip ||
                 item.from.startsWith(skip.endsWith("/") ? skip : skip + "/"))) {
-            results.push({ item, action: "skip-update-skip" });
+            results.push({
+                item,
+                action: "skip-update-skip",
+                renamedUpstreamTo: caseOnlyVariant(item.from, currentTemplatePaths),
+            });
+            continue;
+        }
+        // Check: is this the same file as a current template that differs only in
+        // case? Deleting it would delete the template too — its write was already
+        // judged "unchanged" or "changed" against this very file. Rename it to the
+        // template's case instead, whatever its content: no content changes here,
+        // the template write that follows applies the usual edited-file rules.
+        const caseRenameTo = findCaseOnlyTwin(cwd, item.from, currentTemplatePaths);
+        if (caseRenameTo) {
+            results.push({ item, action: "case-rename", caseRenameTo });
             continue;
         }
         // Check: hash matches allowed_hashes?
@@ -204,7 +343,11 @@ bypassUpdateSkip = false) {
                 results.push({ item, action: "delete" });
             }
             else {
-                results.push({ item, action: "skip-modified" });
+                results.push({
+                    item,
+                    action: "skip-modified",
+                    renamedUpstreamTo: caseOnlyVariant(item.from, currentTemplatePaths),
+                });
             }
         }
         catch {
@@ -218,14 +361,19 @@ bypassUpdateSkip = false) {
  */
 function printSafeFileDeleteSummary(classified) {
     const toDelete = classified.filter((c) => c.action === "delete");
+    const caseRenames = classified.filter((c) => c.action === "case-rename");
     const modified = classified.filter((c) => c.action === "skip-modified");
     const updateSkip = classified.filter((c) => c.action === "skip-update-skip");
     if (toDelete.length === 0 &&
+        caseRenames.length === 0 &&
         modified.length === 0 &&
         updateSkip.length === 0) {
         return;
     }
     console.log(chalk.cyan("  Deprecated commands cleanup:"));
+    for (const c of caseRenames) {
+        console.log(chalk.green(`    ↻ ${c.item.from} → ${c.caseRenameTo ?? ""} (case-only rename)`));
+    }
     if (toDelete.length > 0) {
         for (const c of toDelete) {
             console.log(chalk.green(`    ✕ ${c.item.from}${c.item.description ? ` (${c.item.description})` : ""}`));
@@ -233,12 +381,16 @@ function printSafeFileDeleteSummary(classified) {
     }
     if (modified.length > 0) {
         for (const c of modified) {
-            console.log(chalk.yellow(`    ? ${c.item.from} (modified, skipped)`));
+            console.log(chalk.yellow(c.renamedUpstreamTo
+                ? `    ? ${c.item.from} (modified, kept): ${c.item.from} was renamed upstream to ${c.renamedUpstreamTo}; your edits in ${c.item.from} no longer take effect — move them into ${c.renamedUpstreamTo} if you still want them`
+                : `    ? ${c.item.from} (modified, skipped)`));
         }
     }
     if (updateSkip.length > 0) {
         for (const c of updateSkip) {
-            console.log(chalk.gray(`    ○ ${c.item.from} (skipped, update.skip)`));
+            console.log(chalk.gray(c.renamedUpstreamTo
+                ? `    ○ ${c.item.from} (skipped, update.skip): renamed upstream to ${c.renamedUpstreamTo}, which is skipped too`
+                : `    ○ ${c.item.from} (skipped, update.skip)`));
         }
     }
     console.log("");
@@ -249,6 +401,30 @@ function printSafeFileDeleteSummary(classified) {
 function executeSafeFileDeletes(classified, cwd) {
     const toDelete = classified.filter((c) => c.action === "delete");
     let deleted = 0;
+    for (const c of classified) {
+        if (c.action !== "case-rename" || !c.caseRenameTo)
+            continue;
+        const from = path.join(cwd, c.item.from);
+        // Through a temporary name: a direct case-only rename is not honoured by
+        // every case-insensitive filesystem. An interruption between the two
+        // steps is finished by the next update (finishInterruptedCaseRenames).
+        const temp = from + CASE_RENAME_SUFFIX;
+        try {
+            fs.renameSync(from, temp);
+        }
+        catch {
+            // File may have been removed between classify and execute
+            continue;
+        }
+        try {
+            fs.renameSync(temp, path.join(cwd, c.caseRenameTo));
+        }
+        catch (error) {
+            fs.renameSync(temp, from);
+            throw error;
+        }
+        saveHashes(cwd, moveCaseRenameRecord(loadHashes(cwd), c.item.from, c.caseRenameTo));
+    }
     for (const c of toDelete) {
         const fullPath = path.join(cwd, c.item.from);
         try {
@@ -651,7 +827,7 @@ async function collectRegistrySpecTemplates(cwd) {
     }
     return result.files;
 }
-async function collectTemplateFiles(cwd, mode, extraPlatforms, 
+export async function collectTemplateFiles(cwd, mode, extraPlatforms, 
 /**
  * Bypass `update.skip` when collecting templates. Enable this for breaking
  * releases so newly added files (e.g. a new `continue.md`) and template
@@ -692,6 +868,11 @@ bypassUpdateSkip = false) {
     // platform routing markers outside [workflow-state:*] blocks are also
     // script-consumed.
     files.set(`${DIR_NAMES.WORKFLOW}/workflow.md`, bundledWorkflowFor(mode));
+    // Mode-only .atw/ files (dev: the default definition of done). The project's
+    // own .atw/spec/definition-of-done.md is user content and never collected.
+    for (const [file, content] of getModeAtwFiles(mode)) {
+        files.set(file, content);
+    }
     // workspace/index.md stays excluded — it's runtime-appended by add_session.py
     // (journal index) and has no script-parsed structure.
     files.set(FILE_NAMES.AGENTS, buildAgentsMdTemplate(cwd, mode));
@@ -715,6 +896,11 @@ bypassUpdateSkip = false) {
     if (platforms.has("codex")) {
         preserveCodexAgentModelKeys(cwd, files);
     }
+    // `.omp/config.yml` may be the project's own omp config: compare against
+    // ATW's settings merged into it, not against the bare template.
+    if (platforms.has("omp")) {
+        preserveOmpProjectConfig(cwd, files);
+    }
     preserveExistingClaudeStatusLine(cwd, files);
     for (const [filePath, content] of await collectRegistrySpecTemplates(cwd)) {
         files.set(filePath, content);
@@ -745,7 +931,7 @@ bypassUpdateSkip = false) {
  * - User didn't modify + template updated = auto-update (autoUpdateFiles)
  * - User modified = needs confirmation (changedFiles)
  */
-function analyzeChanges(cwd, hashes, templates) {
+export function analyzeChanges(cwd, hashes, templates) {
     const result = {
         newFiles: [],
         unchangedFiles: [],
@@ -1772,7 +1958,7 @@ async function updateOptionalSkills(cwd, dryRun) {
 export async function update(options) {
     const cwd = process.cwd();
     // Check if ATW is initialized
-    if (!fs.existsSync(path.join(cwd, DIR_NAMES.WORKFLOW))) {
+    if (!isAtwInitialized(cwd)) {
         console.log(chalk.red("Error: ATW not initialized in this directory."));
         console.log(chalk.gray("Run 'atw init' first."));
         return;
@@ -1876,8 +2062,17 @@ export async function update(options) {
     // Collect safe-file-delete items from ALL manifests (hash match is the safety net)
     // This runs regardless of version — unknown version still gets safe cleanup
     const allMigrations = getAllMigrations();
+    hashes = finishInterruptedCaseRenames(allMigrations, cwd, new Set(templates.keys()), hashes, options.dryRun === true);
     const safeFileDeletes = collectSafeFileDeletes(allMigrations, cwd, skipPaths, new Set(templates.keys()), getInstalledOptionalSkillDirs(cwd), breakingBypass);
-    const hasSafeDeletes = safeFileDeletes.filter((c) => c.action === "delete").length > 0;
+    const hasSafeDeletes = safeFileDeletes.some((c) => c.action === "delete" || c.action === "case-rename");
+    hashes = applyCaseRenamesToHashes(safeFileDeletes, hashes);
+    // update.skip 里的旧名字：用户要 ATW 别碰这个文件，只改大小写的新名字是同一个文件
+    // （不分大小写的磁盘）或它的接班（分大小写的磁盘），一并跳过
+    for (const c of safeFileDeletes) {
+        if (c.action === "skip-update-skip" && c.renamedUpstreamTo) {
+            templates.delete(c.renamedUpstreamTo);
+        }
+    }
     // Check for pending regular migrations (skip if unknown version)
     let pendingMigrations = isUnknownVersion
         ? []
@@ -2011,6 +2206,7 @@ export async function update(options) {
             }
         }
         await updateOptionalSkills(cwd, options.dryRun);
+        syncVerifyEntriesAfterInstall(cwd, options.dryRun);
         return;
     }
     // Show what this operation will do
@@ -2056,6 +2252,7 @@ export async function update(options) {
     // Dry run mode
     if (options.dryRun) {
         await updateOptionalSkills(cwd, true);
+        syncVerifyEntriesAfterInstall(cwd, true);
         console.log(chalk.gray("[Dry run] No changes made."));
         return;
     }
@@ -2242,6 +2439,7 @@ export async function update(options) {
         console.log(chalk.gray("\nTip: Review .new files and merge changes manually if needed."));
     }
     await updateOptionalSkills(cwd);
+    syncVerifyEntriesAfterInstall(cwd);
     // Create migration task if there are breaking changes with migration guides
     if (cliVsProject > 0 && projectVersion !== "unknown") {
         const metadata = getMigrationMetadata(projectVersion, cliVersion);