ai-ops-cli 0.1.9 → 0.1.10

package/dist/bin/index.js

@@ -5,39 +5,438 @@ import { Command } from "commander";
 
 // src/commands/init.ts
 import * as p2 from "@clack/prompts";
+import { join as join8 } from "path";
+
+// src/core/schemas/rule.schema.ts
+import { z } from "zod";
+var DecisionTableEntrySchema = z.object({
+  when: z.string().min(1),
+  then: z.string().min(1),
+  /** 조건부 규칙에서 회피해야 할 패턴 */
+  avoid: z.string().min(1).optional()
+}).strict();
+var RuleContentSchema = z.object({
+  /** Anti-pattern 규칙 ('하지 마라'). guidelines보다 항상 상단 렌더링 */
+  constraints: z.array(z.string().min(1)),
+  /** Positive 규칙 ('해라') */
+  guidelines: z.array(z.string().min(1)),
+  /** 조건부 규칙. when→then→avoid 구조 */
+  decision_table: z.array(DecisionTableEntrySchema).optional()
+}).strict();
+var RuleSchema = z.object({
+  id: z.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "id must be kebab-case"),
+  category: z.string().min(1),
+  tags: z.array(z.string().min(1)),
+  /** 0-100. 높을수록 생성 파일 상단 배치 (U-shaped attention 최적화) */
+  priority: z.number().int().min(0).max(100),
+  content: RuleContentSchema
+}).strict();
+
+// src/core/schemas/preset.schema.ts
+import { z as z2 } from "zod";
+var PresetSchema = z2.object({
+  id: z2.string().regex(/^[a-z][a-z0-9-]*$/).min(1),
+  description: z2.string().min(1),
+  rules: z2.array(z2.string().min(1)).min(1)
+}).strict();
+
+// src/core/schemas/manifest.schema.ts
+import { z as z3 } from "zod";
+var WorkspaceEntrySchema = z3.object({
+  preset: z3.string().min(1),
+  rules: z3.array(z3.string().min(1))
+}).strict();
+var ManifestSchema = z3.object({
+  tools: z3.array(z3.string().min(1)).min(1),
+  scope: z3.literal("project"),
+  /** 비모노레포 단일 preset */
+  preset: z3.string().min(1).optional(),
+  /** 모노레포: workspace path → { preset, rules } */
+  workspaces: z3.record(z3.string(), WorkspaceEntrySchema).optional(),
+  installed_rules: z3.array(z3.string().min(1)),
+  /** 실제 디스크에 쓰여진 파일 상대 경로 목록 (uninstall용). 기존 manifest 호환성 위해 optional */
+  installed_files: z3.array(z3.string().min(1)).optional(),
+  /** non-managed 파일에 섹션을 append한 경우 추적 (uninstall 시 섹션만 제거) */
+  appended_files: z3.array(z3.string().min(1)).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 })
+}).strict();
+
+// src/core/loader.ts
+import { readFileSync, readdirSync } from "fs";
+import { resolve } from "path";
+import { parse } from "yaml";
+var sortRulesByPriority = (rules) => [...rules].sort((a, b) => b.priority - a.priority);
+var parseRawPresets = (raw) => Object.entries(raw).map(([id, value]) => PresetSchema.parse({ id, ...value }));
+var excludeRules = (rules, excludeIds) => {
+  const excludeSet = new Set(excludeIds);
+  return rules.filter((r) => !excludeSet.has(r.id));
+};
+var resolvePresetRules = (preset, allRules) => {
+  const resolved = preset.rules.map((ruleId) => {
+    const found = allRules.find((r) => r.id === ruleId);
+    if (!found) throw new Error(`Rule not found: ${ruleId}`);
+    return found;
+  });
+  return sortRulesByPriority(resolved);
+};
+var loadRuleFile = (filePath) => {
+  const raw = readFileSync(filePath, "utf-8");
+  return RuleSchema.parse(parse(raw));
+};
+var loadAllRules = (rulesDir) => {
+  const files = readdirSync(rulesDir).filter((f) => f.endsWith(".yaml")).sort();
+  return files.map((f) => loadRuleFile(resolve(rulesDir, f)));
+};
+var loadPresets = (presetsPath) => {
+  const raw = readFileSync(presetsPath, "utf-8");
+  const data = parse(raw);
+  return parseRawPresets(data);
+};
+
+// src/core/renderer.ts
+import { join } from "path";
+
+// src/core/tool-output.ts
+var GLOBAL_CATEGORIES = ["persona", "communication", "philosophy", "convention", "standard"];
+var CLAUDE_CODE_PATH_GLOBS = {
+  typescript: ["**/*.ts", "**/*.tsx"],
+  "react-typescript": ["**/*.tsx", "**/*.jsx"],
+  nextjs: ["**/app/**", "next.config.*", "**/middleware.ts"],
+  nestjs: ["**/*.module.ts", "**/*.controller.ts", "**/*.service.ts"],
+  "nestjs-graphql": ["**/*.resolver.ts"],
+  graphql: ["**/*.graphql", "**/*.gql"],
+  "prisma-postgresql": ["prisma/**", "**/*.prisma"],
+  "shadcn-ui": ["**/components/ui/**"],
+  flutter: ["lib/**/*.dart"],
+  python: ["**/*.py"],
+  fastapi: ["**/routers/**", "**/main.py"],
+  sqlalchemy: ["**/models/**/*.py", "alembic/**"],
+  "data-pipeline-python": ["**/pipelines/**", "**/etl/**"],
+  "ai-llm-python": ["**/agents/**", "**/chains/**"],
+  "libs-frontend-web": ["**/*.tsx", "**/*.ts"],
+  "libs-frontend-app": ["lib/**/*.dart"],
+  "libs-backend-ts": ["**/*.ts"],
+  "libs-backend-python": ["**/*.py"]
+};
+var TOOL_OUTPUT_MAP = {
+  "claude-code": {
+    mode: "multi-file",
+    rulesDir: ".claude/rules",
+    fileExtension: ".md",
+    // single: path-scoped (paths: frontmatter) / monorepo: hierarchical ({workspace}/CLAUDE.md)
+    contextStrategy: "hybrid"
+  },
+  codex: {
+    mode: "multi-file",
+    dir: "",
+    rootFileName: "AGENTS.md",
+    // global 룰
+    domainFileName: "AGENTS.override.md",
+    // domain 룰 (하위 폴더)
+    contextStrategy: "hierarchical"
+    // 루트 + 하위 폴더 JIT
+  },
+  gemini: {
+    mode: "multi-file",
+    dir: ".gemini",
+    rootFileName: "GEMINI.md",
+    // global 룰
+    domainFileName: "GEMINI.md",
+    // domain 룰 (하위 폴더)
+    contextStrategy: "hierarchical"
+    // 루트 + 하위 폴더 JIT
+  }
+};
+
+// src/core/renderer.ts
+var ruleIdToTitle = (id) => id.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+var renderDecisionTable = (entries) => {
+  const escape = (s) => s.replace(/\|/g, "|");
+  const hasAvoid = entries.some((e) => e.avoid !== void 0);
+  const header = hasAvoid ? "| When | Then | Avoid |\n|------|------|-------|" : "| When | Then |\n|------|------|";
+  const rows = entries.map((e) => {
+    const when = escape(e.when);
+    const then = escape(e.then);
+    if (hasAvoid) {
+      const avoid = e.avoid ? escape(e.avoid) : "";
+      return `| ${when} | ${then} | ${avoid} |`;
+    }
+    return `| ${when} | ${then} |`;
+  });
+  return [header, ...rows].join("\n");
+};
+var renderRuleToMarkdown = (rule) => {
+  const sections = [`# ${ruleIdToTitle(rule.id)}`];
+  if (rule.content.constraints.length > 0) {
+    sections.push("## Constraints");
+    sections.push(rule.content.constraints.map((c) => `- ${c}`).join("\n"));
+  }
+  if (rule.content.guidelines.length > 0) {
+    sections.push("## Guidelines");
+    sections.push(rule.content.guidelines.map((g) => `- ${g}`).join("\n"));
+  }
+  if (rule.content.decision_table && rule.content.decision_table.length > 0) {
+    sections.push("## Decision Table");
+    sections.push(renderDecisionTable(rule.content.decision_table));
+  }
+  return sections.join("\n\n");
+};
+var renderRulesToMarkdown = (rules) => rules.map(renderRuleToMarkdown).join("\n\n---\n\n");
+var isGlobalRule = (rule) => GLOBAL_CATEGORIES.includes(rule.category);
+var partitionRules = (rules) => {
+  const global = [];
+  const domain = [];
+  for (const rule of rules) {
+    if (isGlobalRule(rule)) {
+      global.push(rule);
+    } else {
+      domain.push(rule);
+    }
+  }
+  return { global, domain };
+};
+var renderFrontmatter = (paths) => {
+  const lines = paths.map((p6) => `  - "${p6}"`).join("\n");
+  return `---
+paths:
+${lines}
+---`;
+};
+var renderClaudeCodeRule = (rule) => {
+  const globs = CLAUDE_CODE_PATH_GLOBS[rule.id];
+  if (!isGlobalRule(rule) && globs !== void 0) {
+    return `${renderFrontmatter(globs)}
+
+${renderRuleToMarkdown(rule)}`;
+  }
+  return renderRuleToMarkdown(rule);
+};
+var renderForTool = (toolId, rules, workspaceMappings) => {
+  const config = TOOL_OUTPUT_MAP[toolId];
+  if (toolId === "claude-code") {
+    const { rulesDir, fileExtension } = config;
+    if (!workspaceMappings || workspaceMappings.length === 0) {
+      const files = rules.map((rule) => ({
+        relativePath: join(rulesDir, `${rule.id}${fileExtension}`),
+        content: renderClaudeCodeRule(rule)
+      }));
+      return { tool: "claude-code", files };
+    }
+    const { global: global2, domain: domain2 } = partitionRules(rules);
+    const globalFiles = global2.map((rule) => ({
+      relativePath: join(rulesDir, `${rule.id}${fileExtension}`),
+      content: renderRuleToMarkdown(rule)
+      // global은 frontmatter 불필요
+    }));
+    const workspaceFiles = [];
+    for (const ws of workspaceMappings) {
+      const wsRules = domain2.filter((r) => ws.ruleIds.includes(r.id));
+      if (wsRules.length === 0) continue;
+      workspaceFiles.push({
+        relativePath: join(ws.path, "CLAUDE.md"),
+        content: renderRulesToMarkdown(wsRules)
+      });
+    }
+    return { tool: "claude-code", files: [...globalFiles, ...workspaceFiles] };
+  }
+  const { global, domain } = partitionRules(rules);
+  const rootContent = renderRulesToMarkdown(global);
+  const domainContent = renderRulesToMarkdown(domain);
+  if (toolId === "codex") {
+    return { tool: "codex", rootContent, domainContent };
+  }
+  return { tool: "gemini", rootContent, domainContent };
+};
+
+// src/core/source-hash.ts
+import { createHash } from "crypto";
+import { readFileSync as readFileSync2, readdirSync as readdirSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+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();
+  const contents = files.map((f) => readFileSync2(resolve2(rulesDir, f), "utf-8"));
+  return computeHash(contents);
+};
+var buildManifest = (params) => ManifestSchema.parse({
+  tools: [...params.tools],
+  scope: params.scope,
+  preset: params.preset,
+  workspaces: params.workspaces,
+  installed_rules: [...params.installedRules],
+  installed_files: params.installedFiles ? [...params.installedFiles] : void 0,
+  appended_files: params.appendedFiles && params.appendedFiles.length > 0 ? [...params.appendedFiles] : void 0,
+  sourceHash: params.sourceHash,
+  generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+});
+
+// src/core/managed-header.ts
+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 wrapWithSection = (content, meta) => {
+  const metaLine = `<!-- sourceHash: ${meta.sourceHash} | generatedAt: ${meta.generatedAt} -->`;
+  return `${SECTION_START}
+${metaLine}
+
+${content}
+${SECTION_END}`;
+};
+var hasAiOpsSection = (content) => content.includes(SECTION_START) && content.includes(SECTION_END);
+var stripAiOpsSection = (content) => {
+  const startIdx = content.indexOf(SECTION_START);
+  const endIdx = content.indexOf(SECTION_END);
+  if (startIdx === -1 || endIdx === -1) return content;
+  const before = content.slice(0, startIdx).trimEnd();
+  const after = content.slice(endIdx + SECTION_END.length).trimStart();
+  return before + (after ? "\n\n" + after : "") + "\n";
+};
+var replaceAiOpsSection = (existing, newSection) => {
+  const startIdx = existing.indexOf(SECTION_START);
+  const endIdx = existing.indexOf(SECTION_END);
+  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";
+};
+
+// src/core/manifest-io.ts
+import { mkdirSync, readFileSync as readFileSync3, writeFileSync } from "fs";
+import { dirname, 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";
+var resolveManifestPath = (basePath) => join2(basePath, MANIFEST_FILENAME);
+var readManifest = (manifestPath) => {
+  let raw;
+  try {
+    raw = readFileSync3(manifestPath, "utf-8");
+  } catch {
+    return null;
+  }
+  return parseManifest(raw);
+};
+var writeManifest = (manifestPath, manifest) => {
+  mkdirSync(dirname(manifestPath), { recursive: true });
+  writeFileSync(manifestPath, serializeManifest(manifest), "utf-8");
+};
+
+// src/core/diff.ts
+var computeDiff = (params) => {
+  const { previous, currentRules, currentSourceHash } = 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 };
+};
+
+// src/core/install-plan.ts
+import { join as join3 } from "path";
+var CODEX_PLAN_SECTION = "\n\n---\n\n## Plan\n\nSave plans to `.codex/plans/<timestamp>-<topic>.md` when creating or updating plans in plan mode.";
+var buildInstallPlan = (params) => {
+  const { toolId, renderResult, meta } = params;
+  if (toolId === "claude-code" && renderResult.tool === "claude-code") {
+    return renderResult.files.map(({ relativePath, content }) => ({
+      relativePath,
+      content: wrapWithHeader(content, meta)
+    }));
+  }
+  if (toolId === "codex" && renderResult.tool === "codex" || toolId === "gemini" && renderResult.tool === "gemini") {
+    const config = TOOL_OUTPUT_MAP[toolId];
+    const actions = [];
+    if (renderResult.rootContent) {
+      const rootContent = toolId === "codex" ? renderResult.rootContent + CODEX_PLAN_SECTION : renderResult.rootContent;
+      actions.push({
+        relativePath: join3(config.dir, config.rootFileName),
+        content: wrapWithHeader(rootContent, meta)
+      });
+    }
+    if (renderResult.domainContent) {
+      actions.push({
+        relativePath: join3(config.dir, config.domainFileName),
+        content: wrapWithHeader(renderResult.domainContent, meta)
+      });
+    }
+    return actions;
+  }
+  return [];
+};
+
+// src/core/uninstall-plan.ts
 import { join as join4 } from "path";
-import {
-  loadAllRules,
-  loadPresets,
-  resolvePresetRules,
-  excludeRules,
-  isGlobalRule,
-  partitionRules,
-  renderForTool,
-  renderRulesToMarkdown,
-  buildInstallPlan,
-  buildManifest,
-  computeSourceHash,
-  resolveManifestPath,
-  writeManifest,
-  wrapWithHeader,
-  TOOL_OUTPUT_MAP
-} from "ai-ops-compiler";
+var inferInstalledFiles = (manifest) => {
+  const files = [];
+  const isMonorepo = manifest.workspaces !== void 0;
+  for (const toolId of manifest.tools) {
+    if (toolId === "claude-code") {
+      const config = TOOL_OUTPUT_MAP["claude-code"];
+      for (const ruleId of manifest.installed_rules) {
+        files.push(join4(config.rulesDir, `${ruleId}${config.fileExtension}`));
+      }
+    } else if (toolId === "codex") {
+      const config = TOOL_OUTPUT_MAP["codex"];
+      if (!isMonorepo) {
+        files.push(join4(config.dir, config.rootFileName));
+        files.push(join4(config.dir, config.domainFileName));
+      } else {
+        files.push(join4(config.dir, config.rootFileName));
+        for (const ws of Object.keys(manifest.workspaces ?? {})) {
+          files.push(join4(ws, config.domainFileName));
+        }
+      }
+    } else if (toolId === "gemini") {
+      const config = TOOL_OUTPUT_MAP["gemini"];
+      if (!isMonorepo) {
+        files.push(join4(config.dir, config.rootFileName));
+      } else {
+        files.push(join4(config.dir, config.rootFileName));
+        for (const ws of Object.keys(manifest.workspaces ?? {})) {
+          files.push(join4(ws, config.domainFileName));
+        }
+      }
+    }
+  }
+  return [...new Set(files)];
+};
+
+// 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");
 
 // src/lib/paths.ts
-import { join } from "path";
-import { COMPILER_DATA_DIR } from "ai-ops-compiler";
-var resolveRulesDir = () => join(COMPILER_DATA_DIR, "rules");
-var resolvePresetsPath = () => join(COMPILER_DATA_DIR, "presets.yaml");
+import { join as join5 } from "path";
+var resolveRulesDir = () => join5(COMPILER_DATA_DIR, "rules");
+var resolvePresetsPath = () => join5(COMPILER_DATA_DIR, "presets.yaml");
 var resolveBasePath = () => process.cwd();
 
 // src/lib/workspace.ts
-import { existsSync, readdirSync, statSync } from "fs";
-import { join as join2, resolve } from "path";
+import { existsSync, readdirSync as readdirSync3, statSync } from "fs";
+import { join as join6, resolve as resolve4 } from "path";
 var EXCLUDE_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", ".turbo", ".cache", "coverage"]);
 var isVisibleDir = (basePath, name) => {
   if (name.startsWith(".") || EXCLUDE_DIRS.has(name)) return false;
-  return statSync(resolve(basePath, name)).isDirectory();
+  return statSync(resolve4(basePath, name)).isDirectory();
 };
 var PROJECT_MANIFESTS = [
   "package.json",
@@ -53,20 +452,20 @@ var PROJECT_MANIFESTS = [
   "go.mod"
   // Go
 ];
-var isWorkspaceRoot = (dirPath) => PROJECT_MANIFESTS.some((f) => existsSync(join2(dirPath, f)));
+var isWorkspaceRoot = (dirPath) => PROJECT_MANIFESTS.some((f) => existsSync(join6(dirPath, f)));
 var listWorkspaceCandidates = (basePath) => {
-  const topLevel = readdirSync(basePath).filter((name) => isVisibleDir(basePath, name));
+  const topLevel = readdirSync3(basePath).filter((name) => isVisibleDir(basePath, name));
   const candidates = [];
   for (const dir of topLevel) {
-    const subPath = resolve(basePath, dir);
+    const subPath = resolve4(basePath, dir);
     if (isWorkspaceRoot(subPath)) {
       candidates.push(dir);
     } else {
-      const children = readdirSync(subPath).filter((name) => isVisibleDir(subPath, name));
-      const wsChildren = children.filter((name) => isWorkspaceRoot(resolve(subPath, name)));
+      const children = readdirSync3(subPath).filter((name) => isVisibleDir(subPath, name));
+      const wsChildren = children.filter((name) => isWorkspaceRoot(resolve4(subPath, name)));
       if (wsChildren.length > 0) {
         for (const child of wsChildren) {
-          candidates.push(join2(dir, child));
+          candidates.push(join6(dir, child));
         }
       } else {
         candidates.push(dir);
@@ -77,40 +476,33 @@ var listWorkspaceCandidates = (basePath) => {
 };
 
 // src/lib/install.ts
-import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { dirname, resolve as resolve2 } from "path";
-import {
-  isManagedFile,
-  hasAiOpsSection,
-  wrapWithSection,
-  replaceAiOpsSection,
-  stripManagedHeader
-} from "ai-ops-compiler";
+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) => {
   const written = [];
   const appended = [];
   const skipped = [];
   for (const action of actions) {
-    const absPath = resolve2(basePath, action.relativePath);
+    const absPath = resolve5(basePath, action.relativePath);
     if (existsSync2(absPath)) {
-      const existing = readFileSync(absPath, "utf-8");
+      const existing = readFileSync4(absPath, "utf-8");
       if (isManagedFile(existing)) {
-        writeFileSync(absPath, action.content, "utf-8");
+        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);
-        writeFileSync(absPath, updated, "utf-8");
+        writeFileSync2(absPath, updated, "utf-8");
         appended.push(action.relativePath);
       } else {
         const sectionContent = wrapWithSection(stripManagedHeader(action.content), meta);
         const updated = existing.trimEnd() + "\n\n" + sectionContent + "\n";
-        writeFileSync(absPath, updated, "utf-8");
+        writeFileSync2(absPath, updated, "utf-8");
         appended.push(action.relativePath);
       }
     } else {
-      mkdirSync(dirname(absPath), { recursive: true });
-      writeFileSync(absPath, action.content, "utf-8");
+      mkdirSync2(dirname3(absPath), { recursive: true });
+      writeFileSync2(absPath, action.content, "utf-8");
       written.push(action.relativePath);
     }
   }
@@ -119,8 +511,8 @@ var installFiles = (basePath, actions, meta) => {
 
 // src/lib/gemini-settings.ts
 import * as p from "@clack/prompts";
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { join as join7 } from "path";
 var SETTING_GROUPS = [
   {
     value: "ui",
@@ -179,12 +571,12 @@ var promptGeminiSettings = async () => {
 };
 var installGeminiSettings = (basePath, selectedValues) => {
   if (selectedValues.length === 0) return;
-  const settingsDir = join3(basePath, ".gemini");
-  const settingsPath = join3(settingsDir, "settings.json");
+  const settingsDir = join7(basePath, ".gemini");
+  const settingsPath = join7(settingsDir, "settings.json");
   let existing = {};
   if (existsSync3(settingsPath)) {
     try {
-      existing = JSON.parse(readFileSync2(settingsPath, "utf-8"));
+      existing = JSON.parse(readFileSync5(settingsPath, "utf-8"));
     } catch {
     }
   }
@@ -194,8 +586,8 @@ var installGeminiSettings = (basePath, selectedValues) => {
     if (!group) continue;
     merged = deepMerge(merged, group.patch);
   }
-  mkdirSync2(settingsDir, { recursive: true });
-  writeFileSync2(settingsPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+  mkdirSync3(settingsDir, { recursive: true });
+  writeFileSync3(settingsPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
 };
 
 // src/commands/init.ts
@@ -249,7 +641,7 @@ var installHierarchicalMonorepo = (toolId, mappings, basePath, meta) => {
   const { global } = partitionRules(allRules);
   if (global.length > 0) {
     const rootAction = {
-      relativePath: join4(config.dir, config.rootFileName),
+      relativePath: join8(config.dir, config.rootFileName),
       content: wrapWithHeader(renderRulesToMarkdown(global), meta)
     };
     const r = installFiles(basePath, [rootAction], meta);
@@ -260,7 +652,7 @@ var installHierarchicalMonorepo = (toolId, mappings, basePath, meta) => {
     const { domain } = partitionRules(mapping.finalRules);
     if (domain.length === 0) continue;
     const domainAction = {
-      relativePath: join4(mapping.workspace, config.domainFileName),
+      relativePath: join8(mapping.workspace, config.domainFileName),
       content: wrapWithHeader(renderRulesToMarkdown(domain), meta)
     };
     const r = installFiles(basePath, [domainAction], meta);
@@ -387,25 +779,10 @@ ${allAppended.map((f) => `  ${f}`).join("\n")}`);
 
 // src/commands/update.ts
 import * as p3 from "@clack/prompts";
-import {
-  readManifest,
-  resolveManifestPath as resolveManifestPath2,
-  loadAllRules as loadAllRules2,
-  renderForTool as renderForTool2,
-  buildInstallPlan as buildInstallPlan2,
-  buildManifest as buildManifest2,
-  writeManifest as writeManifest2,
-  computeSourceHash as computeSourceHash2,
-  computeDiff,
-  partitionRules as partitionRules2,
-  renderRulesToMarkdown as renderRulesToMarkdown2,
-  wrapWithHeader as wrapWithHeader2,
-  TOOL_OUTPUT_MAP as TOOL_OUTPUT_MAP2
-} from "ai-ops-compiler";
-import { join as join5 } from "path";
+import { join as join9 } from "path";
 var updateCommand = async (opts) => {
   const basePath = resolveBasePath();
-  const manifestPath = resolveManifestPath2(basePath);
+  const manifestPath = resolveManifestPath(basePath);
   p3.intro("ai-ops update");
   const manifest = readManifest(manifestPath);
   if (!manifest) {
@@ -413,7 +790,7 @@ var updateCommand = async (opts) => {
     process.exit(1);
   }
   const rulesDir = resolveRulesDir();
-  const sourceHash = computeSourceHash2(rulesDir);
+  const sourceHash = computeSourceHash(rulesDir);
   const diffResult = computeDiff({
     previous: manifest,
     currentRules: manifest.installed_rules,
@@ -426,7 +803,7 @@ var updateCommand = async (opts) => {
   }
   const s = p3.spinner();
   s.start("\uADDC\uCE59 \uAC31\uC2E0 \uC911...");
-  const allRules = loadAllRules2(rulesDir);
+  const allRules = loadAllRules(rulesDir);
   const meta = { sourceHash, generatedAt: (/* @__PURE__ */ new Date()).toISOString() };
   const allInstalledFiles = [];
   const allAppended = [];
@@ -441,20 +818,20 @@ var updateCommand = async (opts) => {
           path,
           ruleIds: entry.rules
         }));
-        const renderResult = renderForTool2("claude-code", rulesToInstall, workspaceMappings);
-        const actions = buildInstallPlan2({ toolId: "claude-code", renderResult, meta });
+        const renderResult = renderForTool("claude-code", rulesToInstall, workspaceMappings);
+        const actions = buildInstallPlan({ toolId: "claude-code", renderResult, meta });
         const r = installFiles(basePath, actions, meta);
         allInstalledFiles.push(...r.written);
         allAppended.push(...r.appended);
       } else {
-        const config = TOOL_OUTPUT_MAP2[toolId];
+        const config = TOOL_OUTPUT_MAP[toolId];
         const allInstalledRuleSet = new Set(manifest.installed_rules);
         const allRulesToInstall = allRules.filter((r) => allInstalledRuleSet.has(r.id));
-        const { global } = partitionRules2(allRulesToInstall);
+        const { global } = partitionRules(allRulesToInstall);
         if (global.length > 0) {
           const rootAction = {
-            relativePath: join5(config.dir, config.rootFileName),
-            content: wrapWithHeader2(renderRulesToMarkdown2(global), meta)
+            relativePath: join9(config.dir, config.rootFileName),
+            content: wrapWithHeader(renderRulesToMarkdown(global), meta)
           };
           const r = installFiles(basePath, [rootAction], meta);
           allInstalledFiles.push(...r.written);
@@ -463,11 +840,11 @@ var updateCommand = async (opts) => {
         for (const [ws, entry] of workspaceEntries) {
           const wsRuleSet = new Set(entry.rules);
           const wsRules = allRules.filter((r2) => wsRuleSet.has(r2.id));
-          const { domain } = partitionRules2(wsRules);
+          const { domain } = partitionRules(wsRules);
           if (domain.length === 0) continue;
           const domainAction = {
-            relativePath: join5(ws, config.domainFileName),
-            content: wrapWithHeader2(renderRulesToMarkdown2(domain), meta)
+            relativePath: join9(ws, config.domainFileName),
+            content: wrapWithHeader(renderRulesToMarkdown(domain), meta)
           };
           const r = installFiles(basePath, [domainAction], meta);
           allInstalledFiles.push(...r.written);
@@ -480,14 +857,14 @@ var updateCommand = async (opts) => {
     const rulesToInstall = allRules.filter((r) => installedRuleSet.has(r.id));
     for (const toolIdStr of manifest.tools) {
       const toolId = toolIdStr;
-      const renderResult = renderForTool2(toolId, rulesToInstall);
-      const actions = buildInstallPlan2({ toolId, renderResult, meta });
+      const renderResult = renderForTool(toolId, rulesToInstall);
+      const actions = buildInstallPlan({ toolId, renderResult, meta });
       const r = installFiles(basePath, actions, meta);
       allInstalledFiles.push(...r.written);
       allAppended.push(...r.appended);
     }
   }
-  const newManifest = buildManifest2({
+  const newManifest = buildManifest({
     tools: manifest.tools,
     scope: manifest.scope,
     preset: manifest.preset,
@@ -497,24 +874,23 @@ var updateCommand = async (opts) => {
     appendedFiles: allAppended.length > 0 ? allAppended : manifest.appended_files,
     sourceHash
   });
-  writeManifest2(manifestPath, newManifest);
+  writeManifest(manifestPath, newManifest);
   s.stop("\uADDC\uCE59 \uAC31\uC2E0 \uC644\uB8CC");
   p3.outro("ai-ops update \uC644\uB8CC");
 };
 
 // src/commands/diff.ts
 import * as p4 from "@clack/prompts";
-import { readManifest as readManifest2, resolveManifestPath as resolveManifestPath3, computeSourceHash as computeSourceHash3, computeDiff as computeDiff2 } from "ai-ops-compiler";
 var diffCommand = async () => {
   const basePath = resolveBasePath();
   p4.intro("ai-ops diff");
-  const manifest = readManifest2(resolveManifestPath3(basePath));
+  const manifest = readManifest(resolveManifestPath(basePath));
   if (!manifest) {
     p4.log.error("manifest\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 ai-ops init\uC744 \uC2E4\uD589\uD558\uC138\uC694.");
     process.exit(1);
   }
-  const sourceHash = computeSourceHash3(resolveRulesDir());
-  const result = computeDiff2({
+  const sourceHash = computeSourceHash(resolveRulesDir());
+  const result = computeDiff({
     previous: manifest,
     currentRules: manifest.installed_rules,
     currentSourceHash: sourceHash
@@ -538,28 +914,26 @@ var diffCommand = async () => {
 // src/commands/uninstall.ts
 import * as p5 from "@clack/prompts";
 import { rmSync as rmSync2 } from "fs";
-import { readManifest as readManifest3, resolveManifestPath as resolveManifestPath4, inferInstalledFiles, MANIFEST_FILENAME } from "ai-ops-compiler";
 
 // src/lib/uninstall.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3, rmSync, readdirSync as readdirSync2, writeFileSync as writeFileSync3 } from "fs";
-import { resolve as resolve3, dirname as dirname2 } from "path";
-import { isManagedFile as isManagedFile2, hasAiOpsSection as hasAiOpsSection2, stripAiOpsSection } from "ai-ops-compiler";
+import { existsSync as existsSync4, readFileSync as readFileSync6, rmSync, readdirSync as readdirSync4, writeFileSync as writeFileSync4 } from "fs";
+import { resolve as resolve6, dirname as dirname4 } from "path";
 var removeFiles = (basePath, relativePaths) => {
   const deleted = [];
   const cleaned = [];
   const skipped = [];
   const notFound = [];
   for (const rel of relativePaths) {
-    const absPath = resolve3(basePath, rel);
+    const absPath = resolve6(basePath, rel);
     if (!existsSync4(absPath)) {
       notFound.push(rel);
       continue;
     }
-    const content = readFileSync3(absPath, "utf-8");
-    if (!isManagedFile2(content)) {
-      if (hasAiOpsSection2(content)) {
+    const content = readFileSync6(absPath, "utf-8");
+    if (!isManagedFile(content)) {
+      if (hasAiOpsSection(content)) {
         const stripped = stripAiOpsSection(content);
-        writeFileSync3(absPath, stripped, "utf-8");
+        writeFileSync4(absPath, stripped, "utf-8");
         cleaned.push(rel);
       } else {
         skipped.push(rel);
@@ -574,10 +948,10 @@ var removeFiles = (basePath, relativePaths) => {
 var cleanEmptyDirs = (basePath, dirs) => {
   const removed = [];
   for (const dir of dirs) {
-    const absDir = resolve3(basePath, dir);
+    const absDir = resolve6(basePath, dir);
     if (!existsSync4(absDir)) continue;
     try {
-      const entries = readdirSync2(absDir);
+      const entries = readdirSync4(absDir);
       if (entries.length === 0) {
         rmSync(absDir, { recursive: true });
         removed.push(dir);
@@ -590,7 +964,7 @@ var cleanEmptyDirs = (basePath, dirs) => {
 var collectManagedDirs = (relativePaths) => {
   const dirs = /* @__PURE__ */ new Set();
   for (const rel of relativePaths) {
-    const dir = dirname2(rel);
+    const dir = dirname4(rel);
     if (dir !== ".") {
       dirs.add(dir);
     }
@@ -601,9 +975,9 @@ var collectManagedDirs = (relativePaths) => {
 // src/commands/uninstall.ts
 var uninstallCommand = async () => {
   const basePath = resolveBasePath();
-  const manifestPath = resolveManifestPath4(basePath);
+  const manifestPath = resolveManifestPath(basePath);
   p5.intro("ai-ops uninstall");
-  const manifest = readManifest3(manifestPath);
+  const manifest = readManifest(manifestPath);
   if (!manifest) {
     p5.log.error("manifest\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 ai-ops init\uC744 \uC2E4\uD589\uD558\uC138\uC694.");
     process.exit(1);