ai-ops-cli 0.1.14 → 0.1.16

package/dist/bin/index.js

@@ -4,8 +4,8 @@
 import { Command } from "commander";
 
 // src/commands/init.ts
-import * as p3 from "@clack/prompts";
-import { join as join9 } from "path";
+import * as p4 from "@clack/prompts";
+import { join as join10 } from "path";
 
 // src/core/schemas/rule.schema.ts
 import { z } from "zod";
@@ -44,7 +44,8 @@ var PresetSchema = z2.object({
 import { z as z3 } from "zod";
 var SettingsConfigSchema = z3.object({
   claude: z3.array(z3.string().min(1)).optional(),
-  gemini: z3.array(z3.string().min(1)).optional()
+  gemini: z3.array(z3.string().min(1)).optional(),
+  prettierignore: z3.boolean().optional()
 }).strict();
 var WorkspaceEntrySchema = z3.object({
   preset: z3.string().min(1),
@@ -64,6 +65,8 @@ var ManifestSchema = z3.object({
   appended_files: z3.array(z3.string().min(1)).optional(),
   /** init 시 선택된 settings 항목 — update 시 재생성에 사용 */
   settings: SettingsConfigSchema.optional(),
+  /** init/update 실행 시점의 CLI 패키지 버전 — 버전 변경 감지에 사용 */
+  cliVersion: z3.string().optional(),
   /** SSOT 데이터 파일들의 deterministic SHA-256 해시 (6자리 hex). diff/update 판단 기준 */
   sourceHash: z3.string().regex(/^[a-f0-9]{6}$/, "sourceHash must be 6 lowercase hex chars"),
   generatedAt: z3.string().datetime({ offset: true })
@@ -237,7 +240,7 @@ var partitionRules = (rules) => {
   return { global, domain };
 };
 var renderFrontmatter = (paths) => {
-  const lines = paths.map((p7) => `  - "${p7}"`).join("\n");
+  const lines = paths.map((p8) => `  - "${p8}"`).join("\n");
   return `---
 paths:
 ${lines}
@@ -292,7 +295,18 @@ var renderForTool = (toolId, rules, workspaceMappings) => {
 // src/core/source-hash.ts
 import { createHash } from "crypto";
 import { readFileSync as readFileSync2, readdirSync as readdirSync2 } from "fs";
-import { resolve as resolve2 } from "path";
+import { dirname, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var getCliVersion = () => {
+  try {
+    const pkgPath = resolve2(__dirname, "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+    return pkg.version;
+  } catch {
+    return "unknown";
+  }
+};
 var computeHash = (contents) => createHash("sha256").update(contents.join("")).digest("hex").slice(0, 6);
 var computeSourceHash = (rulesDir) => {
   const files = readdirSync2(rulesDir).filter((f) => f.endsWith(".yaml")).sort();
@@ -311,6 +325,7 @@ var buildManifest = (params) => ManifestSchema.parse({
     claude: params.settings.claude ? [...params.settings.claude] : void 0,
     gemini: params.settings.gemini ? [...params.settings.gemini] : void 0
   } : void 0,
+  cliVersion: params.cliVersion,
   sourceHash: params.sourceHash,
   generatedAt: (/* @__PURE__ */ new Date()).toISOString()
 });
@@ -319,20 +334,7 @@ var buildManifest = (params) => ManifestSchema.parse({
 var MANAGED_MARKER = "<!-- managed by ai-ops -->";
 var SECTION_START = "<!-- ai-ops:start -->";
 var SECTION_END = "<!-- ai-ops:end -->";
-var wrapWithHeader = (content, meta) => {
-  const metaLine = `<!-- sourceHash: ${meta.sourceHash} | generatedAt: ${meta.generatedAt} -->`;
-  return `${MANAGED_MARKER}
-${metaLine}
-
-${content}`;
-};
-var isManagedFile = (content) => content.startsWith(MANAGED_MARKER);
-var stripManagedHeader = (content) => {
-  if (!isManagedFile(content)) return content;
-  const lines = content.split("\n");
-  const stripped = lines.slice(3).join("\n");
-  return stripped;
-};
+var hasLegacyHeader = (content) => content.includes(MANAGED_MARKER);
 var wrapWithSection = (content, meta) => {
   const metaLine = `<!-- sourceHash: ${meta.sourceHash} | generatedAt: ${meta.generatedAt} -->`;
   return `${SECTION_START}
@@ -356,12 +358,12 @@ var replaceAiOpsSection = (existing, newSection) => {
   if (startIdx === -1 || endIdx === -1) return existing;
   const before = existing.slice(0, startIdx).trimEnd();
   const after = existing.slice(endIdx + SECTION_END.length).trimStart();
-  return before + "\n\n" + newSection + (after ? "\n\n" + after : "") + "\n";
+  return [before, newSection, after].filter(Boolean).join("\n\n") + "\n";
 };
 
 // src/core/manifest-io.ts
 import { mkdirSync, readFileSync as readFileSync3, writeFileSync } from "fs";
-import { dirname, join as join2 } from "path";
+import { dirname as dirname2, join as join2 } from "path";
 var MANIFEST_FILENAME = ".ai-ops-manifest.json";
 var parseManifest = (json) => ManifestSchema.parse(JSON.parse(json));
 var serializeManifest = (manifest) => JSON.stringify(manifest, null, 2) + "\n";
@@ -376,20 +378,21 @@ var readManifest = (manifestPath) => {
   return parseManifest(raw);
 };
 var writeManifest = (manifestPath, manifest) => {
-  mkdirSync(dirname(manifestPath), { recursive: true });
+  mkdirSync(dirname2(manifestPath), { recursive: true });
   writeFileSync(manifestPath, serializeManifest(manifest), "utf-8");
 };
 
 // src/core/diff.ts
 var computeDiff = (params) => {
-  const { previous, currentRules, currentSourceHash } = params;
+  const { previous, currentRules, currentSourceHash, currentCliVersion } = params;
   const previousSet = new Set(previous.installed_rules);
   const currentSet = new Set(currentRules);
   const added = currentRules.filter((id) => !previousSet.has(id));
   const removed = previous.installed_rules.filter((id) => !currentSet.has(id));
   const sourceChanged = previous.sourceHash !== currentSourceHash;
-  const status = added.length > 0 || removed.length > 0 || sourceChanged ? "changed" : "up-to-date";
-  return { status, added, removed, sourceChanged };
+  const versionChanged = previous.cliVersion !== void 0 && currentCliVersion !== void 0 && previous.cliVersion !== currentCliVersion;
+  const status = added.length > 0 || removed.length > 0 || sourceChanged || versionChanged ? "changed" : "up-to-date";
+  return { status, added, removed, sourceChanged, versionChanged };
 };
 
 // src/core/install-plan.ts
@@ -400,7 +403,7 @@ var buildInstallPlan = (params) => {
   if (toolId === "claude-code" && renderResult.tool === "claude-code") {
     return renderResult.files.map(({ relativePath, content }) => ({
       relativePath,
-      content: wrapWithHeader(content, meta)
+      content: wrapWithSection(content, meta)
     }));
   }
   if (toolId === "codex" && renderResult.tool === "codex" || toolId === "gemini" && renderResult.tool === "gemini") {
@@ -410,13 +413,13 @@ var buildInstallPlan = (params) => {
       const rootContent = toolId === "codex" ? renderResult.rootContent + CODEX_PLAN_SECTION : renderResult.rootContent;
       actions.push({
         relativePath: join3(config.dir, config.rootFileName),
-        content: wrapWithHeader(rootContent, meta)
+        content: wrapWithSection(rootContent, meta)
       });
     }
     if (renderResult.domainContent) {
       actions.push({
         relativePath: join3(config.dir, config.domainFileName),
-        content: wrapWithHeader(renderResult.domainContent, meta)
+        content: wrapWithSection(renderResult.domainContent, meta)
       });
     }
     return actions;
@@ -462,10 +465,10 @@ var inferInstalledFiles = (manifest) => {
 };
 
 // src/core/paths.ts
-import { dirname as dirname2, resolve as resolve3 } from "path";
-import { fileURLToPath } from "url";
-var __dirname = dirname2(fileURLToPath(import.meta.url));
-var COMPILER_DATA_DIR = resolve3(__dirname, "..", "..", "data");
+import { dirname as dirname3, resolve as resolve3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __dirname2 = dirname3(fileURLToPath2(import.meta.url));
+var COMPILER_DATA_DIR = resolve3(__dirname2, "..", "..", "data");
 
 // src/lib/paths.ts
 import { join as join5 } from "path";
@@ -520,33 +523,32 @@ var listWorkspaceCandidates = (basePath) => {
 
 // src/lib/install.ts
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname3, resolve as resolve5 } from "path";
-var installFiles = (basePath, actions, meta) => {
+import { dirname as dirname4, resolve as resolve5 } from "path";
+var installFiles = (basePath, actions, _meta) => {
   const written = [];
   const appended = [];
   const skipped = [];
   for (const action of actions) {
     const absPath = resolve5(basePath, action.relativePath);
-    if (existsSync2(absPath)) {
+    if (!existsSync2(absPath)) {
+      mkdirSync2(dirname4(absPath), { recursive: true });
+      writeFileSync2(absPath, action.content + "\n", "utf-8");
+      written.push(action.relativePath);
+    } else {
       const existing = readFileSync4(absPath, "utf-8");
-      if (isManagedFile(existing)) {
-        writeFileSync2(absPath, action.content, "utf-8");
-        written.push(action.relativePath);
-      } else if (hasAiOpsSection(existing)) {
-        const sectionContent = wrapWithSection(stripManagedHeader(action.content), meta);
-        const updated = replaceAiOpsSection(existing, sectionContent);
+      if (hasAiOpsSection(existing)) {
+        const updated = replaceAiOpsSection(existing, action.content);
         writeFileSync2(absPath, updated, "utf-8");
-        appended.push(action.relativePath);
+        const stripped = stripAiOpsSection(existing);
+        (stripped.trim().length > 0 ? appended : written).push(action.relativePath);
+      } else if (hasLegacyHeader(existing)) {
+        writeFileSync2(absPath, action.content + "\n", "utf-8");
+        written.push(action.relativePath);
       } else {
-        const sectionContent = wrapWithSection(stripManagedHeader(action.content), meta);
-        const updated = existing.trimEnd() + "\n\n" + sectionContent + "\n";
+        const updated = existing.trimEnd() + "\n\n" + action.content + "\n";
         writeFileSync2(absPath, updated, "utf-8");
         appended.push(action.relativePath);
       }
-    } else {
-      mkdirSync2(dirname3(absPath), { recursive: true });
-      writeFileSync2(absPath, action.content, "utf-8");
-      written.push(action.relativePath);
     }
   }
   return { written, appended, skipped };
@@ -554,8 +556,40 @@ var installFiles = (basePath, actions, meta) => {
 
 // src/lib/gemini-settings.ts
 import * as p from "@clack/prompts";
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync5, rmSync, writeFileSync as writeFileSync3 } from "fs";
 import { join as join7 } from "path";
+
+// src/lib/deep-merge.util.ts
+var deepMerge = (base, patch) => {
+  const result = { ...base };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value !== null && typeof value === "object" && !Array.isArray(value) && typeof result[key] === "object" && result[key] !== null && !Array.isArray(result[key])) {
+      result[key] = deepMerge(result[key], value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+};
+var deepRemoveKeys = (base, patch) => {
+  const result = { ...base };
+  for (const [key, value] of Object.entries(patch)) {
+    if (!(key in result)) continue;
+    if (value !== null && typeof value === "object" && !Array.isArray(value) && typeof result[key] === "object" && result[key] !== null && !Array.isArray(result[key])) {
+      const nested = deepRemoveKeys(result[key], value);
+      if (Object.keys(nested).length === 0) {
+        delete result[key];
+      } else {
+        result[key] = nested;
+      }
+    } else {
+      delete result[key];
+    }
+  }
+  return result;
+};
+
+// src/lib/gemini-settings.ts
 var SETTING_GROUPS = [
   {
     value: "ui",
@@ -582,17 +616,6 @@ var SETTING_GROUPS = [
     patch: { experimental: { jitContext: true, plan: true } }
   }
 ];
-var deepMerge = (base, patch) => {
-  const result = { ...base };
-  for (const [key, value] of Object.entries(patch)) {
-    if (value !== null && typeof value === "object" && !Array.isArray(value) && typeof result[key] === "object" && result[key] !== null) {
-      result[key] = deepMerge(result[key], value);
-    } else {
-      result[key] = value;
-    }
-  }
-  return result;
-};
 var promptGeminiSettings = async () => {
   const wantSettings = await p.confirm({
     message: "Gemini CLI \uC124\uC815 \uD30C\uC77C(.gemini/settings.json)\uC744 \uC124\uCE58\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?",
@@ -632,10 +655,33 @@ var installGeminiSettings = (basePath, selectedValues) => {
   mkdirSync3(settingsDir, { recursive: true });
   writeFileSync3(settingsPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
 };
+var uninstallGeminiSettings = (basePath, selectedValues) => {
+  const settingsPath = join7(basePath, ".gemini", "settings.json");
+  if (!existsSync3(settingsPath)) return "notFound";
+  let existing = {};
+  try {
+    existing = JSON.parse(readFileSync5(settingsPath, "utf-8"));
+  } catch {
+    rmSync(settingsPath, { force: true });
+    return "deleted";
+  }
+  let result = existing;
+  for (const val of selectedValues) {
+    const group = SETTING_GROUPS.find((g) => g.value === val);
+    if (!group) continue;
+    result = deepRemoveKeys(result, group.patch);
+  }
+  if (Object.keys(result).length === 0) {
+    rmSync(settingsPath, { force: true });
+    return "deleted";
+  }
+  writeFileSync3(settingsPath, JSON.stringify(result, null, 2) + "\n", "utf-8");
+  return "cleaned";
+};
 
 // src/lib/claude-settings.ts
 import * as p2 from "@clack/prompts";
-import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync6, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "fs";
 import { join as join8 } from "path";
 var SETTING_GROUPS2 = [
   {
@@ -651,17 +697,6 @@ var SETTING_GROUPS2 = [
     patch: { plansDirectory: "./.claude/plans" }
   }
 ];
-var deepMerge2 = (base, patch) => {
-  const result = { ...base };
-  for (const [key, value] of Object.entries(patch)) {
-    if (value !== null && typeof value === "object" && !Array.isArray(value) && typeof result[key] === "object" && result[key] !== null) {
-      result[key] = deepMerge2(result[key], value);
-    } else {
-      result[key] = value;
-    }
-  }
-  return result;
-};
 var promptClaudeSettings = async () => {
   const wantSettings = await p2.confirm({
     message: "Claude Code \uC124\uC815 \uD30C\uC77C(.claude/settings.local.json)\uC744 \uC124\uCE58\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?",
@@ -696,11 +731,131 @@ var installClaudeSettings = (basePath, selectedValues) => {
   for (const val of selectedValues) {
     const group = SETTING_GROUPS2.find((g) => g.value === val);
     if (!group) continue;
-    merged = deepMerge2(merged, group.patch);
+    merged = deepMerge(merged, group.patch);
   }
   mkdirSync4(settingsDir, { recursive: true });
   writeFileSync4(settingsPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
 };
+var uninstallClaudeSettings = (basePath, selectedValues) => {
+  const settingsPath = join8(basePath, ".claude", "settings.local.json");
+  if (!existsSync4(settingsPath)) return "notFound";
+  let existing = {};
+  try {
+    existing = JSON.parse(readFileSync6(settingsPath, "utf-8"));
+  } catch {
+    rmSync2(settingsPath, { force: true });
+    return "deleted";
+  }
+  let result = existing;
+  for (const val of selectedValues) {
+    const group = SETTING_GROUPS2.find((g) => g.value === val);
+    if (!group) continue;
+    result = deepRemoveKeys(result, group.patch);
+  }
+  if (Object.keys(result).length === 0) {
+    rmSync2(settingsPath, { force: true });
+    return "deleted";
+  }
+  writeFileSync4(settingsPath, JSON.stringify(result, null, 2) + "\n", "utf-8");
+  return "cleaned";
+};
+
+// src/lib/prettier-ignore.ts
+import * as p3 from "@clack/prompts";
+import { existsSync as existsSync5, readFileSync as readFileSync7, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "fs";
+import { join as join9 } from "path";
+var PRETTIER_IGNORE_CONTENT = `# CLAUDE
+.claude/rules/
+**/CLAUDE.md
+
+# GEMINI
+**/GEMINI.md
+
+# CODEX
+**/AGENTS.md
+**/AGENTS.override.md
+
+.ai-ops-manifest.json`;
+var SECTION_START2 = "# ai-ops:start";
+var SECTION_END2 = "# ai-ops:end";
+var wrapSection = (content) => `${SECTION_START2}
+${content}
+${SECTION_END2}`;
+var hasAiOpsSection2 = (content) => content.includes(SECTION_START2) && content.includes(SECTION_END2);
+var replaceSection = (content, newContent) => {
+  const lines = content.split("\n");
+  const result = [];
+  let inside = false;
+  let replaced = false;
+  for (const line of lines) {
+    if (line.trim() === SECTION_START2) {
+      inside = true;
+      result.push(wrapSection(newContent));
+      replaced = true;
+      continue;
+    }
+    if (line.trim() === SECTION_END2) {
+      inside = false;
+      continue;
+    }
+    if (!inside) result.push(line);
+  }
+  if (!replaced) result.push(wrapSection(newContent));
+  return result.join("\n");
+};
+var stripAiOpsSection2 = (content) => {
+  const lines = content.split("\n");
+  const result = [];
+  let inside = false;
+  for (const line of lines) {
+    if (line.trim() === SECTION_START2) {
+      inside = true;
+      continue;
+    }
+    if (line.trim() === SECTION_END2) {
+      inside = false;
+      continue;
+    }
+    if (!inside) result.push(line);
+  }
+  return result.join("\n");
+};
+var promptPrettierIgnore = async () => {
+  const want = await p3.confirm({
+    message: ".prettierignore\uB97C \uC124\uCE58\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C? (VSCode Prettier \uC790\uB3D9 \uD3EC\uB9F7\uC73C\uB85C\uBD80\uD130 AI \uADDC\uCE59 \uD30C\uC77C \uBCF4\uD638)",
+    initialValue: false
+  });
+  if (p3.isCancel(want)) return false;
+  return want;
+};
+var installPrettierIgnore = (basePath) => {
+  const filePath = join9(basePath, ".prettierignore");
+  const section = wrapSection(PRETTIER_IGNORE_CONTENT);
+  if (!existsSync5(filePath)) {
+    writeFileSync5(filePath, section + "\n", "utf-8");
+    return;
+  }
+  const existing = readFileSync7(filePath, "utf-8");
+  if (hasAiOpsSection2(existing)) {
+    writeFileSync5(filePath, replaceSection(existing, PRETTIER_IGNORE_CONTENT), "utf-8");
+    return;
+  }
+  const separator = existing.endsWith("\n") ? "\n" : "\n\n";
+  writeFileSync5(filePath, existing + separator + section + "\n", "utf-8");
+};
+var uninstallPrettierIgnore = (basePath) => {
+  const filePath = join9(basePath, ".prettierignore");
+  if (!existsSync5(filePath)) return "notFound";
+  const existing = readFileSync7(filePath, "utf-8");
+  if (!hasAiOpsSection2(existing)) return "notFound";
+  const stripped = stripAiOpsSection2(existing).trim();
+  if (stripped.length === 0) {
+    rmSync3(filePath, { force: true });
+    return "deleted";
+  }
+  writeFileSync5(filePath, stripped + "\n", "utf-8");
+  return "cleaned";
+};
 
 // src/commands/init.ts
 var TOOL_OPTIONS = [
@@ -717,7 +872,7 @@ var deduplicateRules = (rules) => {
   });
 };
 var selectPresetAndFineTune = async (workspaceName, presets, allRules) => {
-  const preset = await p3.select({
+  const preset = await p4.select({
     message: `[${workspaceName}] \uD504\uB9AC\uC14B\uC744 \uC120\uD0DD\uD558\uC138\uC694`,
     options: presets.map((pr) => ({
       value: pr,
@@ -725,25 +880,25 @@ var selectPresetAndFineTune = async (workspaceName, presets, allRules) => {
       hint: pr.description
     }))
   });
-  if (p3.isCancel(preset)) return null;
+  if (p4.isCancel(preset)) return null;
   const presetRuleGroups = resolvePresetRuleGroups(preset, allRules);
   const globalGroups = presetRuleGroups.filter((group) => group.rules.every(isGlobalRule));
   const domainGroups = presetRuleGroups.filter((group) => !group.rules.every(isGlobalRule));
   const globalGroupIds = globalGroups.map((group) => group.id);
   const globalRules = globalGroupIds.length > 0 ? resolvePresetRules({ ...preset, rules: globalGroupIds }, allRules) : [];
   if (globalRules.length > 0) {
-    p3.note(globalRules.map((r) => `  \u2713 ${r.id}`).join("\n"), `[${workspaceName}] \uAE30\uBCF8 \uADDC\uCE59 (\uC7A0\uAE08)`);
+    p4.note(globalRules.map((r) => `  \u2713 ${r.id}`).join("\n"), `[${workspaceName}] \uAE30\uBCF8 \uADDC\uCE59 (\uC7A0\uAE08)`);
   }
   if (domainGroups.length === 0) {
     return { workspace: workspaceName, preset, finalRules: resolvePresetRules(preset, allRules) };
   }
-  const selectedDomain = await p3.multiselect({
+  const selectedDomain = await p4.multiselect({
     message: `[${workspaceName}] \uB3C4\uBA54\uC778 \uADDC\uCE59 \uC120\uD0DD (\uD574\uC81C\uD558\uC5EC \uC81C\uC678)`,
     options: domainGroups.map((group) => ({ value: group.id, label: group.id })),
     initialValues: domainGroups.map((group) => group.id),
     required: false
   });
-  if (p3.isCancel(selectedDomain)) return null;
+  if (p4.isCancel(selectedDomain)) return null;
   const selectedLogicalRuleIds = [...globalGroupIds, ...selectedDomain];
   return {
     workspace: workspaceName,
@@ -759,8 +914,8 @@ var installHierarchicalMonorepo = (toolId, mappings, basePath, meta) => {
   const { global } = partitionRules(allRules);
   if (global.length > 0) {
     const rootAction = {
-      relativePath: join9(config.dir, config.rootFileName),
-      content: wrapWithHeader(renderRulesToMarkdown(global), meta)
+      relativePath: join10(config.dir, config.rootFileName),
+      content: wrapWithSection(renderRulesToMarkdown(global), meta)
     };
     const r = installFiles(basePath, [rootAction], meta);
     written.push(...r.written);
@@ -770,8 +925,8 @@ var installHierarchicalMonorepo = (toolId, mappings, basePath, meta) => {
     const { domain } = partitionRules(mapping.finalRules);
     if (domain.length === 0) continue;
     const domainAction = {
-      relativePath: join9(mapping.workspace, config.domainFileName),
-      content: wrapWithHeader(renderRulesToMarkdown(domain), meta)
+      relativePath: join10(mapping.workspace, config.domainFileName),
+      content: wrapWithSection(renderRulesToMarkdown(domain), meta)
     };
     const r = installFiles(basePath, [domainAction], meta);
     written.push(...r.written);
@@ -793,22 +948,22 @@ var installClaudeCodeMonorepo = (mappings, basePath, meta) => {
 var initCommand = async () => {
   const basePath = resolveBasePath();
   const rulesDir = resolveRulesDir();
-  p3.intro("ai-ops init");
-  const selectedTools = await p3.multiselect({
+  p4.intro("ai-ops init");
+  const selectedTools = await p4.multiselect({
     message: "AI \uB3C4\uAD6C\uB97C \uC120\uD0DD\uD558\uC138\uC694",
     options: TOOL_OPTIONS,
     required: true
   });
-  if (p3.isCancel(selectedTools)) {
-    p3.cancel("\uCDE8\uC18C\uB428");
+  if (p4.isCancel(selectedTools)) {
+    p4.cancel("\uCDE8\uC18C\uB428");
     process.exit(0);
   }
-  const isMonorepo = await p3.confirm({
+  const isMonorepo = await p4.confirm({
     message: "\uBAA8\uB178\uB808\uD3EC \uD504\uB85C\uC81D\uD2B8\uC785\uB2C8\uAE4C?",
     initialValue: false
   });
-  if (p3.isCancel(isMonorepo)) {
-    p3.cancel("\uCDE8\uC18C\uB428");
+  if (p4.isCancel(isMonorepo)) {
+    p4.cancel("\uCDE8\uC18C\uB428");
     process.exit(0);
   }
   const allRules = loadAllRules(rulesDir);
@@ -818,25 +973,25 @@ var initCommand = async () => {
   if (!isMonorepo) {
     const mapping = await selectPresetAndFineTune(".", presets, allRules);
     if (!mapping) {
-      p3.cancel("\uCDE8\uC18C\uB428");
+      p4.cancel("\uCDE8\uC18C\uB428");
       process.exit(0);
     }
     mappings.push(mapping);
   } else {
     const candidates = listWorkspaceCandidates(basePath);
-    const selectedWorkspaces = await p3.multiselect({
+    const selectedWorkspaces = await p4.multiselect({
       message: "\uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4\uB97C \uC120\uD0DD\uD558\uC138\uC694",
       options: candidates.map((c) => ({ value: c, label: c })),
       required: true
     });
-    if (p3.isCancel(selectedWorkspaces)) {
-      p3.cancel("\uCDE8\uC18C\uB428");
+    if (p4.isCancel(selectedWorkspaces)) {
+      p4.cancel("\uCDE8\uC18C\uB428");
       process.exit(0);
     }
     for (const ws of selectedWorkspaces) {
       const mapping = await selectPresetAndFineTune(ws, presets, allRules);
       if (!mapping) {
-        p3.cancel("\uCDE8\uC18C\uB428");
+        p4.cancel("\uCDE8\uC18C\uB428");
         process.exit(0);
       }
       mappings.push(mapping);
@@ -844,7 +999,8 @@ var initCommand = async () => {
   }
   const geminiSettingValues = selectedTools.includes("gemini") ? await promptGeminiSettings() : null;
   const claudeSettingValues = selectedTools.includes("claude-code") ? await promptClaudeSettings() : null;
-  const s = p3.spinner();
+  const wantPrettierIgnore = await promptPrettierIgnore();
+  const s = p4.spinner();
   s.start("\uADDC\uCE59 \uC124\uCE58 \uC911...");
   const meta = { sourceHash, generatedAt: (/* @__PURE__ */ new Date()).toISOString() };
   const allInstalledFiles = [];
@@ -870,11 +1026,12 @@ var initCommand = async () => {
   }
   if (geminiSettingValues && geminiSettingValues.length > 0) {
     installGeminiSettings(basePath, geminiSettingValues);
-    allInstalledFiles.push(".gemini/settings.json");
   }
   if (claudeSettingValues && claudeSettingValues.length > 0) {
     installClaudeSettings(basePath, claudeSettingValues);
-    allInstalledFiles.push(".claude/settings.local.json");
+  }
+  if (wantPrettierIgnore) {
+    installPrettierIgnore(basePath);
   }
   s.stop("\uADDC\uCE59 \uC124\uCE58 \uC644\uB8CC");
   const allInstalledRuleIds = deduplicateRules(mappings.flatMap((m) => m.finalRules)).map((r) => r.id);
@@ -889,46 +1046,50 @@ var initCommand = async () => {
     installedRules: allInstalledRuleIds,
     installedFiles: allInstalledFiles,
     appendedFiles: allAppended,
-    settings: claudeSettingValues || geminiSettingValues ? {
+    settings: claudeSettingValues || geminiSettingValues || wantPrettierIgnore ? {
       claude: claudeSettingValues ? [...claudeSettingValues] : void 0,
-      gemini: geminiSettingValues ? [...geminiSettingValues] : void 0
+      gemini: geminiSettingValues ? [...geminiSettingValues] : void 0,
+      prettierignore: wantPrettierIgnore || void 0
     } : void 0,
+    cliVersion: getCliVersion(),
     sourceHash
   });
   writeManifest(resolveManifestPath(basePath), manifest);
   if (allAppended.length > 0) {
-    p3.log.info(`\uAE30\uC874 \uD30C\uC77C\uC5D0 \uC139\uC158 \uCD94\uAC00\uB428 (\uB0B4\uC6A9 \uBCF4\uC874):
+    p4.log.info(`\uAE30\uC874 \uD30C\uC77C\uC5D0 \uC139\uC158 \uCD94\uAC00\uB428 (\uB0B4\uC6A9 \uBCF4\uC874):
 ${allAppended.map((f) => `  ${f}`).join("\n")}`);
   }
-  p3.log.success(`\uC124\uCE58\uB41C \uADDC\uCE59: ${allInstalledRuleIds.length}\uAC1C`);
-  p3.outro("ai-ops init \uC644\uB8CC");
+  p4.log.success(`\uC124\uCE58\uB41C \uADDC\uCE59: ${allInstalledRuleIds.length}\uAC1C`);
+  p4.outro("ai-ops init \uC644\uB8CC");
 };
 
 // src/commands/update.ts
-import * as p4 from "@clack/prompts";
-import { join as join10 } from "path";
+import * as p5 from "@clack/prompts";
+import { join as join11 } from "path";
 var updateCommand = async (opts) => {
   const basePath = resolveBasePath();
   const manifestPath = resolveManifestPath(basePath);
-  p4.intro("ai-ops update");
+  p5.intro("ai-ops update");
   const manifest = readManifest(manifestPath);
   if (!manifest) {
-    p4.log.error("manifest\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 ai-ops init\uC744 \uC2E4\uD589\uD558\uC138\uC694.");
+    p5.log.error("manifest\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 ai-ops init\uC744 \uC2E4\uD589\uD558\uC138\uC694.");
     process.exit(1);
   }
   const rulesDir = resolveRulesDir();
   const sourceHash = computeSourceHash(rulesDir);
+  const cliVersion = getCliVersion();
   const diffResult = computeDiff({
     previous: manifest,
     currentRules: manifest.installed_rules,
-    currentSourceHash: sourceHash
+    currentSourceHash: sourceHash,
+    currentCliVersion: cliVersion
   });
   if (diffResult.status === "up-to-date" && !opts.force) {
-    p4.log.info("\uBCC0\uACBD \uC0AC\uD56D\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.");
-    p4.outro("ai-ops update \uC644\uB8CC");
+    p5.log.info("\uBCC0\uACBD \uC0AC\uD56D\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.");
+    p5.outro("ai-ops update \uC644\uB8CC");
     return;
   }
-  const s = p4.spinner();
+  const s = p5.spinner();
   s.start("\uADDC\uCE59 \uAC31\uC2E0 \uC911...");
   const allRules = loadAllRules(rulesDir);
   const meta = { sourceHash, generatedAt: (/* @__PURE__ */ new Date()).toISOString() };
@@ -957,8 +1118,8 @@ var updateCommand = async (opts) => {
         const { global } = partitionRules(allRulesToInstall);
         if (global.length > 0) {
           const rootAction = {
-            relativePath: join10(config.dir, config.rootFileName),
-            content: wrapWithHeader(renderRulesToMarkdown(global), meta)
+            relativePath: join11(config.dir, config.rootFileName),
+            content: wrapWithSection(renderRulesToMarkdown(global), meta)
           };
           const r = installFiles(basePath, [rootAction], meta);
           allInstalledFiles.push(...r.written);
@@ -970,8 +1131,8 @@ var updateCommand = async (opts) => {
           const { domain } = partitionRules(wsRules);
           if (domain.length === 0) continue;
           const domainAction = {
-            relativePath: join10(ws, config.domainFileName),
-            content: wrapWithHeader(renderRulesToMarkdown(domain), meta)
+            relativePath: join11(ws, config.domainFileName),
+            content: wrapWithSection(renderRulesToMarkdown(domain), meta)
           };
           const r = installFiles(basePath, [domainAction], meta);
           allInstalledFiles.push(...r.written);
@@ -997,6 +1158,9 @@ var updateCommand = async (opts) => {
   if (manifest.settings?.gemini) {
     installGeminiSettings(basePath, manifest.settings.gemini);
   }
+  if (manifest.settings?.prettierignore) {
+    installPrettierIgnore(basePath);
+  }
   const newManifest = buildManifest({
     tools: manifest.tools,
     scope: manifest.scope,
@@ -1007,23 +1171,25 @@ var updateCommand = async (opts) => {
     appendedFiles: allAppended.length > 0 ? allAppended : manifest.appended_files,
     settings: manifest.settings ? {
       claude: manifest.settings.claude,
-      gemini: manifest.settings.gemini
+      gemini: manifest.settings.gemini,
+      prettierignore: manifest.settings.prettierignore
     } : void 0,
+    cliVersion,
     sourceHash
   });
   writeManifest(manifestPath, newManifest);
   s.stop("\uADDC\uCE59 \uAC31\uC2E0 \uC644\uB8CC");
-  p4.outro("ai-ops update \uC644\uB8CC");
+  p5.outro("ai-ops update \uC644\uB8CC");
 };
 
 // src/commands/diff.ts
-import * as p5 from "@clack/prompts";
+import * as p6 from "@clack/prompts";
 var diffCommand = async () => {
   const basePath = resolveBasePath();
-  p5.intro("ai-ops diff");
+  p6.intro("ai-ops diff");
   const manifest = readManifest(resolveManifestPath(basePath));
   if (!manifest) {
-    p5.log.error("manifest\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 ai-ops init\uC744 \uC2E4\uD589\uD558\uC138\uC694.");
+    p6.log.error("manifest\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 ai-ops init\uC744 \uC2E4\uD589\uD558\uC138\uC694.");
     process.exit(1);
   }
   const sourceHash = computeSourceHash(resolveRulesDir());
@@ -1033,28 +1199,28 @@ var diffCommand = async () => {
     currentSourceHash: sourceHash
   });
   if (result.status === "up-to-date") {
-    p5.log.success("\uBCC0\uACBD \uC0AC\uD56D \uC5C6\uC74C. \uCD5C\uC2E0 \uC0C1\uD0DC\uC785\uB2C8\uB2E4.");
+    p6.log.success("\uBCC0\uACBD \uC0AC\uD56D \uC5C6\uC74C. \uCD5C\uC2E0 \uC0C1\uD0DC\uC785\uB2C8\uB2E4.");
   } else {
     if (result.sourceChanged) {
-      p5.log.warn(`\uC18C\uC2A4 \uBCC0\uACBD \uAC10\uC9C0: ${manifest.sourceHash} \u2192 ${sourceHash}`);
+      p6.log.warn(`\uC18C\uC2A4 \uBCC0\uACBD \uAC10\uC9C0: ${manifest.sourceHash} \u2192 ${sourceHash}`);
     }
     if (result.added.length > 0) {
-      p5.log.info(`\uCD94\uAC00\uB41C \uADDC\uCE59: ${result.added.join(", ")}`);
+      p6.log.info(`\uCD94\uAC00\uB41C \uADDC\uCE59: ${result.added.join(", ")}`);
     }
     if (result.removed.length > 0) {
-      p5.log.info(`\uC81C\uAC70\uB41C \uADDC\uCE59: ${result.removed.join(", ")}`);
+      p6.log.info(`\uC81C\uAC70\uB41C \uADDC\uCE59: ${result.removed.join(", ")}`);
     }
   }
-  p5.outro("ai-ops diff \uC644\uB8CC");
+  p6.outro("ai-ops diff \uC644\uB8CC");
 };
 
 // src/commands/uninstall.ts
-import * as p6 from "@clack/prompts";
-import { rmSync as rmSync2 } from "fs";
+import * as p7 from "@clack/prompts";
+import { rmSync as rmSync5 } from "fs";
 
 // src/lib/uninstall.ts
-import { existsSync as existsSync5, readFileSync as readFileSync7, rmSync, readdirSync as readdirSync4, writeFileSync as writeFileSync5 } from "fs";
-import { resolve as resolve6, dirname as dirname4 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync8, rmSync as rmSync4, readdirSync as readdirSync4, writeFileSync as writeFileSync6 } from "fs";
+import { resolve as resolve6, dirname as dirname5 } from "path";
 var removeFiles = (basePath, relativePaths) => {
   const deleted = [];
   const cleaned = [];
@@ -1062,23 +1228,26 @@ var removeFiles = (basePath, relativePaths) => {
   const notFound = [];
   for (const rel of relativePaths) {
     const absPath = resolve6(basePath, rel);
-    if (!existsSync5(absPath)) {
+    if (!existsSync6(absPath)) {
       notFound.push(rel);
       continue;
     }
-    const content = readFileSync7(absPath, "utf-8");
-    if (!isManagedFile(content)) {
-      if (hasAiOpsSection(content)) {
-        const stripped = stripAiOpsSection(content);
-        writeFileSync5(absPath, stripped, "utf-8");
-        cleaned.push(rel);
+    const content = readFileSync8(absPath, "utf-8");
+    if (hasAiOpsSection(content)) {
+      const stripped = stripAiOpsSection(content);
+      if (stripped.trim().length === 0) {
+        rmSync4(absPath);
+        deleted.push(rel);
       } else {
-        skipped.push(rel);
+        writeFileSync6(absPath, stripped, "utf-8");
+        cleaned.push(rel);
       }
-      continue;
+    } else if (hasLegacyHeader(content)) {
+      rmSync4(absPath);
+      deleted.push(rel);
+    } else {
+      skipped.push(rel);
     }
-    rmSync(absPath);
-    deleted.push(rel);
   }
   return { deleted, cleaned, skipped, notFound };
 };
@@ -1086,11 +1255,11 @@ var cleanEmptyDirs = (basePath, dirs) => {
   const removed = [];
   for (const dir of dirs) {
     const absDir = resolve6(basePath, dir);
-    if (!existsSync5(absDir)) continue;
+    if (!existsSync6(absDir)) continue;
     try {
       const entries = readdirSync4(absDir);
       if (entries.length === 0) {
-        rmSync(absDir, { recursive: true });
+        rmSync4(absDir, { recursive: true });
         removed.push(dir);
       }
     } catch {
@@ -1101,7 +1270,7 @@ var cleanEmptyDirs = (basePath, dirs) => {
 var collectManagedDirs = (relativePaths) => {
   const dirs = /* @__PURE__ */ new Set();
   for (const rel of relativePaths) {
-    const dir = dirname4(rel);
+    const dir = dirname5(rel);
     if (dir !== ".") {
       dirs.add(dir);
     }
@@ -1110,64 +1279,85 @@ var collectManagedDirs = (relativePaths) => {
 };
 
 // src/commands/uninstall.ts
+var SETTINGS_PATHS = /* @__PURE__ */ new Set([".claude/settings.local.json", ".gemini/settings.json"]);
 var uninstallCommand = async () => {
   const basePath = resolveBasePath();
   const manifestPath = resolveManifestPath(basePath);
-  p6.intro("ai-ops uninstall");
+  p7.intro("ai-ops uninstall");
   const manifest = readManifest(manifestPath);
   if (!manifest) {
-    p6.log.error("manifest\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 ai-ops init\uC744 \uC2E4\uD589\uD558\uC138\uC694.");
+    p7.log.error("manifest\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 ai-ops init\uC744 \uC2E4\uD589\uD558\uC138\uC694.");
     process.exit(1);
   }
   const targetFiles = [
     ...manifest.installed_files ?? inferInstalledFiles(manifest),
     ...manifest.appended_files ?? []
-  ];
+  ].filter((f) => !SETTINGS_PATHS.has(f));
   if (targetFiles.length === 0) {
-    p6.log.warn("\uC0AD\uC81C\uD560 \uD30C\uC77C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.");
-    p6.outro("ai-ops uninstall \uC644\uB8CC");
+    p7.log.warn("\uC0AD\uC81C\uD560 \uD30C\uC77C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.");
+    p7.outro("ai-ops uninstall \uC644\uB8CC");
     return;
   }
-  p6.log.info(`\uC0AD\uC81C \uB300\uC0C1 \uD30C\uC77C (${targetFiles.length}\uAC1C):
+  p7.log.info(`\uC0AD\uC81C \uB300\uC0C1 \uD30C\uC77C (${targetFiles.length}\uAC1C):
 ${targetFiles.map((f) => `  ${f}`).join("\n")}`);
-  const confirmed = await p6.confirm({
+  const confirmed = await p7.confirm({
     message: "\uC704 \uD30C\uC77C\uACFC manifest\uB97C \uBAA8\uB450 \uC0AD\uC81C\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?",
     initialValue: false
   });
-  if (p6.isCancel(confirmed) || !confirmed) {
-    p6.cancel("\uCDE8\uC18C\uB428");
+  if (p7.isCancel(confirmed) || !confirmed) {
+    p7.cancel("\uCDE8\uC18C\uB428");
     process.exit(0);
   }
+  const settingsMessages = [];
+  if (manifest.settings?.claude) {
+    const status = uninstallClaudeSettings(basePath, manifest.settings.claude);
+    if (status === "deleted") settingsMessages.push("\uC0AD\uC81C: .claude/settings.local.json");
+    else if (status === "cleaned") settingsMessages.push("ai-ops \uD0A4 \uC81C\uAC70 (\uC0AC\uC6A9\uC790 \uC124\uC815 \uBCF4\uC874): .claude/settings.local.json");
+  }
+  if (manifest.settings?.gemini) {
+    const status = uninstallGeminiSettings(basePath, manifest.settings.gemini);
+    if (status === "deleted") settingsMessages.push("\uC0AD\uC81C: .gemini/settings.json");
+    else if (status === "cleaned") settingsMessages.push("ai-ops \uD0A4 \uC81C\uAC70 (\uC0AC\uC6A9\uC790 \uC124\uC815 \uBCF4\uC874): .gemini/settings.json");
+  }
+  if (manifest.settings?.prettierignore) {
+    const status = uninstallPrettierIgnore(basePath);
+    if (status === "deleted") settingsMessages.push("\uC0AD\uC81C: .prettierignore");
+    else if (status === "cleaned") settingsMessages.push("ai-ops \uC139\uC158 \uC81C\uAC70 (\uC0AC\uC6A9\uC790 \uB0B4\uC6A9 \uBCF4\uC874): .prettierignore");
+  }
   const result = removeFiles(basePath, targetFiles);
   const dirs = collectManagedDirs(targetFiles);
   const removedDirs = cleanEmptyDirs(basePath, dirs);
-  rmSync2(manifestPath, { force: true });
+  rmSync5(manifestPath, { force: true });
   if (result.deleted.length > 0) {
-    p6.log.success(`\uC0AD\uC81C \uC644\uB8CC (${result.deleted.length}\uAC1C):
+    p7.log.success(`\uC0AD\uC81C \uC644\uB8CC (${result.deleted.length}\uAC1C):
 ${result.deleted.map((f) => `  ${f}`).join("\n")}`);
   }
   if (result.cleaned.length > 0) {
-    p6.log.success(
+    p7.log.success(
       `\uC139\uC158 \uC81C\uAC70 \uC644\uB8CC (\uC0AC\uC6A9\uC790 \uB0B4\uC6A9 \uBCF4\uC874, ${result.cleaned.length}\uAC1C):
 ${result.cleaned.map((f) => `  ${f}`).join("\n")}`
     );
   }
   if (result.skipped.length > 0) {
-    p6.log.warn(
+    p7.log.warn(
       `\uAC74\uB108\uB700 (non-managed \uD30C\uC77C \uBCF4\uD638, ${result.skipped.length}\uAC1C):
 ${result.skipped.map((f) => `  ${f}`).join("\n")}`
     );
   }
   if (result.notFound.length > 0) {
-    p6.log.info(`\uC774\uBBF8 \uC5C6\uC74C (${result.notFound.length}\uAC1C):
+    p7.log.info(`\uC774\uBBF8 \uC5C6\uC74C (${result.notFound.length}\uAC1C):
 ${result.notFound.map((f) => `  ${f}`).join("\n")}`);
   }
   if (removedDirs.length > 0) {
-    p6.log.info(`\uBE48 \uB514\uB809\uD1A0\uB9AC \uC815\uB9AC (${removedDirs.length}\uAC1C):
+    p7.log.info(`\uBE48 \uB514\uB809\uD1A0\uB9AC \uC815\uB9AC (${removedDirs.length}\uAC1C):
 ${removedDirs.map((d) => `  ${d}`).join("\n")}`);
   }
-  p6.log.success(`manifest \uC0AD\uC81C: ${MANIFEST_FILENAME}`);
-  p6.outro("ai-ops uninstall \uC644\uB8CC");
+  if (settingsMessages.length > 0) {
+    p7.log.success(`\uC124\uC815 \uD30C\uC77C \uCC98\uB9AC:
+${settingsMessages.map((m) => `  ${m}`).join("\n")}`);
+  }
+  p7.log.success(`manifest \uC0AD\uC81C: ${MANIFEST_FILENAME}`);
+  p7.outro("ai-ops uninstall \uC644\uB8CC");
 };
 
 // src/bin/index.ts