kirograph 0.27.1 → 0.28.0

package/dist/mcp/handlers/core.js

@@ -0,0 +1,611 @@
+"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 core_exports = {};
+__export(core_exports, {
+  handleCore: () => handleCore
+});
+module.exports = __toCommonJS(core_exports);
+var import_utils = require("./utils");
+async function handleCore(toolName, args, cg) {
+  switch (toolName) {
+    case "kirograph_search": {
+      const limit = (0, import_utils.clampLimit)(args.limit, 10);
+      const mode = args.mode ?? "name";
+      let nodes;
+      if (mode === "similar") {
+        nodes = cg.getDatabase().searchNodesByName(
+          args.query,
+          { kinds: args.kind ? [args.kind] : void 0, limit }
+        );
+      } else {
+        nodes = cg.searchNodes(args.query, args.kind, limit).map((r) => r.node);
+      }
+      if (nodes.length === 0) return `No symbols found matching "${args.query}".`;
+      return nodes.map(
+        (n) => `${(0, import_utils.mapKind)(n.kind)} ${n.name}
+  File: ${n.filePath}:${n.startLine}
+  Qualified: ${n.qualifiedName}`
+      ).join("\n\n");
+    }
+    case "kirograph_context": {
+      const detail = args.detail ?? (args.includeCode === false ? "summary" : "full");
+      const ctx = await cg.buildContext(args.task, {
+        maxNodes: args.maxNodes ?? 20,
+        includeCode: detail === "full"
+      });
+      const lines = [ctx.summary, ""];
+      if (ctx.entryPoints.length === 0) {
+        lines.push("No matching symbols found. If this is a new feature, consider using kirograph_files to explore the codebase structure.");
+      } else {
+        lines.push("## Entry Points");
+        for (const n of ctx.entryPoints) {
+          lines.push(`- ${(0, import_utils.mapKind)(n.kind)} \`${n.name}\` \u2014 ${n.filePath}:${n.startLine}`);
+          if (detail === "full" && ctx.codeSnippets.has(n.id)) {
+            lines.push("```", ctx.codeSnippets.get(n.id), "```");
+          } else if (detail === "signatures") {
+            if (n.signature) lines.push(`  Signature: ${n.signature}`);
+            if (n.docstring) lines.push(`  Docs: ${n.docstring}`);
+          }
+        }
+        if (ctx.relatedNodes.length > 0) {
+          lines.push("", "## Related Symbols");
+          for (const n of ctx.relatedNodes.slice(0, 10)) {
+            lines.push(`- ${(0, import_utils.mapKind)(n.kind)} \`${n.name}\` \u2014 ${n.filePath}:${n.startLine}`);
+          }
+        }
+      }
+      try {
+        const { loadConfig } = await Promise.resolve().then(() => require("../../config.js"));
+        const projectRoot = cg.getProjectRoot();
+        const config = await loadConfig(projectRoot);
+        if (config.enableMemory) {
+          const { MemoryManager } = await Promise.resolve().then(() => require("../../memory/index.js"));
+          const db = cg.getDatabase();
+          db.applyMemorySchema();
+          const mem = new MemoryManager(config, db.getRawDb());
+          mem.initialize();
+          const qualifiedNames = [
+            ...ctx.entryPoints.map((n) => n.qualifiedName),
+            ...ctx.relatedNodes.slice(0, 5).map((n) => n.qualifiedName)
+          ].filter(Boolean);
+          const contextLimit = config.memoryContextLimit ?? 3;
+          const contextThreshold = config.memoryContextThreshold ?? 0.3;
+          let memResults = mem.getLinkedObservations(qualifiedNames, contextLimit, contextThreshold);
+          if (memResults.length === 0) {
+            memResults = (await mem.search(args.task, { limit: contextLimit })).filter((r) => r.score >= contextThreshold);
+          }
+          if (memResults.length > 0) {
+            lines.push("", "## Related Memory");
+            for (const r of memResults.slice(0, contextLimit)) {
+              lines.push(`- [${r.observation.kind}] ${r.observation.content}`);
+            }
+          }
+        }
+      } catch {
+      }
+      try {
+        const projectRoot2 = cg.getProjectRoot();
+        const config2 = await (await Promise.resolve().then(() => require("../../config.js"))).loadConfig(projectRoot2);
+        if (config2.enableDocs && config2.docsContextLimit > 0) {
+          const db2 = cg.getDatabase();
+          db2.applyDocsSchema();
+          const { DocsQueries } = await Promise.resolve().then(() => require("../../docs/queries.js"));
+          const docsQueries = new DocsQueries(db2.getRawDb(), projectRoot2);
+          const qNames = ctx.entryPoints.map((n) => n.qualifiedName).filter(Boolean);
+          if (qNames.length > 0) {
+            const docRefs = docsQueries.getRefs({ qualifiedName: qNames[0] });
+            const additionalRefs = qNames.slice(1, 5).flatMap((qn) => docsQueries.getRefs({ qualifiedName: qn }));
+            const allDocRefs = [...docRefs, ...additionalRefs];
+            const seenSections = /* @__PURE__ */ new Set();
+            const uniqueRefs = allDocRefs.filter((r) => {
+              if (seenSections.has(r.sectionId)) return false;
+              seenSections.add(r.sectionId);
+              return r.confidence >= config2.docsContextThreshold;
+            }).slice(0, config2.docsContextLimit);
+            if (uniqueRefs.length > 0) {
+              lines.push("", "## Related Documentation");
+              for (const ref of uniqueRefs) {
+                const section = docsQueries.getSection(ref.sectionId);
+                if (section) {
+                  const summary = section.section.summary ?? section.section.title;
+                  lines.push(`- [${ref.refType}] ${summary} \u2014 ${section.section.filePath} (ID: ${ref.sectionId})`);
+                }
+              }
+            }
+          }
+        }
+      } catch {
+      }
+      try {
+        const projectRoot3 = cg.getProjectRoot();
+        const config3 = await (await Promise.resolve().then(() => require("../../config.js"))).loadConfig(projectRoot3);
+        if (config3.enableData && config3.dataContextLimit > 0) {
+          const db3 = cg.getDatabase();
+          db3.applyDataSchema();
+          const entryFiles = ctx.entryPoints.map((n) => n.filePath).filter(Boolean);
+          if (entryFiles.length > 0) {
+            const placeholders = entryFiles.map(() => "?").join(", ");
+            const dataRefs = db3.getRawDb().all(
+              `SELECT DISTINCT d.id, d.file_path, d.row_count, d.column_count
+               FROM data_code_refs r JOIN data_datasets d ON r.dataset_id = d.id
+               WHERE r.qualified_name IN (${placeholders})`,
+              entryFiles
+            );
+            if (dataRefs.length > 0) {
+              const { DataQueries } = await Promise.resolve().then(() => require("../../data/queries.js"));
+              const dq = new DataQueries(db3.getRawDb());
+              const limit = config3.dataContextLimit;
+              lines.push("", "## Related Data");
+              for (const ref of dataRefs.slice(0, limit)) {
+                const info = dq.describeDataset(ref.id);
+                if (info) {
+                  const colSummary = info.columns.map((c) => `${c.name}:${c.inferredType}`).join(", ");
+                  lines.push(`- **${ref.id}** (${ref.file_path}) \u2014 ${ref.row_count} rows, ${ref.column_count} cols`);
+                  lines.push(`  Schema: ${colSummary}`);
+                }
+              }
+            }
+          }
+        }
+      } catch {
+      }
+      try {
+        const projectRootSec = cg.getProjectRoot();
+        const configSec = await (await Promise.resolve().then(() => require("../../config.js"))).loadConfig(projectRootSec);
+        if (configSec.enableSecurity) {
+          const dbSec = cg.getDatabase();
+          dbSec.applySecuritySchema();
+          const rawDbSec = dbSec.getRawDb();
+          const contextNodeIds = [
+            ...ctx.entryPoints.map((n) => n.id),
+            ...ctx.relatedNodes.map((n) => n.id)
+          ].filter(Boolean);
+          if (contextNodeIds.length > 0) {
+            const { getSecurityWarningsForNodes, formatSecurityWarnings } = await Promise.resolve().then(() => require("../../security/context-warnings.js"));
+            const warnings = getSecurityWarningsForNodes(rawDbSec, contextNodeIds);
+            if (warnings.length > 0) {
+              const nodeNames = /* @__PURE__ */ new Map();
+              for (const n of ctx.entryPoints) {
+                nodeNames.set(n.id, n.name);
+              }
+              for (const n of ctx.relatedNodes) {
+                nodeNames.set(n.id, n.name);
+              }
+              const secSection = formatSecurityWarnings(warnings, nodeNames);
+              if (secSection) {
+                lines.push(secSection);
+              }
+            }
+          }
+        }
+      } catch {
+      }
+      try {
+        const projectRootPat = cg.getProjectRoot();
+        const configPat = await (await Promise.resolve().then(() => require("../../config.js"))).loadConfig(projectRootPat);
+        if (configPat.enablePatterns) {
+          const dbPat = cg.getDatabase();
+          dbPat.applyPatternsSchema();
+          const rawDbPat = dbPat.getRawDb();
+          const tableExists = rawDbPat.get("SELECT name FROM sqlite_master WHERE type='table' AND name='pattern_matches'");
+          if (tableExists) {
+            const contextFiles = [
+              ...ctx.entryPoints.map((n) => n.filePath),
+              ...ctx.relatedNodes.map((n) => n.filePath)
+            ].filter(Boolean);
+            const uniqueContextFiles = [...new Set(contextFiles)];
+            if (uniqueContextFiles.length > 0) {
+              const placeholders = uniqueContextFiles.map(() => "?").join(",");
+              const patternRows = rawDbPat.all(
+                `SELECT file_path, pattern_id, severity, owasp_category, line FROM pattern_matches WHERE file_path IN (${placeholders}) ORDER BY severity DESC LIMIT 5`,
+                uniqueContextFiles
+              );
+              if (patternRows.length > 0) {
+                const patternWarnings = patternRows.map(
+                  (p) => `- **${p.pattern_id}** [${p.severity.toUpperCase()}/${p.owasp_category}]: ${p.file_path}:${p.line}`
+                ).join("\n");
+                lines.push("", "## \u26A0 Pattern Findings", "", patternWarnings);
+                if (patternRows.length === 5) lines.push("", "More findings \u2014 run `kirograph pattern --list` to see all rules.");
+              }
+            }
+          }
+        }
+      } catch {
+      }
+      const graphTokens = lines.join("\n").length / 4;
+      const uniqueFiles = /* @__PURE__ */ new Set([
+        ...ctx.entryPoints.map((n) => n.filePath),
+        ...ctx.relatedNodes.map((n) => n.filePath)
+      ]);
+      if (uniqueFiles.size > 0) {
+        const naiveTokens = (0, import_utils.estimateFileTokens)(cg.getProjectRoot(), [...uniqueFiles]);
+        if (naiveTokens > 0) {
+          const savingsPct = Math.round((1 - graphTokens / naiveTokens) * 100);
+          if (savingsPct > 0) {
+            lines.push("", `---`, `Context savings: ~${Math.round(graphTokens)} tokens (graph) vs ~${naiveTokens} tokens (full files) \u2014 ${savingsPct}% reduction`);
+          }
+        }
+      }
+      return lines.join("\n");
+    }
+    case "kirograph_callers": {
+      const limit = (0, import_utils.clampLimit)(args.limit, 20);
+      const results = cg.searchNodes(args.symbol, void 0, 5);
+      if (results.length === 0) return `Symbol "${args.symbol}" not found in index.`;
+      const node = results[0].node;
+      const callers = await cg.getCallers(node.id, limit);
+      if (callers.length === 0) return `No callers found for \`${node.name}\`.`;
+      return `Callers of \`${node.name}\`:
+` + callers.map(
+        (n) => `- ${(0, import_utils.mapKind)(n.kind)} \`${n.name}\` \u2014 ${n.filePath}:${n.startLine}`
+      ).join("\n");
+    }
+    case "kirograph_callees": {
+      const limit = (0, import_utils.clampLimit)(args.limit, 20);
+      const results = cg.searchNodes(args.symbol, void 0, 5);
+      if (results.length === 0) return `Symbol "${args.symbol}" not found in index.`;
+      const node = results[0].node;
+      const callees = await cg.getCallees(node.id, limit);
+      if (callees.length === 0) return `\`${node.name}\` doesn't call any indexed symbols.`;
+      return `\`${node.name}\` calls:
+` + callees.map(
+        (n) => `- ${(0, import_utils.mapKind)(n.kind)} \`${n.name}\` \u2014 ${n.filePath}:${n.startLine}`
+      ).join("\n");
+    }
+    case "kirograph_impact": {
+      const results = cg.searchNodes(args.symbol, void 0, 5);
+      if (results.length === 0) return `Symbol "${args.symbol}" not found in index.`;
+      const node = results[0].node;
+      const affected = await cg.getImpactRadius(node.id, args.depth ?? 2);
+      if (affected.length === 0) return `No dependents found for \`${node.name}\`.`;
+      let output = `Changing \`${node.name}\` may affect ${affected.length} symbol(s):
+` + affected.map((n) => `- ${(0, import_utils.mapKind)(n.kind)} \`${n.name}\` \u2014 ${n.filePath}:${n.startLine}`).join("\n");
+      try {
+        const { loadConfig } = await Promise.resolve().then(() => require("../../config.js"));
+        const projectRoot = cg.getProjectRoot();
+        const config = await loadConfig(projectRoot);
+        if (config.enableMemory) {
+          const { MemoryManager } = await Promise.resolve().then(() => require("../../memory/index.js"));
+          const db = cg.getDatabase();
+          db.applyMemorySchema();
+          const mem = new MemoryManager(config, db.getRawDb());
+          mem.initialize();
+          const contextLimit = config.memoryContextLimit ?? 3;
+          const contextThreshold = config.memoryContextThreshold ?? 0.3;
+          const memResults = mem.getLinkedObservations(
+            [node.qualifiedName],
+            contextLimit,
+            contextThreshold
+          );
+          if (memResults.length > 0) {
+            output += "\n\nRelated Memory:";
+            for (const r of memResults) {
+              const age = (0, import_utils.formatAge)(r.observation.createdAt);
+              output += `
+- [${r.observation.kind}] ${r.observation.content} (${age})`;
+            }
+          }
+        }
+      } catch {
+      }
+      try {
+        const rawDbImp = cg.getDatabase().getRawDb();
+        const tableExistsImp = rawDbImp.get("SELECT name FROM sqlite_master WHERE type='table' AND name='pattern_matches'");
+        if (tableExistsImp) {
+          const symNode = rawDbImp.get("SELECT id FROM nodes WHERE name = ? LIMIT 1", [args.symbol]);
+          if (symNode) {
+            const patternMatches = rawDbImp.all(
+              "SELECT pattern_id, severity, line FROM pattern_matches WHERE symbol_node_id = ?",
+              [symNode.id]
+            );
+            if (patternMatches.length > 0) {
+              output += "\n\n\u26A0 This symbol has pattern matches:";
+              for (const pm of patternMatches) {
+                output += `
+  [${pm.severity.toUpperCase()}] ${pm.pattern_id} at line ${pm.line}`;
+              }
+            }
+          }
+        }
+      } catch {
+      }
+      return output;
+    }
+    case "kirograph_node": {
+      let node = null;
+      if (args.qualified) {
+        const row = cg.getDatabase().getRawDb().get(
+          `SELECT * FROM nodes WHERE qualified_name = ? LIMIT 1`,
+          [args.symbol]
+        );
+        if (row) {
+          node = {
+            id: row.id,
+            kind: row.kind,
+            name: row.name,
+            qualifiedName: row.qualified_name,
+            filePath: row.file_path,
+            language: row.language,
+            startLine: row.start_line,
+            endLine: row.end_line,
+            startColumn: row.start_column,
+            endColumn: row.end_column,
+            docstring: row.docstring ?? void 0,
+            signature: row.signature ?? void 0,
+            visibility: row.visibility ?? void 0,
+            isExported: row.is_exported === 1,
+            isAsync: row.is_async === 1,
+            isStatic: row.is_static === 1,
+            isAbstract: row.is_abstract === 1
+          };
+        }
+      } else {
+        const results = cg.searchNodes(args.symbol, void 0, 5);
+        if (results.length > 0) node = results[0].node;
+      }
+      if (!node) return `Symbol "${args.symbol}" not found in index.`;
+      const nodeDetail = args.detail ?? (args.includeCode ? "full" : "summary");
+      const lines = [
+        `${(0, import_utils.mapKind)(node.kind)} \`${node.name}\``,
+        `File: ${node.filePath}:${node.startLine}-${node.endLine}`,
+        `Qualified: ${node.qualifiedName}`
+      ];
+      if (nodeDetail === "signatures" || nodeDetail === "full") {
+        if (node.signature) lines.push(`Signature: ${node.signature}`);
+        if (node.docstring) lines.push(`Docs: ${node.docstring}`);
+      }
+      if (nodeDetail === "full") {
+        const src = cg.getNodeSource(node);
+        if (src) lines.push("", "```", src, "```");
+      }
+      return lines.join("\n");
+    }
+    case "kirograph_status": {
+      const stats = await cg.getStats();
+      const langLine = Object.entries(stats.filesByLanguage).sort((a, b) => b[1] - a[1]).map(([k, v]) => `${k}=${v}`).join(", ");
+      const dbMb = (stats.dbSizeBytes / 1024 / 1024).toFixed(2);
+      const semanticLines = stats.embeddingsEnabled ? [
+        `  Semantic search: enabled`,
+        `  Semantic model:  ${stats.embeddingModel}`,
+        `  Semantic engine: ${stats.semanticEngine === "turboquant" ? `turboquant (${stats.vecIndexCount} entries \xB7 ANN)` : stats.semanticEngine === "turbovec" ? `turbovec (${stats.vecIndexCount} entries \xB7 ${stats.turbovecBits ?? 4} bits \xB7 Rust/SIMD)` : stats.semanticEngine === "sqlite-vec" ? `sqlite-vec (${stats.vecIndexCount} entries in ANN index)` : stats.semanticEngine === "orama" ? `orama hybrid (${stats.vecIndexCount} docs in index)` : stats.semanticEngine === "pglite" ? `pglite+pgvector (${stats.vecIndexCount} rows in DB)` : stats.semanticEngine === "lancedb" ? `lancedb (${stats.vecIndexCount} entries in ANN index)` : stats.semanticEngine === "qdrant" ? `qdrant (${stats.vecIndexCount} points in collection)` : stats.semanticEngine === "typesense" ? `typesense (${stats.vecIndexCount} documents in collection)` : "in-process cosine"}`,
+        `  Embeddings:      ${stats.embeddingCount} / ${stats.embeddableNodeCount || stats.nodes} embeddable symbols`,
+        ...stats.engineFallback ? [`  \u26A0 Engine fallback: ${stats.engineFallback}`] : []
+      ] : [`  Semantic search: disabled`];
+      const frameworkLine = stats.frameworks.length > 0 ? `  Frameworks: ${stats.frameworks.join(", ")}` : `  Frameworks: none detected`;
+      const archLine = stats.architectureEnabled ? stats.architectureStats ? `  Architecture: enabled \u2014 ${stats.architectureStats.packages} packages, ${stats.architectureStats.layers} layers, ${stats.architectureStats.packageDeps} deps` : `  Architecture: enabled (not yet analyzed \u2014 run kirograph index)` : `  Architecture: disabled`;
+      let docsLine = "  Documentation: disabled";
+      try {
+        const { loadConfig: loadCfg } = await Promise.resolve().then(() => require("../../config.js"));
+        const cfg = await loadCfg(cg.getProjectRoot());
+        if (cfg.enableDocs) {
+          const db = cg.getDatabase();
+          db.applyDocsSchema();
+          const rawDb = db.getRawDb();
+          const docFiles = rawDb.get("SELECT COUNT(DISTINCT file_path) as cnt FROM doc_sections")?.cnt ?? 0;
+          const docSections = rawDb.get("SELECT COUNT(*) as cnt FROM doc_sections")?.cnt ?? 0;
+          const docRefs = rawDb.get("SELECT COUNT(*) as cnt FROM doc_code_refs")?.cnt ?? 0;
+          docsLine = `  Documentation: enabled \u2014 ${docFiles} files, ${docSections} sections, ${docRefs} code refs`;
+        }
+      } catch {
+      }
+      let dataLine = "  Data: disabled";
+      try {
+        const { loadConfig: loadCfg2 } = await Promise.resolve().then(() => require("../../config.js"));
+        const cfg2 = await loadCfg2(cg.getProjectRoot());
+        if (cfg2.enableData) {
+          const rawDb2 = cg.getDatabase().getRawDb();
+          cg.getDatabase().applyDataSchema();
+          const datasetCount = rawDb2.get("SELECT COUNT(*) as cnt FROM data_datasets")?.cnt ?? 0;
+          if (datasetCount > 0) {
+            const totalRows = rawDb2.get("SELECT SUM(row_count) as total FROM data_datasets")?.total ?? 0;
+            const totalCols = rawDb2.get("SELECT SUM(column_count) as total FROM data_datasets")?.total ?? 0;
+            const totalSize = rawDb2.get("SELECT SUM(file_size) as total FROM data_datasets")?.total ?? 0;
+            const sizeMb = (totalSize / 1024 / 1024).toFixed(2);
+            dataLine = `  Data: enabled \u2014 ${datasetCount} datasets, ${totalRows.toLocaleString()} rows, ${totalCols} columns (${sizeMb} MB source)`;
+          } else {
+            dataLine = `  Data: enabled (no datasets indexed yet \u2014 run kirograph index)`;
+          }
+        }
+      } catch {
+      }
+      let securityLine = "  Security: disabled";
+      try {
+        const { loadConfig: loadCfgSec } = await Promise.resolve().then(() => require("../../config.js"));
+        const cfgSec = await loadCfgSec(cg.getProjectRoot());
+        if (cfgSec.enableSecurity) {
+          const db = cg.getDatabase();
+          db.applySecuritySchema();
+          const rawDb = db.getRawDb();
+          const depCount = rawDb.get("SELECT COUNT(*) as cnt FROM sec_dependencies")?.cnt ?? 0;
+          const vulnCount = rawDb.get("SELECT COUNT(*) as cnt FROM sec_vulnerabilities")?.cnt ?? 0;
+          const affectedCount = rawDb.get("SELECT COUNT(*) as cnt FROM sec_reachability WHERE verdict = 'affected'")?.cnt ?? 0;
+          const staleCount = rawDb.get("SELECT COUNT(*) as cnt FROM sec_dependencies WHERE vuln_data_stale = 1")?.cnt ?? 0;
+          const staleNote = staleCount > 0 ? ` \u26A0 ${staleCount} stale` : "";
+          securityLine = `  Security: enabled \u2014 ${depCount} deps, ${vulnCount} vulns (${affectedCount} affected)${staleNote}`;
+        }
+      } catch {
+      }
+      let patternsLine = "  Patterns: disabled";
+      try {
+        const { loadConfig: loadCfgPat } = await Promise.resolve().then(() => require("../../config.js"));
+        const cfgP = await loadCfgPat(cg.getProjectRoot());
+        if (cfgP.enablePatterns) {
+          const rawDbP = cg.getDatabase().getRawDb();
+          const tableExistsP = rawDbP.get("SELECT name FROM sqlite_master WHERE type='table' AND name='pattern_matches'");
+          if (tableExistsP) {
+            const matchCount = rawDbP.get("SELECT COUNT(*) as cnt FROM pattern_matches")?.cnt ?? 0;
+            const fileCount = rawDbP.get("SELECT COUNT(DISTINCT file_path) as cnt FROM pattern_matches")?.cnt ?? 0;
+            const ruleCount = rawDbP.get("SELECT COUNT(DISTINCT pattern_id) as cnt FROM pattern_matches")?.cnt ?? 0;
+            patternsLine = `  Patterns: enabled \u2014 ${matchCount} matches, ${ruleCount} rules triggered, ${fileCount} files`;
+          } else {
+            patternsLine = `  Patterns: enabled (no data yet \u2014 run kirograph index)`;
+          }
+        }
+      } catch {
+      }
+      const threshold = stats.syncWarningThreshold ?? 10;
+      const pendingFiles = stats.pendingFiles ?? 0;
+      const syncRunning = stats.syncRunning ?? false;
+      const syncLines = [];
+      if (syncRunning) {
+        syncLines.push(`  \u26A0 Sync is currently running in the background.`);
+      }
+      if (threshold > 0 && pendingFiles >= threshold) {
+        syncLines.push(
+          `  \u26A0 Index may be incomplete \u2014 ${pendingFiles} file${pendingFiles !== 1 ? "s" : ""} pending sync.` + (syncRunning ? " Sync is running in background." : " Run `kirograph sync` to update.") + ` Would you like to wait before proceeding?`
+        );
+      }
+      const { TokenTracker } = await Promise.resolve().then(() => require("../../compression/tracker.js"));
+      const tracker = new TokenTracker(cg.getProjectRoot());
+      const gainStats = tracker.getStats("session");
+      const gainLines = [];
+      if (gainStats.totalCommands > 0) {
+        gainLines.push(`  Compression: ${gainStats.totalCommands} commands, ${gainStats.savingsPercent}% avg savings (${gainStats.totalSaved.toLocaleString()} tokens saved this session)`);
+      }
+      return [
+        `KiroGraph Status`,
+        `  Project: ${cg.getProjectRoot()}`,
+        `  Files indexed: ${stats.files}`,
+        `  Symbols: ${stats.nodes}`,
+        `  Relationships: ${stats.edges}`,
+        `  By kind: ${Object.entries(stats.nodesByKind).map(([k, v]) => `${k}=${v}`).join(", ")}`,
+        langLine ? `  By language: ${langLine}` : "",
+        frameworkLine,
+        archLine,
+        docsLine,
+        dataLine,
+        securityLine,
+        patternsLine,
+        `  DB size: ${dbMb} MB`,
+        ...semanticLines,
+        ...syncLines,
+        ...gainLines
+      ].filter(Boolean).join("\n");
+    }
+    case "kirograph_files": {
+      let renderTree2 = function(nodes, prefix) {
+        for (let i = 0; i < nodes.length; i++) {
+          const node = nodes[i];
+          const isLast = i === nodes.length - 1;
+          const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+          const childPrefix = prefix + (isLast ? "    " : "\u2502   ");
+          const meta = includeMetadata && node.type === "file" && node.language ? `  [${node.language}${node.symbolCount ? ` \xB7 ${node.symbolCount} symbols` : ""}]` : "";
+          lines.push(`${prefix}${connector}${node.name}${meta}`);
+          if (node.children?.length) renderTree2(node.children, childPrefix);
+        }
+      };
+      var renderTree = renderTree2;
+      const format = args.format ?? "tree";
+      const includeMetadata = args.includeMetadata !== false;
+      const tree = cg.getFiles({
+        filterPath: args.filterPath,
+        pattern: args.pattern,
+        maxDepth: args.maxDepth
+      });
+      if (format === "flat") {
+        let flattenTree2 = function(nodes) {
+          for (const node of nodes) {
+            if (node.type === "file") {
+              const meta = includeMetadata && node.language ? ` [${node.language}${node.symbolCount ? ` \xB7 ${node.symbolCount}` : ""}]` : "";
+              flat.push(`${node.path}${meta}`);
+            }
+            if (node.children?.length) flattenTree2(node.children);
+          }
+        };
+        var flattenTree = flattenTree2;
+        const flat = [];
+        flattenTree2(tree);
+        return flat.length > 0 ? flat.join("\n") : "No indexed files found.";
+      }
+      if (format === "grouped") {
+        let groupTree2 = function(nodes) {
+          for (const node of nodes) {
+            if (node.type === "file") {
+              const dir = node.path.includes("/") ? node.path.slice(0, node.path.lastIndexOf("/")) : ".";
+              if (!groups.has(dir)) groups.set(dir, []);
+              groups.get(dir).push(node);
+            }
+            if (node.children?.length) groupTree2(node.children);
+          }
+        };
+        var groupTree = groupTree2;
+        const groups = /* @__PURE__ */ new Map();
+        groupTree2(tree);
+        const lines2 = [];
+        for (const [dir, files] of [...groups.entries()].sort()) {
+          lines2.push(`${dir}/`);
+          for (const f of files) {
+            const meta = includeMetadata && f.language ? ` [${f.language}${f.symbolCount ? ` \xB7 ${f.symbolCount}` : ""}]` : "";
+            lines2.push(`  ${f.name}${meta}`);
+          }
+        }
+        return lines2.length > 0 ? lines2.join("\n") : "No indexed files found.";
+      }
+      if (format === "compact") {
+        let compactTree2 = function(nodes) {
+          for (const node of nodes) {
+            if (node.type === "file") {
+              const dir = node.path.includes("/") ? node.path.slice(0, node.path.lastIndexOf("/")) : ".";
+              const stat = dirStats.get(dir) || { files: 0, symbols: 0, langs: /* @__PURE__ */ new Map() };
+              stat.files++;
+              stat.symbols += node.symbolCount || 0;
+              if (node.language) stat.langs.set(node.language, (stat.langs.get(node.language) || 0) + 1);
+              dirStats.set(dir, stat);
+            }
+            if (node.children?.length) compactTree2(node.children);
+          }
+        };
+        var compactTree = compactTree2;
+        const dirStats = /* @__PURE__ */ new Map();
+        compactTree2(tree);
+        const totalFiles = [...dirStats.values()].reduce((s, d) => s + d.files, 0);
+        const totalSymbols = [...dirStats.values()].reduce((s, d) => s + d.symbols, 0);
+        const lines2 = [`${totalFiles} files, ${totalSymbols} symbols in ${dirStats.size} directories:
+`];
+        for (const [dir, stat] of [...dirStats.entries()].sort()) {
+          const langSummary = [...stat.langs.entries()].map(([l, c]) => `${l}:${c}`).join(" ");
+          lines2.push(`${dir}/ (${stat.files} files, ${stat.symbols} symbols) ${langSummary}`);
+        }
+        return lines2.join("\n");
+      }
+      const lines = [];
+      renderTree2(tree, "");
+      return lines.length > 0 ? lines.join("\n") : "No indexed files found.";
+    }
+    case "kirograph_affected": {
+      const files = args.files ?? [];
+      if (files.length === 0) return 'No files provided. Pass file paths in the "files" array.';
+      const affected = cg.getAffectedTests(files, {
+        depth: args.depth ?? 5,
+        testPattern: args.testPattern
+      });
+      if (affected.length === 0) return `No affected test files found for the provided ${files.length} changed file(s).`;
+      return `Affected test files (${affected.length}) for ${files.length} changed file(s):
+
+` + affected.map((f) => `- ${f}`).join("\n");
+    }
+    default:
+      return `Unknown tool: ${toolName}`;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handleCore
+});
+//# sourceMappingURL=core.js.map