@plumpslabs/kuma 2.1.3 → 2.1.5

package/dist/chunk-2BFTJMBP.js

@@ -0,0 +1,907 @@
+// src/cli/init.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// src/utils/pathValidator.ts
+import path from "path";
+import fs from "fs";
+function validateFilePath(filePath, projectRoot) {
+  try {
+    const root = projectRoot ?? getProjectRoot();
+    const resolvedRoot = path.resolve(root);
+    const normalizedRoot = path.normalize(resolvedRoot).toLowerCase();
+    let resolvedPath;
+    if (!path.isAbsolute(filePath)) {
+      const cwdPath = path.resolve(process.cwd(), filePath);
+      const normalizedCwdPath = path.normalize(cwdPath).toLowerCase();
+      if (fs.existsSync(cwdPath) && normalizedCwdPath.startsWith(normalizedRoot)) {
+        resolvedPath = cwdPath;
+      } else {
+        resolvedPath = path.resolve(resolvedRoot, filePath);
+      }
+    } else {
+      resolvedPath = path.resolve(resolvedRoot, filePath);
+    }
+    const normalizedPath = path.normalize(resolvedPath).toLowerCase();
+    if (!normalizedPath.startsWith(normalizedRoot)) {
+      return {
+        valid: false,
+        error: new Error(
+          `PATH_TRAVERSAL: Access denied. Path "${filePath}" resolves outside project root "${resolvedRoot}".`
+        )
+      };
+    }
+    if (normalizedPath.includes("..")) {
+      return {
+        valid: false,
+        error: new Error(
+          `PATH_TRAVERSAL: Path traversal detected in "${filePath}". Relative paths with ".." are not allowed.`
+        )
+      };
+    }
+    const blockedPatterns = [
+      "/etc/",
+      "/sys/",
+      "/proc/",
+      "/dev/",
+      "/boot/",
+      "/usr/",
+      "C:\\Windows",
+      "C:\\Program Files",
+      "C:\\Program Files (x86)",
+      "C:\\System32",
+      "~/.ssh",
+      "/root/"
+    ];
+    for (const pattern of blockedPatterns) {
+      if (normalizedPath.includes(pattern.toLowerCase())) {
+        return {
+          valid: false,
+          error: new Error(
+            `PATH_TRAVERSAL: Access to system directory "${pattern}" is blocked.`
+          )
+        };
+      }
+    }
+    try {
+      if (fs.existsSync(resolvedPath)) {
+        const realPath = fs.realpathSync(resolvedPath);
+        const normalizedRealPath = path.normalize(realPath).toLowerCase();
+        if (!normalizedRealPath.startsWith(normalizedRoot)) {
+          return {
+            valid: false,
+            error: new Error(
+              `PATH_TRAVERSAL: Symlink escape detected. Path "${filePath}" resolves to "${realPath}" which is outside project root "${resolvedRoot}".`
+            )
+          };
+        }
+      }
+    } catch {
+    }
+    if (normalizedPath.includes("node_modules")) {
+      return {
+        valid: true,
+        resolvedPath
+        // Warning will be handled by caller
+      };
+    }
+    return { valid: true, resolvedPath };
+  } catch (err) {
+    return {
+      valid: false,
+      error: err instanceof Error ? err : new Error(`Path validation error: ${String(err)}`)
+    };
+  }
+}
+function validateFileExtension(filePath) {
+  const allowedExtensions = [
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".json",
+    ".md",
+    ".css",
+    ".html",
+    ".htm",
+    ".env",
+    ".env.example",
+    ".env.local",
+    ".yml",
+    ".yaml",
+    ".toml",
+    ".svg",
+    ".png",
+    ".jpg",
+    ".gif",
+    ".sh",
+    ".bat",
+    ".ps1",
+    ".sql",
+    ".graphql",
+    ".gql",
+    ".vue",
+    ".svelte",
+    ".astro",
+    ".prisma",
+    ".proto",
+    ".txt",
+    ".log"
+  ];
+  const ext = path.extname(filePath).toLowerCase();
+  return allowedExtensions.includes(ext);
+}
+function getProjectRoot() {
+  return process.env.AGENT_PROJECT_ROOT ?? process.cwd();
+}
+function getBackupPath(filePath, timestamp) {
+  const ts = timestamp ?? Date.now();
+  const root = getProjectRoot();
+  const relativePath = path.relative(root, filePath);
+  return path.join(root, ".agent-backups", String(ts), relativePath);
+}
+function ensureBackupDir() {
+  const root = getProjectRoot();
+  const backupDir = path.join(root, ".agent-backups");
+  if (!fs.existsSync(backupDir)) {
+    fs.mkdirSync(backupDir, { recursive: true });
+  }
+  return backupDir;
+}
+
+// src/cli/init.ts
+var ALL_CONFIG_TYPES = [
+  "claude",
+  "cursor",
+  "windsurf",
+  "copilot",
+  "cline",
+  "aider",
+  "antigravity",
+  "opencode",
+  "codex",
+  "qwen",
+  "kiro",
+  "openclaw",
+  "codewhale"
+];
+var CONFIG_LABELS = {
+  claude: "Claude Code (CLAUDE.md / plugin)",
+  cursor: "Cursor (.cursor/rules/*.mdc)",
+  windsurf: "Windsurf (.windsurfrules)",
+  copilot: "GitHub Copilot Editor (AGENTS.md + Skill)",
+  cline: "Cline (.clinerules/*.md)",
+  aider: "Aider (CONVENTIONS.md via .aider.conf.yml)",
+  antigravity: "Antigravity CLI (.agents/skills/)",
+  opencode: "OpenCode (opencode.json)",
+  codex: "Codex CLI (AGENTS.md + .codex/config.toml)",
+  qwen: "Qwen Code (AGENTS.md + settings.json)",
+  kiro: "Kiro (.kiro/steering/*.md)",
+  openclaw: "OpenClaw (skills/)",
+  codewhale: "CodeWhale (skills/ + .codewhale/mcp.json)"
+};
+function configFilePath(type) {
+  switch (type) {
+    case "claude":
+      return "CLAUDE.md";
+    case "cursor":
+      return ".cursor/rules/kuma.mdc";
+    case "windsurf":
+      return ".windsurfrules";
+    case "copilot":
+      return "AGENTS.md";
+    case "cline":
+      return ".clinerules/kuma.md";
+    case "aider":
+      return "CONVENTIONS.md";
+    case "antigravity":
+      return ".agents/skills/kuma/SKILL.md";
+    case "opencode":
+      return "opencode.json";
+    case "codex":
+      return "AGENTS.md";
+    case "qwen":
+      return "AGENTS.md";
+    case "kiro":
+      return ".kiro/steering/kuma.md";
+    case "openclaw":
+      return "skills/kuma/SKILL.md";
+    case "codewhale":
+      return "skills/kuma/SKILL.md";
+  }
+}
+var BOOTSTRAP_LINES = [
+  "Kuma MCP tools are installed. All behavioral rules are in `.kuma/init.md`.",
+  "**Before coding, call `kuma_init()`** to load project context and session memory.",
+  "Project knowledge persists in `.kuma/memories/*.md` across sessions."
+].join("\n");
+var KUMA_CORE_INSTRUCTIONS = BOOTSTRAP_LINES;
+function claudeTemplate() {
+  return [
+    "# Kuma MCP",
+    "",
+    KUMA_CORE_INSTRUCTIONS,
+    "",
+    "\u{1F4D6} Rules: `.kuma/init.md`",
+    "\u{1F9E0} Memories: `.kuma/memories/*.md`"
+  ].join("\n");
+}
+function cursorRulesTemplate() {
+  return [
+    "---",
+    "description: Kuma MCP \u2014 .kuma/ is the single source of truth",
+    "alwaysApply: true",
+    "---",
+    "",
+    KUMA_CORE_INSTRUCTIONS,
+    "",
+    "\u{1F4D6} Read `.kuma/init.md` for detailed rules."
+  ].join("\n");
+}
+function windsurfRulesTemplate() {
+  return [
+    "# Kuma MCP \u2014 Windsurf",
+    "",
+    KUMA_CORE_INSTRUCTIONS
+  ].join("\n");
+}
+function copilotTemplate() {
+  return [
+    "## Kuma MCP",
+    "",
+    KUMA_CORE_INSTRUCTIONS
+  ].join("\n");
+}
+function clineRulesTemplate() {
+  return [
+    "---",
+    "description: Kuma MCP \u2014 .kuma/ is the single source of truth",
+    "paths:",
+    '  - "*"',
+    "---",
+    "",
+    KUMA_CORE_INSTRUCTIONS,
+    "",
+    "\u{1F4D6} Read `.kuma/init.md` for detailed rules."
+  ].join("\n");
+}
+function aiderTemplate() {
+  return [
+    "# Kuma MCP",
+    "",
+    KUMA_CORE_INSTRUCTIONS
+  ].join("\n");
+}
+function opencodeTemplate() {
+  const config = {
+    $schema: "https://opencode-ai.github.io/schema.json",
+    mcp: {
+      kuma: {
+        type: "local",
+        command: ["npx", "-y", "@plumpslabs/kuma"],
+        enabled: true
+      }
+    },
+    instructions: [".kuma/init.md"]
+  };
+  return JSON.stringify(config, null, 2) + "\n";
+}
+function codexTemplate() {
+  return [
+    "## Kuma MCP",
+    "",
+    KUMA_CORE_INSTRUCTIONS,
+    "",
+    "\u{1F4D6} Rules: `.kuma/init.md`"
+  ].join("\n");
+}
+function codexConfigTomlTemplate() {
+  return [
+    "# Generated by Kuma MCP - https://github.com/plumpslabs/kuma",
+    "# Kuma MCP server config for Codex CLI",
+    "",
+    "[mcp_servers.kuma]",
+    'command = "npx"',
+    'args = ["-y", "@plumpslabs/kuma"]',
+    ""
+  ].join("\n");
+}
+function qwenTemplate() {
+  return [
+    "## Kuma MCP",
+    "",
+    KUMA_CORE_INSTRUCTIONS,
+    "",
+    "\u{1F4D6} Rules: `.kuma/init.md`"
+  ].join("\n");
+}
+function qwenSettingsTemplate() {
+  const config = {
+    mcpServers: {
+      kuma: {
+        command: "npx",
+        args: ["-y", "@plumpslabs/kuma"],
+        env: {}
+      }
+    }
+  };
+  return JSON.stringify(config, null, 2) + "\n";
+}
+function kiroRulesTemplate() {
+  return [
+    "---",
+    "name: kuma-mcp",
+    "description: Kuma MCP \u2014 .kuma/ is the single source of truth",
+    "inclusion: always",
+    "---",
+    "",
+    KUMA_CORE_INSTRUCTIONS,
+    "",
+    "\u{1F4D6} Read `.kuma/init.md` for detailed rules."
+  ].join("\n");
+}
+function openclawSkillTemplate() {
+  return [
+    "---",
+    "name: kuma-mcp",
+    "description: Kuma MCP \u2014 .kuma/ is the single source of truth",
+    "---",
+    "",
+    KUMA_CORE_INSTRUCTIONS,
+    "",
+    "\u{1F4D6} Read `.kuma/init.md` for detailed rules.",
+    "\u{1F9E0} Memories: `.kuma/memories/*.md`"
+  ].join("\n");
+}
+function codewhaleTemplate() {
+  return [
+    "---",
+    "name: kuma-mcp",
+    "description: Kuma MCP \u2014 .kuma/ is the single source of truth",
+    "---",
+    "",
+    KUMA_CORE_INSTRUCTIONS,
+    "",
+    "\u{1F4D6} Read `.kuma/init.md` for detailed rules.",
+    "\u{1F9E0} Memories: `.kuma/memories/*.md`"
+  ].join("\n");
+}
+function antigravitySkillTemplate() {
+  return [
+    "---",
+    "name: kuma-mcp",
+    "description: Kuma MCP \u2014 .kuma/ is the single source of truth",
+    "---",
+    "",
+    KUMA_CORE_INSTRUCTIONS,
+    "",
+    "\u{1F4D6} Read `.kuma/init.md` for detailed rules.",
+    "\u{1F9E0} Memories: `.kuma/memories/*.md`"
+  ].join("\n");
+}
+function antigravityMcpConfigTemplate() {
+  const config = {
+    mcpServers: {
+      kuma: {
+        command: "npx",
+        args: ["-y", "@plumpslabs/kuma"],
+        env: {}
+      }
+    }
+  };
+  return JSON.stringify(config, null, 2) + "\n";
+}
+function generateInitMdContent() {
+  return [
+    "# Kuma Init \u2014 Behavioral Rules",
+    "",
+    "_(Auto-generated by `kuma init` \u2014 edit this file directly to customize rules)_",
+    "",
+    "## Code Search",
+    "",
+    "- Use the **smart_grep** tool to search code \u2014 NOT bash grep/ripgrep manually",
+    "- smart_grep returns line numbers + context, caches results, respects .gitignore",
+    "",
+    "## Reading Code",
+    "",
+    "- Use the **smart_file_picker** tool to read files with smart chunking",
+    "- For large files, use startLine/endLine to read specific ranges",
+    "",
+    "## Editing Code",
+    "",
+    "- Use the **precise_diff_editor** tool to edit files (fuzzy matching + auto-backup)",
+    "- DO NOT create Python/Node scripts to patch files; use precise_diff_editor directly",
+    "- DO NOT use bash sed/cat/awk to modify source files",
+    "",
+    "## Creating Files",
+    "",
+    "- Use the **batch_file_writer** tool to create new files (up to 15 at once)",
+    "- Before creating a file, ask: does this need to exist, or can it merge into an existing module?",
+    "",
+    "## Running Tasks",
+    "",
+    "- Use the **execute_safe_test** tool for test/build/lint/typecheck",
+    "- Always run typecheck after editing TypeScript files",
+    "",
+    "## Code Review",
+    "",
+    "- Use the **code_reviewer** tool after making changes",
+    "- Supports focus: correctness, security, performance, over-engineering",
+    "",
+    "## Session Awareness",
+    "",
+    "- Start each session by calling **kuma_init()** to load context",
+    "- Use **get_session_memory()** to recall what happened before",
+    "- Use **kuma_reflect** / **kuma_guard** to stay on track",
+    "- Use **write_memory()** to persist decisions and glossary terms",
+    "",
+    "## General Rules",
+    "",
+    "- When a tool errors, READ the error carefully before acting",
+    "- After 3+ edits without running tests, stop and verify",
+    "- If a tool fails, check the message \u2014 don't retry blindly",
+    "- Detect conventions first with **project_conventions()**",
+    "",
+    "---",
+    "_Generated by Kuma MCP - https://github.com/plumpslabs/kuma_"
+  ].join("\n");
+}
+var TEMPLATES = {
+  claude: claudeTemplate,
+  cursor: cursorRulesTemplate,
+  windsurf: windsurfRulesTemplate,
+  copilot: copilotTemplate,
+  cline: clineRulesTemplate,
+  aider: aiderTemplate,
+  antigravity: antigravitySkillTemplate,
+  opencode: opencodeTemplate,
+  codex: codexTemplate,
+  qwen: qwenTemplate,
+  kiro: kiroRulesTemplate,
+  openclaw: openclawSkillTemplate,
+  codewhale: codewhaleTemplate
+};
+var APPEND_SEPARATOR = "\n\n---\n_Generated by Kuma MCP - https://github.com/plumpslabs/kuma_\n\n";
+function handleOpencodeSecondary(_root, _results) {
+}
+function handleCodexSecondary(root, results) {
+  const tomlPath = path2.resolve(root, ".codex/config.toml");
+  if (results.some((r) => r.filePath === ".codex/config.toml")) return;
+  try {
+    const dir = path2.dirname(tomlPath);
+    if (!fs2.existsSync(dir)) fs2.mkdirSync(dir, { recursive: true });
+    if (fs2.existsSync(tomlPath)) {
+      const existingContent = fs2.readFileSync(tomlPath, "utf-8");
+      if (existingContent.includes("kuma")) {
+        results.push({ type: "codex", filePath: ".codex/config.toml", action: "skipped" });
+        return;
+      }
+      fs2.writeFileSync(tomlPath, existingContent.trimEnd() + "\n\n" + codexConfigTomlTemplate(), "utf-8");
+      results.push({ type: "codex", filePath: ".codex/config.toml", action: "appended" });
+    } else {
+      fs2.writeFileSync(tomlPath, codexConfigTomlTemplate(), "utf-8");
+      results.push({ type: "codex", filePath: ".codex/config.toml", action: "created" });
+    }
+  } catch (err) {
+    results.push({
+      type: "codex",
+      filePath: ".codex/config.toml",
+      action: "error",
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+function handleQwenSecondary(root, results) {
+  const settingsPath = path2.resolve(root, "settings.json");
+  if (results.some((r) => r.filePath === "settings.json")) return;
+  try {
+    if (fs2.existsSync(settingsPath)) {
+      const existingContent = fs2.readFileSync(settingsPath, "utf-8");
+      if (existingContent.includes("kuma")) {
+        if (!existingContent.includes("_Generated by Kuma MCP_")) {
+          try {
+            const parsed = JSON.parse(existingContent);
+            parsed.mcpServers = parsed.mcpServers || {};
+            if (!parsed.mcpServers.kuma) {
+              parsed.mcpServers.kuma = { command: "npx", args: ["-y", "@plumpslabs/kuma"], env: {} };
+              fs2.writeFileSync(settingsPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+              results.push({ type: "qwen", filePath: "settings.json", action: "appended" });
+              return;
+            }
+          } catch {
+          }
+        }
+        results.push({ type: "qwen", filePath: "settings.json", action: "skipped" });
+        return;
+      }
+      try {
+        const parsed = JSON.parse(existingContent);
+        parsed.mcpServers = parsed.mcpServers || {};
+        if (!parsed.mcpServers.kuma) {
+          parsed.mcpServers.kuma = { command: "npx", args: ["-y", "@plumpslabs/kuma"], env: {} };
+          fs2.writeFileSync(settingsPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+          results.push({ type: "qwen", filePath: "settings.json", action: "appended" });
+        }
+      } catch {
+      }
+    } else {
+      fs2.writeFileSync(settingsPath, qwenSettingsTemplate(), "utf-8");
+      results.push({ type: "qwen", filePath: "settings.json", action: "created" });
+    }
+  } catch (err) {
+    results.push({
+      type: "qwen",
+      filePath: "settings.json",
+      action: "error",
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+var AGENTS_MD_TYPES = ["codex", "qwen", "copilot"];
+function getAgentsMdHeader() {
+  return [
+    "# Kuma MCP - Combined Agent Instructions",
+    "",
+    "This file contains instructions for AI coding agents that read AGENTS.md.",
+    "Each section applies to a specific agent. Unused sections can be safely removed.",
+    "",
+    "---",
+    "_Generated by Kuma MCP - https://github.com/plumpslabs/kuma_",
+    ""
+  ].join("\n");
+}
+function getCombinedAgentsMd(selectedTypes) {
+  const sections = [getAgentsMdHeader()];
+  const agentOrder = ["codex", "qwen", "copilot"];
+  for (const t of agentOrder) {
+    if (selectedTypes.has(t)) {
+      sections.push(TEMPLATES[t]());
+    }
+  }
+  return sections.join("\n\n---\n\n");
+}
+function handleAntigravityMcpConfig(root, results) {
+  const mcpPath = path2.resolve(root, ".agents/mcp_config.json");
+  if (results.some((r) => r.filePath === ".agents/mcp_config.json")) return;
+  try {
+    const mcpDir = path2.dirname(mcpPath);
+    if (fs2.existsSync(mcpPath)) {
+      const existingContent = fs2.readFileSync(mcpPath, "utf-8");
+      if (existingContent.includes("kuma")) {
+        if (!existingContent.includes("_Generated by Kuma MCP_")) {
+          const trimmed = existingContent.trimEnd();
+          if (trimmed.endsWith("}")) {
+            const updated = trimmed.slice(0, -1).trimEnd() + ',\n  "_kuma_note": "Kuma MCP - Generated by kuma init"\n}\n';
+            fs2.writeFileSync(mcpPath, updated, "utf-8");
+            results.push({ type: "antigravity", filePath: ".agents/mcp_config.json", action: "appended" });
+          }
+        }
+        return;
+      }
+      const parsed = JSON.parse(existingContent);
+      parsed.mcpServers = parsed.mcpServers || {};
+      parsed.mcpServers.kuma = { command: "npx", args: ["-y", "@plumpslabs/kuma"], env: {} };
+      fs2.writeFileSync(mcpPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+      results.push({ type: "antigravity", filePath: ".agents/mcp_config.json", action: "appended" });
+    } else {
+      if (!fs2.existsSync(mcpDir)) fs2.mkdirSync(mcpDir, { recursive: true });
+      fs2.writeFileSync(mcpPath, antigravityMcpConfigTemplate(), "utf-8");
+      results.push({ type: "antigravity", filePath: ".agents/mcp_config.json", action: "created" });
+    }
+  } catch (err) {
+    results.push({
+      type: "antigravity",
+      filePath: ".agents/mcp_config.json",
+      action: "error",
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+function handleAiderSecondary(root, results) {
+  const ymlPath = path2.resolve(root, ".aider.conf.yml");
+  if (results.some((r) => r.filePath === ".aider.conf.yml")) return;
+  try {
+    const conventionsRef = "read: CONVENTIONS.md";
+    if (fs2.existsSync(ymlPath)) {
+      const existingContent = fs2.readFileSync(ymlPath, "utf-8");
+      if (existingContent.includes("CONVENTIONS.md") || existingContent.includes("kuma")) {
+        results.push({ type: "aider", filePath: ".aider.conf.yml", action: "skipped" });
+        return;
+      }
+      const newContent = existingContent.trimEnd() + "\n\n# Kuma MCP conventions\n" + conventionsRef + "\n";
+      fs2.writeFileSync(ymlPath, newContent, "utf-8");
+      results.push({ type: "aider", filePath: ".aider.conf.yml", action: "appended" });
+    } else {
+      const content = [
+        "# Generated by Kuma MCP - https://github.com/plumpslabs/kuma",
+        "# Aider will read CONVENTIONS.md for coding conventions",
+        "",
+        conventionsRef,
+        ""
+      ].join("\n");
+      fs2.writeFileSync(ymlPath, content, "utf-8");
+      results.push({ type: "aider", filePath: ".aider.conf.yml", action: "created" });
+    }
+  } catch (err) {
+    results.push({
+      type: "aider",
+      filePath: ".aider.conf.yml",
+      action: "error",
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+function handleCopilotSecondary(root, results) {
+  const skillPath = path2.resolve(root, ".github/skills/kuma/SKILL.md");
+  if (results.some((r) => r.filePath === ".github/skills/kuma/SKILL.md")) return;
+  try {
+    const dir = path2.dirname(skillPath);
+    const content = [
+      "---",
+      "name: kuma-mcp",
+      "description: Kuma MCP \u2014 .kuma/ is the single source of truth",
+      "---",
+      "",
+      KUMA_CORE_INSTRUCTIONS,
+      "",
+      "\u{1F4D6} Read `.kuma/init.md` for detailed rules."
+    ].join("\n");
+    if (fs2.existsSync(skillPath)) {
+      const existingContent = fs2.readFileSync(skillPath, "utf-8");
+      if (existingContent.includes("kuma")) {
+        results.push({ type: "copilot", filePath: ".github/skills/kuma/SKILL.md", action: "skipped" });
+        return;
+      }
+      fs2.writeFileSync(skillPath, existingContent.trimEnd() + "\n\n" + content, "utf-8");
+      results.push({ type: "copilot", filePath: ".github/skills/kuma/SKILL.md", action: "appended" });
+    } else {
+      if (!fs2.existsSync(dir)) fs2.mkdirSync(dir, { recursive: true });
+      fs2.writeFileSync(skillPath, content, "utf-8");
+      results.push({ type: "copilot", filePath: ".github/skills/kuma/SKILL.md", action: "created" });
+    }
+  } catch (err) {
+    results.push({
+      type: "copilot",
+      filePath: ".github/skills/kuma/SKILL.md",
+      action: "error",
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+function handleOpenclawSecondary(root, results) {
+  const mcpPath = path2.resolve(root, ".agents/mcp_config.json");
+  if (results.some((r) => r.filePath === ".agents/mcp_config.json")) return;
+  try {
+    const dir = path2.dirname(mcpPath);
+    if (fs2.existsSync(mcpPath)) {
+      const existingContent = fs2.readFileSync(mcpPath, "utf-8");
+      if (existingContent.includes("kuma")) return;
+      const parsed = JSON.parse(existingContent);
+      parsed.mcpServers = parsed.mcpServers || {};
+      parsed.mcpServers.kuma = { command: "npx", args: ["-y", "@plumpslabs/kuma"], env: {} };
+      fs2.writeFileSync(mcpPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+      results.push({ type: "openclaw", filePath: ".agents/mcp_config.json", action: "appended" });
+    } else {
+      if (!fs2.existsSync(dir)) fs2.mkdirSync(dir, { recursive: true });
+      fs2.writeFileSync(mcpPath, antigravityMcpConfigTemplate(), "utf-8");
+      results.push({ type: "openclaw", filePath: ".agents/mcp_config.json", action: "created" });
+    }
+  } catch (err) {
+    results.push({
+      type: "openclaw",
+      filePath: ".agents/mcp_config.json",
+      action: "error",
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+function handleInitMdGeneration(root, results) {
+  const initMdPath = path2.resolve(root, ".kuma/init.md");
+  try {
+    const kumaDir = path2.dirname(initMdPath);
+    if (!fs2.existsSync(kumaDir)) fs2.mkdirSync(kumaDir, { recursive: true });
+    if (fs2.existsSync(initMdPath)) {
+      const existing = fs2.readFileSync(initMdPath, "utf-8");
+      if (existing.includes("_Generated by Kuma MCP_")) {
+        results.push({ type: "claude", filePath: ".kuma/init.md", action: "skipped" });
+        return;
+      }
+      fs2.writeFileSync(initMdPath, existing.trimEnd() + "\n\n" + generateInitMdContent(), "utf-8");
+      results.push({ type: "claude", filePath: ".kuma/init.md", action: "appended" });
+    } else {
+      fs2.writeFileSync(initMdPath, generateInitMdContent(), "utf-8");
+      results.push({ type: "claude", filePath: ".kuma/init.md", action: "created" });
+    }
+  } catch (err) {
+    results.push({
+      type: "claude",
+      filePath: ".kuma/init.md",
+      action: "error",
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+function handleCodewhaleSecondary(root, results) {
+  const mcpPath = path2.resolve(root, ".codewhale/mcp.json");
+  if (results.some((r) => r.filePath === ".codewhale/mcp.json")) return;
+  try {
+    const dir = path2.dirname(mcpPath);
+    if (fs2.existsSync(mcpPath)) {
+      const existingContent = fs2.readFileSync(mcpPath, "utf-8");
+      if (existingContent.includes("kuma")) return;
+      const parsed = JSON.parse(existingContent);
+      parsed.mcpServers = parsed.mcpServers || {};
+      parsed.mcpServers.kuma = { command: "npx", args: ["-y", "@plumpslabs/kuma"], env: {} };
+      fs2.writeFileSync(mcpPath, JSON.stringify(parsed, null, 2) + "\n", "utf-8");
+      results.push({ type: "codewhale", filePath: ".codewhale/mcp.json", action: "appended" });
+    } else {
+      if (!fs2.existsSync(dir)) fs2.mkdirSync(dir, { recursive: true });
+      const config = {
+        mcpServers: {
+          kuma: {
+            command: "npx",
+            args: ["-y", "@plumpslabs/kuma"],
+            env: {}
+          }
+        }
+      };
+      fs2.writeFileSync(mcpPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+      results.push({ type: "codewhale", filePath: ".codewhale/mcp.json", action: "created" });
+    }
+  } catch (err) {
+    results.push({
+      type: "codewhale",
+      filePath: ".codewhale/mcp.json",
+      action: "error",
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+function runInit(options) {
+  const root = options.projectRoot ?? getProjectRoot();
+  const selected = options.types.length > 0 ? options.types : ALL_CONFIG_TYPES;
+  const results = [];
+  handleInitMdGeneration(root, results);
+  const selectedSet = new Set(selected);
+  const agentsMdSelected = AGENTS_MD_TYPES.filter((t) => selectedSet.has(t));
+  let agentsMdHandled = false;
+  for (const type of selected) {
+    const relativePath = configFilePath(type);
+    const fullPath = path2.resolve(root, relativePath);
+    const getTemplate = TEMPLATES[type];
+    try {
+      if (AGENTS_MD_TYPES.includes(type) && !agentsMdHandled) {
+        agentsMdHandled = true;
+        const combinedContent = getCombinedAgentsMd(new Set(agentsMdSelected));
+        if (fs2.existsSync(fullPath)) {
+          if (options.skipExisting) {
+            results.push({ type, filePath: relativePath, action: "skipped" });
+          } else {
+            const existingContent = fs2.readFileSync(fullPath, "utf-8");
+            if (existingContent.includes("_Generated by Kuma MCP_")) {
+              results.push({ type, filePath: relativePath, action: "skipped" });
+            } else {
+              fs2.writeFileSync(fullPath, existingContent.trimEnd() + "\n\n" + combinedContent, "utf-8");
+              results.push({ type, filePath: relativePath, action: "appended" });
+            }
+          }
+        } else {
+          const dir = path2.dirname(fullPath);
+          if (!fs2.existsSync(dir)) fs2.mkdirSync(dir, { recursive: true });
+          fs2.writeFileSync(fullPath, combinedContent, "utf-8");
+          results.push({ type, filePath: relativePath, action: "created" });
+        }
+        if (selectedSet.has("codex")) handleCodexSecondary(root, results);
+        if (selectedSet.has("qwen")) handleQwenSecondary(root, results);
+        if (selectedSet.has("copilot")) handleCopilotSecondary(root, results);
+      } else if (AGENTS_MD_TYPES.includes(type) && agentsMdHandled) {
+        results.push({ type, filePath: relativePath, action: "skipped" });
+        continue;
+      } else {
+        const template = getTemplate();
+        if (fs2.existsSync(fullPath)) {
+          if (options.skipExisting) {
+            results.push({ type, filePath: relativePath, action: "skipped" });
+            continue;
+          }
+          const existingContent = fs2.readFileSync(fullPath, "utf-8");
+          if (existingContent.includes("_Generated by Kuma MCP_")) {
+            if (type === "antigravity") {
+              handleAntigravityMcpConfig(root, results);
+            } else if (type === "openclaw") {
+              handleOpenclawSecondary(root, results);
+            } else if (type === "codewhale") {
+              handleCodewhaleSecondary(root, results);
+            }
+            results.push({ type, filePath: relativePath, action: "skipped" });
+            continue;
+          }
+          const newContent = existingContent.trimEnd() + APPEND_SEPARATOR + template;
+          fs2.writeFileSync(fullPath, newContent, "utf-8");
+          results.push({ type, filePath: relativePath, action: "appended" });
+        } else {
+          const dir = path2.dirname(fullPath);
+          if (!fs2.existsSync(dir)) {
+            fs2.mkdirSync(dir, { recursive: true });
+          }
+          fs2.writeFileSync(fullPath, template, "utf-8");
+          results.push({ type, filePath: relativePath, action: "created" });
+        }
+        if (type === "antigravity") {
+          handleAntigravityMcpConfig(root, results);
+        } else if (type === "openclaw") {
+          handleOpenclawSecondary(root, results);
+        } else if (type === "codewhale") {
+          handleCodewhaleSecondary(root, results);
+        } else if (type === "aider") {
+          handleAiderSecondary(root, results);
+        } else if (type === "opencode") {
+          handleOpencodeSecondary(root, results);
+        }
+      }
+    } catch (err) {
+      results.push({
+        type,
+        filePath: relativePath,
+        action: "error",
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return results;
+}
+function formatInitResults(results) {
+  const lines = [
+    "\u{1F43B} **Kuma Init - AI Agent Config Generator**",
+    ""
+  ];
+  for (const r of results) {
+    const label = CONFIG_LABELS[r.type];
+    switch (r.action) {
+      case "created":
+        lines.push("  \u2705 " + label);
+        lines.push("     \u2192 Created: " + r.filePath);
+        break;
+      case "appended":
+        lines.push("  \u2795 " + label);
+        lines.push("     \u2192 Appended to: " + r.filePath);
+        break;
+      case "skipped":
+        lines.push("  \u23ED " + label);
+        lines.push("     \u2192 Skipped (already has Kuma): " + r.filePath);
+        break;
+      case "error":
+        lines.push("  \u274C " + label);
+        lines.push("     \u2192 Error: " + (r.error ?? "unknown"));
+        break;
+    }
+  }
+  const created = results.filter((r) => r.action === "created").length;
+  const appended = results.filter((r) => r.action === "appended").length;
+  const skipped = results.filter((r) => r.action === "skipped").length;
+  const errors = results.filter((r) => r.action === "error").length;
+  lines.push(
+    "",
+    "\u{1F4CA} Summary: " + created + " created, " + appended + " appended, " + skipped + " skipped, " + errors + " errors",
+    "",
+    "\u{1F4A1} Rules are in `.kuma/init.md` \u2014 single source of truth for all tools.",
+    "\u{1F4A1} Call `kuma_init()` at session start to load project context.",
+    "\u{1F4A1} Run again to generate additional config files anytime."
+  );
+  return lines.join("\n");
+}
+
+export {
+  validateFilePath,
+  validateFileExtension,
+  getProjectRoot,
+  getBackupPath,
+  ensureBackupDir,
+  ALL_CONFIG_TYPES,
+  CONFIG_LABELS,
+  generateInitMdContent,
+  runInit,
+  formatInitResults
+};