kirograph 0.13.0 → 0.13.1

package/dist/bin/installer/mcp.js

@@ -31,46 +31,16 @@ __export(mcp_exports, {
   writeMcpConfig: () => writeMcpConfig
 });
 module.exports = __toCommonJS(mcp_exports);
-var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
-function ensureDir(p) {
-  fs.mkdirSync(p, { recursive: true });
-}
-function readJson(p) {
-  try {
-    return JSON.parse(fs.readFileSync(p, "utf8"));
-  } catch {
-    return {};
-  }
-}
-function writeJson(p, data) {
-  fs.writeFileSync(p, JSON.stringify(data, null, 2) + "\n");
-}
+var import_common = require("./common");
 function writeMcpConfig(kiroDir) {
   const mcpPath = path.join(kiroDir, "settings", "mcp.json");
-  ensureDir(path.dirname(mcpPath));
-  const existing = readJson(mcpPath);
-  existing.mcpServers = existing.mcpServers ?? {};
-  existing.mcpServers.kirograph = {
-    command: "kirograph",
-    args: ["serve", "--mcp"],
+  (0, import_common.writeMcpServersConfig)(mcpPath, {
+    command: import_common.KIROGRAPH_COMMAND,
+    args: import_common.KIROGRAPH_MCP_ARGS,
     disabled: false,
-    autoApprove: [
-      "kirograph_search",
-      "kirograph_context",
-      "kirograph_callers",
-      "kirograph_callees",
-      "kirograph_impact",
-      "kirograph_node",
-      "kirograph_status",
-      "kirograph_files",
-      "kirograph_dead_code",
-      "kirograph_circular_deps",
-      "kirograph_path",
-      "kirograph_type_hierarchy"
-    ]
-  };
-  writeJson(mcpPath, existing);
+    autoApprove: import_common.KIROGRAPH_TOOLS
+  });
   console.log(`  \u2713 MCP server registered in ${mcpPath}`);
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/bin/installer/mcp.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/bin/installer/mcp.ts"],
-  "sourcesContent": ["/**\n * KiroGraph Installer \u2014 MCP server registration\n */\n\nimport * as fs from 'fs';\nimport * as path from 'path';\n\nfunction ensureDir(p: string): void {\n  fs.mkdirSync(p, { recursive: true });\n}\n\nfunction readJson(p: string): any {\n  try { return JSON.parse(fs.readFileSync(p, 'utf8')); } catch { return {}; }\n}\n\nfunction writeJson(p: string, data: unknown): void {\n  fs.writeFileSync(p, JSON.stringify(data, null, 2) + '\\n');\n}\n\nexport function writeMcpConfig(kiroDir: string): void {\n  const mcpPath = path.join(kiroDir, 'settings', 'mcp.json');\n  ensureDir(path.dirname(mcpPath));\n  const existing = readJson(mcpPath);\n  existing.mcpServers = existing.mcpServers ?? {};\n  existing.mcpServers.kirograph = {\n    command: 'kirograph',\n    args: ['serve', '--mcp'],\n    disabled: false,\n    autoApprove: [\n      'kirograph_search',\n      'kirograph_context',\n      'kirograph_callers',\n      'kirograph_callees',\n      'kirograph_impact',\n      'kirograph_node',\n      'kirograph_status',\n      'kirograph_files',\n      'kirograph_dead_code',\n      'kirograph_circular_deps',\n      'kirograph_path',\n      'kirograph_type_hierarchy',\n    ],\n  };\n  writeJson(mcpPath, existing);\n  console.log(`  \u2713 MCP server registered in ${mcpPath}`);\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,SAAoB;AACpB,WAAsB;AAEtB,SAAS,UAAU,GAAiB;AAClC,KAAG,UAAU,GAAG,EAAE,WAAW,KAAK,CAAC;AACrC;AAEA,SAAS,SAAS,GAAgB;AAChC,MAAI;AAAE,WAAO,KAAK,MAAM,GAAG,aAAa,GAAG,MAAM,CAAC;AAAA,EAAG,QAAQ;AAAE,WAAO,CAAC;AAAA,EAAG;AAC5E;AAEA,SAAS,UAAU,GAAW,MAAqB;AACjD,KAAG,cAAc,GAAG,KAAK,UAAU,MAAM,MAAM,CAAC,IAAI,IAAI;AAC1D;AAEO,SAAS,eAAe,SAAuB;AACpD,QAAM,UAAU,KAAK,KAAK,SAAS,YAAY,UAAU;AACzD,YAAU,KAAK,QAAQ,OAAO,CAAC;AAC/B,QAAM,WAAW,SAAS,OAAO;AACjC,WAAS,aAAa,SAAS,cAAc,CAAC;AAC9C,WAAS,WAAW,YAAY;AAAA,IAC9B,SAAS;AAAA,IACT,MAAM,CAAC,SAAS,OAAO;AAAA,IACvB,UAAU;AAAA,IACV,aAAa;AAAA,MACX;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF;AACA,YAAU,SAAS,QAAQ;AAC3B,UAAQ,IAAI,qCAAgC,OAAO,EAAE;AACvD;",
+  "sourcesContent": ["/**\n * KiroGraph Installer \u2014 MCP server registration\n */\n\nimport * as path from 'path';\nimport { KIROGRAPH_COMMAND, KIROGRAPH_MCP_ARGS, KIROGRAPH_TOOLS, writeMcpServersConfig } from './common';\n\nexport function writeMcpConfig(kiroDir: string): void {\n  const mcpPath = path.join(kiroDir, 'settings', 'mcp.json');\n  writeMcpServersConfig(mcpPath, {\n    command: KIROGRAPH_COMMAND,\n    args: KIROGRAPH_MCP_ARGS,\n    disabled: false,\n    autoApprove: KIROGRAPH_TOOLS,\n  });\n  console.log(`  \u2713 MCP server registered in ${mcpPath}`);\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,WAAsB;AACtB,oBAA8F;AAEvF,SAAS,eAAe,SAAuB;AACpD,QAAM,UAAU,KAAK,KAAK,SAAS,YAAY,UAAU;AACzD,2CAAsB,SAAS;AAAA,IAC7B,SAAS;AAAA,IACT,MAAM;AAAA,IACN,UAAU;AAAA,IACV,aAAa;AAAA,EACf,CAAC;AACD,UAAQ,IAAI,qCAAgC,OAAO,EAAE;AACvD;",
   "names": []
 }

package/dist/bin/installer/targets/claude.js

@@ -0,0 +1,79 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var claude_exports = {};
+__export(claude_exports, {
+  installClaudeEarly: () => installClaudeEarly,
+  installClaudeLate: () => installClaudeLate,
+  printClaudeNextSteps: () => printClaudeNextSteps,
+  uninitClaude: () => uninitClaude
+});
+module.exports = __toCommonJS(claude_exports);
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var import_common = require("../common");
+var import_instructions = require("../instructions");
+const CLAUDE_IMPORT = "@.kirograph/claude.md";
+function installClaudeEarly(projectRoot) {
+  const mcpPath = path.join(projectRoot, ".mcp.json");
+  (0, import_common.writeMcpServersConfig)(mcpPath, {
+    command: import_common.KIROGRAPH_COMMAND,
+    args: import_common.KIROGRAPH_MCP_ARGS
+  });
+  console.log(`  \u2713 Claude MCP server registered in ${mcpPath}`);
+}
+function installClaudeLate(projectRoot, cavemanMode) {
+  const instructionsPath = path.join(projectRoot, ".kirograph", "claude.md");
+  (0, import_common.ensureDir)(path.dirname(instructionsPath));
+  fs.writeFileSync(instructionsPath, (0, import_instructions.buildAgentInstructions)(cavemanMode));
+  console.log(`  \u2713 Claude instructions written to ${instructionsPath}`);
+  const memoryPath = path.join(projectRoot, "CLAUDE.md");
+  const changed = (0, import_common.appendImportLine)(memoryPath, CLAUDE_IMPORT, "## KiroGraph");
+  console.log(changed ? `  \u2713 Claude project memory updated in ${memoryPath}` : `  \u2713 Claude project memory already imports ${CLAUDE_IMPORT}`);
+}
+function uninitClaude(projectRoot) {
+  const mcpPath = path.join(projectRoot, ".mcp.json");
+  if ((0, import_common.removeMcpServersConfig)(mcpPath)) {
+    console.log(`  \u2713 Removed kirograph from .mcp.json`);
+  }
+  const memoryPath = path.join(projectRoot, "CLAUDE.md");
+  if ((0, import_common.removeImportLine)(memoryPath, CLAUDE_IMPORT)) {
+    console.log(`  \u2713 Removed KiroGraph import from CLAUDE.md`);
+  }
+}
+function printClaudeNextSteps() {
+  console.log("\n  Done! Restart Claude Code for the MCP server and project memory to load.\n");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  installClaudeEarly,
+  installClaudeLate,
+  printClaudeNextSteps,
+  uninitClaude
+});
+//# sourceMappingURL=claude.js.map

package/dist/bin/installer/targets/claude.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/bin/installer/targets/claude.ts"],
+  "sourcesContent": ["import * as fs from 'fs';\nimport * as path from 'path';\nimport { CavemanMode } from '../caveman';\nimport {\n  appendImportLine,\n  ensureDir,\n  KIROGRAPH_COMMAND,\n  KIROGRAPH_MCP_ARGS,\n  removeMcpServersConfig,\n  removeImportLine,\n  writeMcpServersConfig,\n} from '../common';\nimport { buildAgentInstructions } from '../instructions';\n\nconst CLAUDE_IMPORT = '@.kirograph/claude.md';\n\nexport function installClaudeEarly(projectRoot: string): void {\n  const mcpPath = path.join(projectRoot, '.mcp.json');\n  writeMcpServersConfig(mcpPath, {\n    command: KIROGRAPH_COMMAND,\n    args: KIROGRAPH_MCP_ARGS,\n  });\n  console.log(`  \u2713 Claude MCP server registered in ${mcpPath}`);\n}\n\nexport function installClaudeLate(projectRoot: string, cavemanMode?: CavemanMode | 'off'): void {\n  const instructionsPath = path.join(projectRoot, '.kirograph', 'claude.md');\n  ensureDir(path.dirname(instructionsPath));\n  fs.writeFileSync(instructionsPath, buildAgentInstructions(cavemanMode));\n  console.log(`  \u2713 Claude instructions written to ${instructionsPath}`);\n\n  const memoryPath = path.join(projectRoot, 'CLAUDE.md');\n  const changed = appendImportLine(memoryPath, CLAUDE_IMPORT, '## KiroGraph');\n  console.log(changed\n    ? `  \u2713 Claude project memory updated in ${memoryPath}`\n    : `  \u2713 Claude project memory already imports ${CLAUDE_IMPORT}`);\n}\n\nexport function uninitClaude(projectRoot: string): void {\n  const mcpPath = path.join(projectRoot, '.mcp.json');\n  if (removeMcpServersConfig(mcpPath)) {\n    console.log(`  \u2713 Removed kirograph from .mcp.json`);\n  }\n\n  const memoryPath = path.join(projectRoot, 'CLAUDE.md');\n  if (removeImportLine(memoryPath, CLAUDE_IMPORT)) {\n    console.log(`  \u2713 Removed KiroGraph import from CLAUDE.md`);\n  }\n}\n\nexport function printClaudeNextSteps(): void {\n  console.log('\\n  Done! Restart Claude Code for the MCP server and project memory to load.\\n');\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,SAAoB;AACpB,WAAsB;AAEtB,oBAQO;AACP,0BAAuC;AAEvC,MAAM,gBAAgB;AAEf,SAAS,mBAAmB,aAA2B;AAC5D,QAAM,UAAU,KAAK,KAAK,aAAa,WAAW;AAClD,2CAAsB,SAAS;AAAA,IAC7B,SAAS;AAAA,IACT,MAAM;AAAA,EACR,CAAC;AACD,UAAQ,IAAI,4CAAuC,OAAO,EAAE;AAC9D;AAEO,SAAS,kBAAkB,aAAqB,aAAyC;AAC9F,QAAM,mBAAmB,KAAK,KAAK,aAAa,cAAc,WAAW;AACzE,+BAAU,KAAK,QAAQ,gBAAgB,CAAC;AACxC,KAAG,cAAc,sBAAkB,4CAAuB,WAAW,CAAC;AACtE,UAAQ,IAAI,2CAAsC,gBAAgB,EAAE;AAEpE,QAAM,aAAa,KAAK,KAAK,aAAa,WAAW;AACrD,QAAM,cAAU,gCAAiB,YAAY,eAAe,cAAc;AAC1E,UAAQ,IAAI,UACR,6CAAwC,UAAU,KAClD,kDAA6C,aAAa,EAAE;AAClE;AAEO,SAAS,aAAa,aAA2B;AACtD,QAAM,UAAU,KAAK,KAAK,aAAa,WAAW;AAClD,UAAI,sCAAuB,OAAO,GAAG;AACnC,YAAQ,IAAI,2CAAsC;AAAA,EACpD;AAEA,QAAM,aAAa,KAAK,KAAK,aAAa,WAAW;AACrD,UAAI,gCAAiB,YAAY,aAAa,GAAG;AAC/C,YAAQ,IAAI,kDAA6C;AAAA,EAC3D;AACF;AAEO,SAAS,uBAA6B;AAC3C,UAAQ,IAAI,gFAAgF;AAC9F;",
+  "names": []
+}

package/dist/bin/installer/targets/codex.js

@@ -0,0 +1,77 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var codex_exports = {};
+__export(codex_exports, {
+  installCodexEarly: () => installCodexEarly,
+  installCodexLate: () => installCodexLate,
+  printCodexNextSteps: () => printCodexNextSteps,
+  uninitCodex: () => uninitCodex
+});
+module.exports = __toCommonJS(codex_exports);
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var import_common = require("../common");
+var import_instructions = require("../instructions");
+const CODEX_BLOCK_ID = "codex";
+function installCodexEarly(_projectRoot) {
+}
+function installCodexLate(projectRoot, cavemanMode) {
+  const instructionsPath = path.join(projectRoot, ".kirograph", "codex.md");
+  (0, import_common.ensureDir)(path.dirname(instructionsPath));
+  fs.writeFileSync(instructionsPath, (0, import_instructions.buildAgentInstructions)(cavemanMode));
+  console.log(`  \u2713 Codex instructions written to ${instructionsPath}`);
+  const agentsPath = path.join(projectRoot, "AGENTS.md");
+  const changed = (0, import_common.upsertGeneratedBlock)(agentsPath, CODEX_BLOCK_ID, "## KiroGraph", (0, import_instructions.buildAgentInstructions)(cavemanMode));
+  console.log(changed ? `  \u2713 Codex project instructions updated in ${agentsPath}` : `  \u2713 Codex project instructions already up to date`);
+}
+function uninitCodex(projectRoot) {
+  const agentsPath = path.join(projectRoot, "AGENTS.md");
+  if ((0, import_common.removeGeneratedBlock)(agentsPath, CODEX_BLOCK_ID)) {
+    console.log(`  \u2713 Removed KiroGraph block from AGENTS.md`);
+  }
+}
+function printCodexNextSteps(projectRoot) {
+  const escapedPath = projectRoot.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  console.log("\n  Done! Codex project instructions are installed.");
+  console.log("  Add the MCP server to Codex with:");
+  console.log(`    codex mcp add kirograph -- kirograph serve --mcp --path "${escapedPath}"`);
+  console.log("\n  Or add this to ~/.codex/config.toml:");
+  console.log("    [mcp_servers.kirograph]");
+  console.log('    command = "kirograph"');
+  console.log(`    args = ["serve", "--mcp", "--path", "${escapedPath}"]
+`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  installCodexEarly,
+  installCodexLate,
+  printCodexNextSteps,
+  uninitCodex
+});
+//# sourceMappingURL=codex.js.map

package/dist/bin/installer/targets/codex.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/bin/installer/targets/codex.ts"],
+  "sourcesContent": ["import * as fs from 'fs';\nimport * as path from 'path';\nimport { CavemanMode } from '../caveman';\nimport { ensureDir, removeGeneratedBlock, upsertGeneratedBlock } from '../common';\nimport { buildAgentInstructions } from '../instructions';\n\nconst CODEX_BLOCK_ID = 'codex';\n\nexport function installCodexEarly(_projectRoot: string): void {\n  // Codex MCP config is user-scoped. We print the exact config in next steps\n  // instead of writing outside the project from an installer command.\n}\n\nexport function installCodexLate(projectRoot: string, cavemanMode?: CavemanMode | 'off'): void {\n  const instructionsPath = path.join(projectRoot, '.kirograph', 'codex.md');\n  ensureDir(path.dirname(instructionsPath));\n  fs.writeFileSync(instructionsPath, buildAgentInstructions(cavemanMode));\n  console.log(`  \u2713 Codex instructions written to ${instructionsPath}`);\n\n  const agentsPath = path.join(projectRoot, 'AGENTS.md');\n  const changed = upsertGeneratedBlock(agentsPath, CODEX_BLOCK_ID, '## KiroGraph', buildAgentInstructions(cavemanMode));\n  console.log(changed\n    ? `  \u2713 Codex project instructions updated in ${agentsPath}`\n    : `  \u2713 Codex project instructions already up to date`);\n}\n\nexport function uninitCodex(projectRoot: string): void {\n  const agentsPath = path.join(projectRoot, 'AGENTS.md');\n  if (removeGeneratedBlock(agentsPath, CODEX_BLOCK_ID)) {\n    console.log(`  \u2713 Removed KiroGraph block from AGENTS.md`);\n  }\n}\n\nexport function printCodexNextSteps(projectRoot: string): void {\n  const escapedPath = projectRoot.replace(/\\\\/g, '\\\\\\\\').replace(/\"/g, '\\\\\"');\n  console.log('\\n  Done! Codex project instructions are installed.');\n  console.log('  Add the MCP server to Codex with:');\n  console.log(`    codex mcp add kirograph -- kirograph serve --mcp --path \"${escapedPath}\"`);\n  console.log('\\n  Or add this to ~/.codex/config.toml:');\n  console.log('    [mcp_servers.kirograph]');\n  console.log('    command = \"kirograph\"');\n  console.log(`    args = [\"serve\", \"--mcp\", \"--path\", \"${escapedPath}\"]\\n`);\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,SAAoB;AACpB,WAAsB;AAEtB,oBAAsE;AACtE,0BAAuC;AAEvC,MAAM,iBAAiB;AAEhB,SAAS,kBAAkB,cAA4B;AAG9D;AAEO,SAAS,iBAAiB,aAAqB,aAAyC;AAC7F,QAAM,mBAAmB,KAAK,KAAK,aAAa,cAAc,UAAU;AACxE,+BAAU,KAAK,QAAQ,gBAAgB,CAAC;AACxC,KAAG,cAAc,sBAAkB,4CAAuB,WAAW,CAAC;AACtE,UAAQ,IAAI,0CAAqC,gBAAgB,EAAE;AAEnE,QAAM,aAAa,KAAK,KAAK,aAAa,WAAW;AACrD,QAAM,cAAU,oCAAqB,YAAY,gBAAgB,oBAAgB,4CAAuB,WAAW,CAAC;AACpH,UAAQ,IAAI,UACR,kDAA6C,UAAU,KACvD,wDAAmD;AACzD;AAEO,SAAS,YAAY,aAA2B;AACrD,QAAM,aAAa,KAAK,KAAK,aAAa,WAAW;AACrD,UAAI,oCAAqB,YAAY,cAAc,GAAG;AACpD,YAAQ,IAAI,iDAA4C;AAAA,EAC1D;AACF;AAEO,SAAS,oBAAoB,aAA2B;AAC7D,QAAM,cAAc,YAAY,QAAQ,OAAO,MAAM,EAAE,QAAQ,MAAM,KAAK;AAC1E,UAAQ,IAAI,qDAAqD;AACjE,UAAQ,IAAI,qCAAqC;AACjD,UAAQ,IAAI,gEAAgE,WAAW,GAAG;AAC1F,UAAQ,IAAI,0CAA0C;AACtD,UAAQ,IAAI,6BAA6B;AACzC,UAAQ,IAAI,2BAA2B;AACvC,UAAQ,IAAI,4CAA4C,WAAW;AAAA,CAAM;AAC3E;",
+  "names": []
+}

package/dist/bin/installer/targets/index.js

@@ -0,0 +1,57 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var targets_exports = {};
+__export(targets_exports, {
+  getTargetInstaller: () => getTargetInstaller
+});
+module.exports = __toCommonJS(targets_exports);
+var import_kiro = require("./kiro");
+var import_claude = require("./claude");
+var import_codex = require("./codex");
+function getTargetInstaller(target) {
+  if (target === "claude") {
+    return {
+      label: "Claude Code",
+      installEarly: import_claude.installClaudeEarly,
+      installLate: import_claude.installClaudeLate,
+      printNextSteps: import_claude.printClaudeNextSteps,
+      uninit: import_claude.uninitClaude
+    };
+  }
+  if (target === "codex") {
+    return {
+      label: "Codex",
+      installEarly: import_codex.installCodexEarly,
+      installLate: import_codex.installCodexLate,
+      printNextSteps: import_codex.printCodexNextSteps,
+      uninit: import_codex.uninitCodex
+    };
+  }
+  return {
+    label: "Kiro",
+    installEarly: import_kiro.installKiroEarly,
+    installLate: import_kiro.installKiroLate,
+    printNextSteps: import_kiro.printKiroNextSteps
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getTargetInstaller
+});
+//# sourceMappingURL=index.js.map

package/dist/bin/installer/targets/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/bin/installer/targets/index.ts"],
+  "sourcesContent": ["import type { CavemanMode } from '../caveman';\nimport type { InstallTarget } from '../common';\nimport { installKiroEarly, installKiroLate, printKiroNextSteps } from './kiro';\nimport { installClaudeEarly, installClaudeLate, printClaudeNextSteps, uninitClaude } from './claude';\nimport { installCodexEarly, installCodexLate, printCodexNextSteps, uninitCodex } from './codex';\n\nexport interface TargetInstaller {\n  label: string;\n  installEarly(projectRoot: string): void;\n  installLate(projectRoot: string, cavemanMode?: CavemanMode | 'off'): void;\n  printNextSteps(projectRoot: string): void;\n  uninit?(projectRoot: string): void;\n}\n\nexport function getTargetInstaller(target: InstallTarget): TargetInstaller {\n  if (target === 'claude') {\n    return {\n      label: 'Claude Code',\n      installEarly: installClaudeEarly,\n      installLate: installClaudeLate,\n      printNextSteps: printClaudeNextSteps,\n      uninit: uninitClaude,\n    };\n  }\n\n  if (target === 'codex') {\n    return {\n      label: 'Codex',\n      installEarly: installCodexEarly,\n      installLate: installCodexLate,\n      printNextSteps: printCodexNextSteps,\n      uninit: uninitCodex,\n    };\n  }\n\n  return {\n    label: 'Kiro',\n    installEarly: installKiroEarly,\n    installLate: installKiroLate,\n    printNextSteps: printKiroNextSteps,\n  };\n}\n\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,kBAAsE;AACtE,oBAA0F;AAC1F,mBAAsF;AAU/E,SAAS,mBAAmB,QAAwC;AACzE,MAAI,WAAW,UAAU;AACvB,WAAO;AAAA,MACL,OAAO;AAAA,MACP,cAAc;AAAA,MACd,aAAa;AAAA,MACb,gBAAgB;AAAA,MAChB,QAAQ;AAAA,IACV;AAAA,EACF;AAEA,MAAI,WAAW,SAAS;AACtB,WAAO;AAAA,MACL,OAAO;AAAA,MACP,cAAc;AAAA,MACd,aAAa;AAAA,MACb,gBAAgB;AAAA,MAChB,QAAQ;AAAA,IACV;AAAA,EACF;AAEA,SAAO;AAAA,IACL,OAAO;AAAA,IACP,cAAc;AAAA,IACd,aAAa;AAAA,IACb,gBAAgB;AAAA,EAClB;AACF;",
+  "names": []
+}

package/dist/bin/installer/targets/kiro.js

@@ -0,0 +1,61 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var kiro_exports = {};
+__export(kiro_exports, {
+  installKiroEarly: () => installKiroEarly,
+  installKiroLate: () => installKiroLate,
+  printKiroNextSteps: () => printKiroNextSteps
+});
+module.exports = __toCommonJS(kiro_exports);
+var path = __toESM(require("path"));
+var import_cli_agent = require("../cli-agent");
+var import_hooks = require("../hooks");
+var import_mcp = require("../mcp");
+var import_steering = require("../steering");
+function installKiroEarly(projectRoot) {
+  const kiroDir = path.join(projectRoot, ".kiro");
+  (0, import_mcp.writeMcpConfig)(kiroDir);
+  (0, import_hooks.writeHooks)(kiroDir);
+}
+function installKiroLate(projectRoot, cavemanMode) {
+  const kiroDir = path.join(projectRoot, ".kiro");
+  (0, import_steering.writeSteering)(kiroDir, cavemanMode);
+  (0, import_cli_agent.writeCliAgent)(kiroDir);
+}
+function printKiroNextSteps() {
+  console.log("\n  Done! Restart Kiro IDE for the MCP server to load.");
+  console.log('  For Kiro CLI, use the "kirograph" agent: kiro-cli --agent kirograph\n');
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  installKiroEarly,
+  installKiroLate,
+  printKiroNextSteps
+});
+//# sourceMappingURL=kiro.js.map

package/dist/bin/installer/targets/kiro.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/bin/installer/targets/kiro.ts"],
+  "sourcesContent": ["import * as path from 'path';\nimport { CavemanMode } from '../caveman';\nimport { writeCliAgent } from '../cli-agent';\nimport { writeHooks } from '../hooks';\nimport { writeMcpConfig } from '../mcp';\nimport { writeSteering } from '../steering';\n\nexport function installKiroEarly(projectRoot: string): void {\n  const kiroDir = path.join(projectRoot, '.kiro');\n  writeMcpConfig(kiroDir);\n  writeHooks(kiroDir);\n}\n\nexport function installKiroLate(projectRoot: string, cavemanMode?: CavemanMode | 'off'): void {\n  const kiroDir = path.join(projectRoot, '.kiro');\n  writeSteering(kiroDir, cavemanMode);\n  writeCliAgent(kiroDir);\n}\n\nexport function printKiroNextSteps(): void {\n  console.log('\\n  Done! Restart Kiro IDE for the MCP server to load.');\n  console.log('  For Kiro CLI, use the \"kirograph\" agent: kiro-cli --agent kirograph\\n');\n}\n\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,WAAsB;AAEtB,uBAA8B;AAC9B,mBAA2B;AAC3B,iBAA+B;AAC/B,sBAA8B;AAEvB,SAAS,iBAAiB,aAA2B;AAC1D,QAAM,UAAU,KAAK,KAAK,aAAa,OAAO;AAC9C,iCAAe,OAAO;AACtB,+BAAW,OAAO;AACpB;AAEO,SAAS,gBAAgB,aAAqB,aAAyC;AAC5F,QAAM,UAAU,KAAK,KAAK,aAAa,OAAO;AAC9C,qCAAc,SAAS,WAAW;AAClC,sCAAc,OAAO;AACvB;AAEO,SAAS,qBAA2B;AACzC,UAAQ,IAAI,wDAAwD;AACpE,UAAQ,IAAI,yEAAyE;AACvF;",
+  "names": []
+}

package/dist/bin/kirograph.js

@@ -56,7 +56,7 @@ process.on("uncaughtException", (err) => {
   process.exit(1);
 });
 const program = new import_commander.Command();
-program.name("kirograph").description("Semantic code knowledge graph for Kiro").version("0.13.0").addHelpCommand(true).hook("preAction", (thisCommand) => {
+program.name("kirograph").description("Semantic code knowledge graph for Kiro").version("0.13.1").addHelpCommand(true).hook("preAction", (thisCommand) => {
   const name = thisCommand.name();
   if (name === "init") (0, import_banner.printBanner)();
 });

package/dist/mcp/tool-names.js

@@ -0,0 +1,48 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tool_names_exports = {};
+__export(tool_names_exports, {
+  KIROGRAPH_TOOL_NAMES: () => KIROGRAPH_TOOL_NAMES
+});
+module.exports = __toCommonJS(tool_names_exports);
+const KIROGRAPH_TOOL_NAMES = [
+  "kirograph_search",
+  "kirograph_context",
+  "kirograph_callers",
+  "kirograph_callees",
+  "kirograph_impact",
+  "kirograph_node",
+  "kirograph_status",
+  "kirograph_files",
+  "kirograph_dead_code",
+  "kirograph_circular_deps",
+  "kirograph_path",
+  "kirograph_architecture",
+  "kirograph_coupling",
+  "kirograph_package",
+  "kirograph_hotspots",
+  "kirograph_surprising",
+  "kirograph_diff",
+  "kirograph_type_hierarchy"
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  KIROGRAPH_TOOL_NAMES
+});
+//# sourceMappingURL=tool-names.js.map

package/dist/mcp/tool-names.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/mcp/tool-names.ts"],
+  "sourcesContent": ["export const KIROGRAPH_TOOL_NAMES = [\n  'kirograph_search',\n  'kirograph_context',\n  'kirograph_callers',\n  'kirograph_callees',\n  'kirograph_impact',\n  'kirograph_node',\n  'kirograph_status',\n  'kirograph_files',\n  'kirograph_dead_code',\n  'kirograph_circular_deps',\n  'kirograph_path',\n  'kirograph_architecture',\n  'kirograph_coupling',\n  'kirograph_package',\n  'kirograph_hotspots',\n  'kirograph_surprising',\n  'kirograph_diff',\n  'kirograph_type_hierarchy',\n];\n\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,MAAM,uBAAuB;AAAA,EAClC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;",
+  "names": []
+}

package/dist/mcp/tools.js

@@ -28,6 +28,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var tools_exports = {};
 __export(tools_exports, {
+  KIROGRAPH_TOOL_NAMES: () => import_tool_names.KIROGRAPH_TOOL_NAMES,
   ToolHandler: () => ToolHandler,
   tools: () => tools
 });
@@ -37,6 +38,7 @@ var path = __toESM(require("path"));
 var crypto = __toESM(require("crypto"));
 var import__ = __toESM(require("../index"));
 var import_errors = require("../errors");
+var import_tool_names = require("./tool-names");
 const MAX_OUTPUT = 15e3;
 function truncate(s) {
   return s.length > MAX_OUTPUT ? s.slice(0, MAX_OUTPUT) + "\n\u2026[truncated]" : s;
@@ -773,6 +775,7 @@ class ToolHandler {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  KIROGRAPH_TOOL_NAMES,
   ToolHandler,
   tools
 });