kirograph 0.19.0 → 0.20.0

package/dist/mcp/server.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/mcp/server.ts"],
-  "sourcesContent": ["/**\n * KiroGraph MCP Server\n * Implements the Model Context Protocol over stdio.\n */\n\nimport * as path from 'path';\nimport KiroGraph, { findNearestKiroGraphRoot } from '../index';\nimport { StdioTransport, ErrorCodes } from './transport';\nimport { tools, ToolHandler } from './tools';\nimport type { JsonRpcMessage } from './transport';\n\nconst SERVER_INFO = { name: 'kirograph', version: '0.1.0' };\nconst PROTOCOL_VERSION = '2024-11-05';\n\nexport class MCPServer {\n  private transport = new StdioTransport();\n  private cg: KiroGraph | null = null;\n  private toolHandler: ToolHandler;\n  private projectPath: string | null;\n\n  constructor(projectPath?: string) {\n    // Normalize to absolute path immediately to prevent any path traversal\n    this.projectPath = projectPath ? path.resolve(projectPath) : null;\n    this.toolHandler = new ToolHandler(null);\n  }\n\n  async start(): Promise<void> {\n    this.transport.start(this.handleMessage.bind(this));\n    process.on('SIGINT', () => this.stop());\n    process.on('SIGTERM', () => this.stop());\n    process.stdin.on('end', () => this.stop());\n    process.stdin.on('close', () => this.stop());\n  }\n\n  private async tryInit(projectPath: string): Promise<void> {\n    const root = findNearestKiroGraphRoot(projectPath);\n    if (!root) { this.projectPath = projectPath; return; }\n    this.projectPath = root;\n    try {\n      this.cg = await KiroGraph.open(root);\n      this.toolHandler.setDefaultKiroGraph(this.cg);\n    } catch (err) {\n      process.stderr.write(`[KiroGraph MCP] Failed to open ${root}: ${err}\\n`);\n    }\n  }\n\n  private async handleMessage(msg: JsonRpcMessage): Promise<unknown> {\n    const req = msg as any;\n\n    switch (req.method) {\n      case 'initialize': {\n        const rootUri = req.params?.rootUri ?? req.params?.workspaceFolders?.[0]?.uri;\n        if (rootUri) {\n          const p = rootUri.startsWith('file://') ? decodeURIComponent(rootUri.replace(/^file:\\/\\/\\/?/, '')) : rootUri;\n          await this.tryInit(p);\n        } else if (this.projectPath) {\n          await this.tryInit(this.projectPath);\n        }\n        return {\n          protocolVersion: PROTOCOL_VERSION,\n          capabilities: { tools: {} },\n          serverInfo: SERVER_INFO,\n        };\n      }\n\n      case 'tools/list':\n        return { tools };\n\n      case 'tools/call': {\n        const { name, arguments: args = {} } = req.params ?? {};\n        try {\n          return await this.toolHandler.handle(name, args);\n        } catch (err) {\n          return {\n            content: [{ type: 'text', text: `Error: ${err instanceof Error ? err.message : String(err)}` }],\n            isError: true,\n          };\n        }\n      }\n\n      case 'notifications/initialized':\n      case 'ping':\n        return {};\n\n      default:\n        this.transport.sendError(req.id, ErrorCodes.MethodNotFound, `Unknown method: ${req.method}`);\n        return undefined;\n    }\n  }\n\n  private stop(): void {\n    this.cg?.close();\n    this.toolHandler.closeAll();\n    process.exit(0);\n  }\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,WAAsB;AACtB,eAAoD;AACpD,uBAA2C;AAC3C,mBAAmC;AAGnC,MAAM,cAAc,EAAE,MAAM,aAAa,SAAS,QAAQ;AAC1D,MAAM,mBAAmB;AAElB,MAAM,UAAU;AAAA,EAMrB,YAAY,aAAsB;AALlC,SAAQ,YAAY,IAAI,gCAAe;AACvC,SAAQ,KAAuB;AAM7B,SAAK,cAAc,cAAc,KAAK,QAAQ,WAAW,IAAI;AAC7D,SAAK,cAAc,IAAI,yBAAY,IAAI;AAAA,EACzC;AAAA,EAEA,MAAM,QAAuB;AAC3B,SAAK,UAAU,MAAM,KAAK,cAAc,KAAK,IAAI,CAAC;AAClD,YAAQ,GAAG,UAAU,MAAM,KAAK,KAAK,CAAC;AACtC,YAAQ,GAAG,WAAW,MAAM,KAAK,KAAK,CAAC;AACvC,YAAQ,MAAM,GAAG,OAAO,MAAM,KAAK,KAAK,CAAC;AACzC,YAAQ,MAAM,GAAG,SAAS,MAAM,KAAK,KAAK,CAAC;AAAA,EAC7C;AAAA,EAEA,MAAc,QAAQ,aAAoC;AACxD,UAAM,WAAO,mCAAyB,WAAW;AACjD,QAAI,CAAC,MAAM;AAAE,WAAK,cAAc;AAAa;AAAA,IAAQ;AACrD,SAAK,cAAc;AACnB,QAAI;AACF,WAAK,KAAK,MAAM,SAAAA,QAAU,KAAK,IAAI;AACnC,WAAK,YAAY,oBAAoB,KAAK,EAAE;AAAA,IAC9C,SAAS,KAAK;AACZ,cAAQ,OAAO,MAAM,kCAAkC,IAAI,KAAK,GAAG;AAAA,CAAI;AAAA,IACzE;AAAA,EACF;AAAA,EAEA,MAAc,cAAc,KAAuC;AACjE,UAAM,MAAM;AAEZ,YAAQ,IAAI,QAAQ;AAAA,MAClB,KAAK,cAAc;AACjB,cAAM,UAAU,IAAI,QAAQ,WAAW,IAAI,QAAQ,mBAAmB,CAAC,GAAG;AAC1E,YAAI,SAAS;AACX,gBAAM,IAAI,QAAQ,WAAW,SAAS,IAAI,mBAAmB,QAAQ,QAAQ,iBAAiB,EAAE,CAAC,IAAI;AACrG,gBAAM,KAAK,QAAQ,CAAC;AAAA,QACtB,WAAW,KAAK,aAAa;AAC3B,gBAAM,KAAK,QAAQ,KAAK,WAAW;AAAA,QACrC;AACA,eAAO;AAAA,UACL,iBAAiB;AAAA,UACjB,cAAc,EAAE,OAAO,CAAC,EAAE;AAAA,UAC1B,YAAY;AAAA,QACd;AAAA,MACF;AAAA,MAEA,KAAK;AACH,eAAO,EAAE,0BAAM;AAAA,MAEjB,KAAK,cAAc;AACjB,cAAM,EAAE,MAAM,WAAW,OAAO,CAAC,EAAE,IAAI,IAAI,UAAU,CAAC;AACtD,YAAI;AACF,iBAAO,MAAM,KAAK,YAAY,OAAO,MAAM,IAAI;AAAA,QACjD,SAAS,KAAK;AACZ,iBAAO;AAAA,YACL,SAAS,CAAC,EAAE,MAAM,QAAQ,MAAM,UAAU,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG,CAAC,GAAG,CAAC;AAAA,YAC9F,SAAS;AAAA,UACX;AAAA,QACF;AAAA,MACF;AAAA,MAEA,KAAK;AAAA,MACL,KAAK;AACH,eAAO,CAAC;AAAA,MAEV;AACE,aAAK,UAAU,UAAU,IAAI,IAAI,4BAAW,gBAAgB,mBAAmB,IAAI,MAAM,EAAE;AAC3F,eAAO;AAAA,IACX;AAAA,EACF;AAAA,EAEQ,OAAa;AACnB,SAAK,IAAI,MAAM;AACf,SAAK,YAAY,SAAS;AAC1B,YAAQ,KAAK,CAAC;AAAA,EAChB;AACF;",
+  "sourcesContent": ["/**\n * KiroGraph MCP Server\n * Implements the Model Context Protocol over stdio.\n */\n\nimport * as path from 'path';\nimport KiroGraph, { findNearestKiroGraphRoot } from '../index';\nimport { StdioTransport, ErrorCodes } from './transport';\nimport { tools, ToolHandler, LIVE_SEARCH_TOOL_DEFINITION } from './tools';\nimport { PatternRunner } from '../patterns/runner';\nimport type { JsonRpcMessage } from './transport';\n\nconst SERVER_INFO = { name: 'kirograph', version: '0.1.0' };\nconst PROTOCOL_VERSION = '2024-11-05';\n\nexport class MCPServer {\n  private transport = new StdioTransport();\n  private cg: KiroGraph | null = null;\n  private toolHandler: ToolHandler;\n  private projectPath: string | null;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private config: any | null = null;\n\n  constructor(projectPath?: string) {\n    // Normalize to absolute path immediately to prevent any path traversal\n    this.projectPath = projectPath ? path.resolve(projectPath) : null;\n    this.toolHandler = new ToolHandler(null);\n  }\n\n  async start(): Promise<void> {\n    this.transport.start(this.handleMessage.bind(this));\n    process.on('SIGINT', () => this.stop());\n    process.on('SIGTERM', () => this.stop());\n    process.stdin.on('end', () => this.stop());\n    process.stdin.on('close', () => this.stop());\n  }\n\n  private async tryInit(projectPath: string): Promise<void> {\n    const root = findNearestKiroGraphRoot(projectPath);\n    if (!root) { this.projectPath = projectPath; return; }\n    this.projectPath = root;\n    try {\n      this.cg = await KiroGraph.open(root);\n      this.toolHandler.setDefaultKiroGraph(this.cg);\n    } catch (err) {\n      process.stderr.write(`[KiroGraph MCP] Failed to open ${root}: ${err}\\n`);\n    }\n    try {\n      const { loadConfig } = await Promise.resolve().then(() => require('../config.js'));\n      this.config = await loadConfig(root);\n    } catch {\n      // config is optional \u2014 proceed without it\n    }\n  }\n\n  private async handleMessage(msg: JsonRpcMessage): Promise<unknown> {\n    const req = msg as any;\n\n    switch (req.method) {\n      case 'initialize': {\n        const rootUri = req.params?.rootUri ?? req.params?.workspaceFolders?.[0]?.uri;\n        if (rootUri) {\n          const p = rootUri.startsWith('file://') ? decodeURIComponent(rootUri.replace(/^file:\\/\\/\\/?/, '')) : rootUri;\n          await this.tryInit(p);\n        } else if (this.projectPath) {\n          await this.tryInit(this.projectPath);\n        }\n        return {\n          protocolVersion: PROTOCOL_VERSION,\n          capabilities: { tools: {} },\n          serverInfo: SERVER_INFO,\n        };\n      }\n\n      case 'tools/list': {\n        const dynamicTools = [...tools];\n        if (this.config?.enablePatterns && new PatternRunner().isAvailable()) {\n          dynamicTools.push(LIVE_SEARCH_TOOL_DEFINITION);\n        }\n        return { tools: dynamicTools };\n      }\n\n      case 'tools/call': {\n        const { name, arguments: args = {} } = req.params ?? {};\n        try {\n          return await this.toolHandler.handle(name, args);\n        } catch (err) {\n          return {\n            content: [{ type: 'text', text: `Error: ${err instanceof Error ? err.message : String(err)}` }],\n            isError: true,\n          };\n        }\n      }\n\n      case 'notifications/initialized':\n      case 'ping':\n        return {};\n\n      default:\n        this.transport.sendError(req.id, ErrorCodes.MethodNotFound, `Unknown method: ${req.method}`);\n        return undefined;\n    }\n  }\n\n  private stop(): void {\n    this.cg?.close();\n    this.toolHandler.closeAll();\n    process.exit(0);\n  }\n}\n"],
+  "mappings": "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",
   "names": ["KiroGraph"]
 }

package/dist/mcp/tool-names.d.ts

@@ -0,0 +1,2 @@
+export declare const KIROGRAPH_TOOL_NAMES: string[];
+//# sourceMappingURL=tool-names.d.ts.map

package/dist/mcp/tool-names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-names.d.ts","sourceRoot":"","sources":["../../src/mcp/tool-names.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB,UA6DhC,CAAC"}

package/dist/mcp/tool-names.js

@@ -78,7 +78,10 @@ const KIROGRAPH_TOOL_NAMES = [
   "kirograph_security_flows",
   "kirograph_supply_chain",
   "kirograph_dep_confusion",
-  "kirograph_remediation"
+  "kirograph_remediation",
+  "kirograph_pattern_coverage",
+  "kirograph_pattern_save_baseline",
+  "kirograph_pattern_diff"
 ];
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -1,7 +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  'kirograph_exec',\n  'kirograph_gain',\n  'kirograph_read',\n  'kirograph_budget',\n  'kirograph_flows',\n  'kirograph_communities',\n  'kirograph_refactor',\n  'kirograph_mem_search',\n  'kirograph_mem_store',\n  'kirograph_mem_timeline',\n  'kirograph_mem_status',\n  'kirograph_docs_toc',\n  'kirograph_docs_search',\n  'kirograph_docs_section',\n  'kirograph_docs_outline',\n  'kirograph_docs_refs',\n  'kirograph_data_list',\n  'kirograph_data_describe',\n  'kirograph_data_query',\n  'kirograph_data_aggregate',\n  'kirograph_data_search',\n  'kirograph_data_join',\n  'kirograph_data_correlations',\n  'kirograph_data_quality',\n  'kirograph_security',\n  'kirograph_vulns',\n  'kirograph_sbom',\n  'kirograph_vex',\n  'kirograph_reachability',\n  'kirograph_vuln_add',\n  'kirograph_vuln_suppress',\n  'kirograph_staleness',\n  'kirograph_licenses',\n  'kirograph_attack_surface',\n  'kirograph_secrets',\n  'kirograph_security_flows',\n  'kirograph_supply_chain',\n  'kirograph_dep_confusion',\n  'kirograph_remediation',\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;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;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;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;",
+  "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  'kirograph_exec',\n  'kirograph_gain',\n  'kirograph_read',\n  'kirograph_budget',\n  'kirograph_flows',\n  'kirograph_communities',\n  'kirograph_refactor',\n  'kirograph_mem_search',\n  'kirograph_mem_store',\n  'kirograph_mem_timeline',\n  'kirograph_mem_status',\n  'kirograph_docs_toc',\n  'kirograph_docs_search',\n  'kirograph_docs_section',\n  'kirograph_docs_outline',\n  'kirograph_docs_refs',\n  'kirograph_data_list',\n  'kirograph_data_describe',\n  'kirograph_data_query',\n  'kirograph_data_aggregate',\n  'kirograph_data_search',\n  'kirograph_data_join',\n  'kirograph_data_correlations',\n  'kirograph_data_quality',\n  'kirograph_security',\n  'kirograph_vulns',\n  'kirograph_sbom',\n  'kirograph_vex',\n  'kirograph_reachability',\n  'kirograph_vuln_add',\n  'kirograph_vuln_suppress',\n  'kirograph_staleness',\n  'kirograph_licenses',\n  'kirograph_attack_surface',\n  'kirograph_secrets',\n  'kirograph_security_flows',\n  'kirograph_supply_chain',\n  'kirograph_dep_confusion',\n  'kirograph_remediation',\n  'kirograph_pattern_coverage',\n  'kirograph_pattern_save_baseline',\n  'kirograph_pattern_diff',\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;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;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;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;",
   "names": []
 }

package/dist/mcp/tools.d.ts

@@ -2,6 +2,7 @@
  * KiroGraph MCP Tool Definitions + Handlers
  */
 import KiroGraph from '../index';
+export { KIROGRAPH_TOOL_NAMES } from './tool-names';
 export interface ToolDefinition {
     name: string;
     description: string;
@@ -17,13 +18,24 @@ export interface ToolDefinition {
     };
 }
 export declare const tools: ToolDefinition[];
+/**
+ * Dynamic tool definition for kirograph_live_search.
+ * NOT included in the static `tools` array — injected into tools/list at runtime
+ * only when config.enablePatterns === true AND @ast-grep/napi is available.
+ * NOT added to KIROGRAPH_TOOL_NAMES (which is a static list for Kiro autoApprove).
+ */
+export declare const LIVE_SEARCH_TOOL_DEFINITION: ToolDefinition;
 export declare class ToolHandler {
     private defaultCg;
     private connections;
+    /** Anti-loop: track recent data_query calls per dataset for pagination detection. */
+    private queryTracker;
     constructor(cg: KiroGraph | null);
     setDefaultKiroGraph(cg: KiroGraph): void;
     /** Close all cached cross-project connections. */
     closeAll(): void;
+    /** Anti-loop: detect pagination patterns and warn the agent. */
+    private checkPaginationLoop;
     private getConnection;
     handle(toolName: string, args: Record<string, unknown>): Promise<{
         content: Array<{

package/dist/mcp/tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../src/mcp/tools.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,OAAO,SAAuC,MAAM,UAAU,CAAC;AA6B/D,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE;QACX,IAAI,EAAE,QAAQ,CAAC;QACf,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,WAAW,EAAE,MAAM,CAAC;YAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;YAAC,OAAO,CAAC,EAAE,OAAO,CAAA;SAAE,CAAC,CAAC;QACtG,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;KACrB,CAAC;CACH;AAED,eAAO,MAAM,KAAK,EAAE,cAAc,EAsNjC,CAAC;AAEF,qBAAa,WAAW;IACtB,OAAO,CAAC,SAAS,CAAmB;IACpC,OAAO,CAAC,WAAW,CAAgC;gBAEvC,EAAE,EAAE,SAAS,GAAG,IAAI;IAIhC,mBAAmB,CAAC,EAAE,EAAE,SAAS,GAAG,IAAI;IAIxC,kDAAkD;IAClD,QAAQ,IAAI,IAAI;YAOF,aAAa;IAarB,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,KAAK,CAAC;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;YAW/H,QAAQ;CAgavB"}
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../src/mcp/tools.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,OAAO,SAAuC,MAAM,UAAU,CAAC;AAK/D,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAyDpD,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE;QACX,IAAI,EAAE,QAAQ,CAAC;QACf,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,WAAW,EAAE,MAAM,CAAC;YAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;YAAC,OAAO,CAAC,EAAE,OAAO,CAAA;SAAE,CAAC,CAAC;QACtG,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;KACrB,CAAC;CACH;AAED,eAAO,MAAM,KAAK,EAAE,cAAc,EA4xBjC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,EAAE,cAczC,CAAC;AAEF,qBAAa,WAAW;IACtB,OAAO,CAAC,SAAS,CAAmB;IACpC,OAAO,CAAC,WAAW,CAAgC;IACnD,qFAAqF;IACrF,OAAO,CAAC,YAAY,CAA8D;gBAEtE,EAAE,EAAE,SAAS,GAAG,IAAI;IAIhC,mBAAmB,CAAC,EAAE,EAAE,SAAS,GAAG,IAAI;IAIxC,kDAAkD;IAClD,QAAQ,IAAI,IAAI;IAOhB,gEAAgE;IAChE,OAAO,CAAC,mBAAmB;YAiCb,aAAa;IAerB,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,KAAK,CAAC;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;YAoC/H,QAAQ;CA02FvB"}

package/dist/mcp/tools.js

@@ -29,6 +29,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var tools_exports = {};
 __export(tools_exports, {
   KIROGRAPH_TOOL_NAMES: () => import_tool_names.KIROGRAPH_TOOL_NAMES,
+  LIVE_SEARCH_TOOL_DEFINITION: () => LIVE_SEARCH_TOOL_DEFINITION,
   ToolHandler: () => ToolHandler,
   tools: () => tools
 });
@@ -848,8 +849,55 @@ const tools = [
         projectPath: { type: "string", description: "Project root path (optional)" }
       }
     }
+  },
+  // ── Pattern tools (require enablePatterns=true) ─────────────────────────────
+  {
+    name: "kirograph_pattern_coverage",
+    description: "OWASP Top 10 coverage report: shows which vulnerability categories are covered by bundled pattern rules and how many matches exist in each.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectPath: { type: "string", description: "Project root path (optional)" }
+      }
+    }
+  },
+  {
+    name: "kirograph_pattern_save_baseline",
+    description: "Save current pattern match counts as a baseline for future diffing.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        label: { type: "string", description: 'Baseline label (default: "default")', default: "default" },
+        projectPath: { type: "string", description: "Project root path (optional)" }
+      }
+    }
+  },
+  {
+    name: "kirograph_pattern_diff",
+    description: "Diff current pattern matches against a saved baseline. Shows new findings, resolved findings, and unchanged counts.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        label: { type: "string", description: 'Baseline label (default: "default")', default: "default" },
+        projectPath: { type: "string", description: "Project root path (optional)" }
+      }
+    }
   }
 ];
+const LIVE_SEARCH_TOOL_DEFINITION = {
+  name: "kirograph_live_search",
+  description: "Run a live AST pattern search against the indexed file list using @ast-grep/napi. Finds structural code patterns (SQL injection, eval, path traversal, etc.) without needing the codebase to be re-indexed. Only available when enablePatterns: true.",
+  inputSchema: {
+    type: "object",
+    required: ["pattern", "language"],
+    properties: {
+      pattern: { type: "string", description: 'ast-grep inline pattern (e.g. "eval($X)")' },
+      language: { type: "string", description: "Language to search: javascript, typescript, python, go, rust, java, etc." },
+      limit: { type: "number", description: "Max results (default 20, max 100)", default: 20 },
+      projectPath: { type: "string", description: "Project root path (optional)" }
+    }
+  }
+};
 class ToolHandler {
   constructor(cg) {
     this.connections = /* @__PURE__ */ new Map();
@@ -1263,6 +1311,38 @@ ${result.content}`;
           }
         } 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),
@@ -1339,6 +1419,27 @@ ${result.content}`;
           }
         } 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": {
@@ -1423,6 +1524,24 @@ ${result.content}`;
           }
         } 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;
@@ -1454,6 +1573,7 @@ ${result.content}`;
           docsLine,
           dataLine,
           securityLine,
+          patternsLine,
           `  DB size: ${dbMb} MB`,
           ...semanticLines,
           ...syncLines,
@@ -2398,6 +2518,18 @@ ${lines.join("\n")}`;
             lines.push("", `\u26A0 Vulnerability data is ${Math.floor(ageDays)} days old (max: ${maxAge}). Run kirograph vulns --refresh to update.`);
           }
         }
+        try {
+          const rawDbSec = db.getRawDb();
+          const tableExistsSec = rawDbSec.get("SELECT name FROM sqlite_master WHERE type='table' AND name='pattern_matches'");
+          if (tableExistsSec) {
+            const patternCount = rawDbSec.get("SELECT COUNT(*) as cnt FROM pattern_matches")?.cnt ?? 0;
+            if (patternCount > 0) {
+              const critCount = rawDbSec.get("SELECT COUNT(*) as cnt FROM pattern_matches WHERE severity = 'critical'")?.cnt ?? 0;
+              lines.push(`SAST findings: ${patternCount} pattern matches (${critCount} critical)`);
+            }
+          }
+        } catch {
+        }
         return lines.join("\n");
       }
       case "kirograph_vulns": {
@@ -2989,6 +3121,270 @@ ${lines.join("\n")}`;
         }
         return truncate(lines.join("\n"));
       }
+      case "kirograph_live_search": {
+        const { loadConfig } = await Promise.resolve().then(() => require("../config.js"));
+        const projectRoot = cg.getProjectRoot();
+        const config = await loadConfig(projectRoot);
+        if (!config.enablePatterns) {
+          return "kirograph_live_search requires enablePatterns: true in .kirograph/config.json";
+        }
+        const { PatternRunner } = await Promise.resolve().then(() => require("../patterns/runner.js"));
+        const runner = new PatternRunner();
+        if (!runner.isAvailable()) {
+          return "kirograph_live_search requires @ast-grep/napi. Run: npm install @ast-grep/napi";
+        }
+        const pattern = args.pattern;
+        const language = args.language;
+        const rawLimit = typeof args.limit === "number" ? args.limit : 20;
+        const limit = Math.max(1, Math.min(100, Math.round(rawLimit)));
+        const db = cg.getDatabase();
+        const rawDb = db.getRawDb();
+        const files = rawDb.all(
+          "SELECT path FROM files WHERE language = ? LIMIT 5000",
+          [language]
+        );
+        const results = [];
+        let truncated = false;
+        for (const file of files) {
+          if (results.length >= limit) {
+            truncated = true;
+            break;
+          }
+          let content;
+          try {
+            const fullPath = path.isAbsolute(file.path) ? file.path : path.join(projectRoot, file.path);
+            content = fs.readFileSync(fullPath, "utf8");
+          } catch {
+            continue;
+          }
+          const matches = await runner.runInline(pattern, language, content);
+          for (const m of matches) {
+            if (results.length >= limit) {
+              truncated = true;
+              break;
+            }
+            results.push({ filePath: file.path, line: m.line, matchText: m.matchText });
+          }
+        }
+        if (results.length === 0) {
+          return `0 matches for '${pattern}' in ${language} files`;
+        }
+        const lines = [
+          `${results.length} match${results.length !== 1 ? "es" : ""} for '${pattern}' in ${language} files`,
+          ""
+        ];
+        for (const r of results) {
+          lines.push(` ${r.filePath}:${r.line}`);
+          lines.push(`   ${r.matchText}`);
+          lines.push("");
+        }
+        if (truncated) {
+          lines.push(`[truncated \u2014 showing first ${limit} results; refine your pattern or use --lang to narrow scope]`);
+        }
+        return truncate(lines.join("\n"));
+      }
+      // ── Pattern tools ──────────────────────────────────────────────────────────
+      case "kirograph_pattern_coverage": {
+        const { loadConfig } = await Promise.resolve().then(() => require("../config.js"));
+        const projectRoot = cg.getProjectRoot();
+        const config = await loadConfig(projectRoot);
+        if (!config.enablePatterns) {
+          return "Pattern analysis is not enabled. Set enablePatterns: true in .kirograph/config.json and run kirograph index.";
+        }
+        const { PatternLibraryLoader } = await Promise.resolve().then(() => require("../patterns/loader.js"));
+        const loader = new PatternLibraryLoader();
+        const builtinPath = path.join(__dirname, "../patterns/library");
+        const customPath = config.patternLibraryPath;
+        let rules = [];
+        try {
+          rules = loader.load(builtinPath, customPath);
+        } catch {
+        }
+        const rulesByCategory = /* @__PURE__ */ new Map();
+        for (const rule of rules) {
+          const prefix = rule.owaspCategory.match(/^(A\d{2})/)?.[1] ?? rule.owaspCategory;
+          if (!rulesByCategory.has(prefix)) rulesByCategory.set(prefix, []);
+          rulesByCategory.get(prefix).push(rule);
+        }
+        const db = cg.getDatabase();
+        db.applyPatternsSchema();
+        const rawDb = db.getRawDb();
+        const matchCountsByCategory = /* @__PURE__ */ new Map();
+        try {
+          const tableExists = rawDb.get("SELECT name FROM sqlite_master WHERE type='table' AND name='pattern_matches'");
+          if (tableExists) {
+            const rows = rawDb.all(
+              "SELECT owasp_category, COUNT(*) as cnt FROM pattern_matches GROUP BY owasp_category"
+            );
+            for (const row of rows) {
+              const prefix = row.owasp_category.match(/^(A\d{2})/)?.[1] ?? row.owasp_category;
+              matchCountsByCategory.set(prefix, (matchCountsByCategory.get(prefix) ?? 0) + row.cnt);
+            }
+          }
+        } catch {
+        }
+        const owaspTop10 = [
+          "A01",
+          "A02",
+          "A03",
+          "A04",
+          "A05",
+          "A06",
+          "A07",
+          "A08",
+          "A09",
+          "A10"
+        ];
+        const owaspNames = {
+          A01: "Broken Access Control",
+          A02: "Cryptographic Failures",
+          A03: "Injection",
+          A04: "Insecure Design",
+          A05: "Security Misconfiguration",
+          A06: "Vulnerable and Outdated Components",
+          A07: "Identification and Authentication Failures",
+          A08: "Software and Data Integrity Failures",
+          A09: "Security Logging and Monitoring Failures",
+          A10: "Server-Side Request Forgery"
+        };
+        const covered = [];
+        const uncovered = [];
+        const lines = [
+          "# OWASP Top 10 Pattern Coverage",
+          "",
+          `Total rules loaded: ${rules.length}`,
+          "",
+          "Category | Rules | Matches",
+          "-------- | ----- | -------"
+        ];
+        for (const cat of owaspTop10) {
+          const catRules = rulesByCategory.get(cat) ?? [];
+          const matchCount = matchCountsByCategory.get(cat) ?? 0;
+          const label = `${cat}: ${owaspNames[cat] ?? cat}`;
+          if (catRules.length > 0) {
+            covered.push(label);
+            lines.push(`${label} | ${catRules.length} | ${matchCount}`);
+          } else {
+            uncovered.push(label);
+          }
+        }
+        for (const [cat, catRules] of rulesByCategory.entries()) {
+          if (!owaspTop10.includes(cat)) {
+            const matchCount = matchCountsByCategory.get(cat) ?? 0;
+            lines.push(`${cat} | ${catRules.length} | ${matchCount}`);
+          }
+        }
+        if (uncovered.length > 0) {
+          lines.push("", `Uncovered categories (${uncovered.length}):`, ...uncovered.map((c) => `  - ${c}`));
+        }
+        lines.push("", `Coverage: ${covered.length} / ${owaspTop10.length} OWASP Top 10 categories`);
+        return lines.join("\n");
+      }
+      case "kirograph_pattern_save_baseline": {
+        const { loadConfig } = await Promise.resolve().then(() => require("../config.js"));
+        const projectRoot = cg.getProjectRoot();
+        const config = await loadConfig(projectRoot);
+        if (!config.enablePatterns) {
+          return "Pattern analysis is not enabled. Set enablePatterns: true in .kirograph/config.json and run kirograph index.";
+        }
+        const label = args.label ?? "default";
+        const db = cg.getDatabase();
+        db.applyPatternsSchema();
+        const rawDb = db.getRawDb();
+        const tableExists = rawDb.get("SELECT name FROM sqlite_master WHERE type='table' AND name='pattern_matches'");
+        if (!tableExists) {
+          return "No pattern_matches table found. Run kirograph index first to populate pattern data.";
+        }
+        const rows = rawDb.all(
+          "SELECT pattern_id, COUNT(*) as cnt FROM pattern_matches GROUP BY pattern_id"
+        );
+        const baseline = {};
+        for (const row of rows) {
+          baseline[row.pattern_id] = row.cnt;
+        }
+        const kirographDir = path.join(projectRoot, ".kirograph");
+        if (!fs.existsSync(kirographDir)) fs.mkdirSync(kirographDir, { recursive: true });
+        const baselinePath = path.join(kirographDir, `pattern-baseline-${label}.json`);
+        fs.writeFileSync(baselinePath, JSON.stringify({ label, savedAt: Date.now(), counts: baseline }, null, 2));
+        const totalMatches = Object.values(baseline).reduce((s, c) => s + c, 0);
+        return `Baseline "${label}" saved: ${Object.keys(baseline).length} patterns, ${totalMatches} total matches \u2192 ${baselinePath}`;
+      }
+      case "kirograph_pattern_diff": {
+        const { loadConfig } = await Promise.resolve().then(() => require("../config.js"));
+        const projectRoot = cg.getProjectRoot();
+        const config = await loadConfig(projectRoot);
+        if (!config.enablePatterns) {
+          return "Pattern analysis is not enabled. Set enablePatterns: true in .kirograph/config.json and run kirograph index.";
+        }
+        const label = args.label ?? "default";
+        const baselinePath = path.join(projectRoot, ".kirograph", `pattern-baseline-${label}.json`);
+        if (!fs.existsSync(baselinePath)) {
+          return `Baseline "${label}" not found. Run kirograph_pattern_save_baseline first.`;
+        }
+        let baseline;
+        try {
+          baseline = JSON.parse(fs.readFileSync(baselinePath, "utf8"));
+        } catch {
+          return `Failed to read baseline file: ${baselinePath}`;
+        }
+        const db = cg.getDatabase();
+        db.applyPatternsSchema();
+        const rawDb = db.getRawDb();
+        const tableExists = rawDb.get("SELECT name FROM sqlite_master WHERE type='table' AND name='pattern_matches'");
+        const currentCounts = {};
+        if (tableExists) {
+          const rows = rawDb.all(
+            "SELECT pattern_id, COUNT(*) as cnt FROM pattern_matches GROUP BY pattern_id"
+          );
+          for (const row of rows) {
+            currentCounts[row.pattern_id] = row.cnt;
+          }
+        }
+        const allPatternIds = /* @__PURE__ */ new Set([...Object.keys(baseline.counts), ...Object.keys(currentCounts)]);
+        const newFindings = [];
+        const resolvedFindings = [];
+        const unchanged = [];
+        const changed = [];
+        for (const id of allPatternIds) {
+          const before = baseline.counts[id] ?? 0;
+          const after = currentCounts[id] ?? 0;
+          if (before === 0 && after > 0) {
+            newFindings.push({ id, count: after });
+          } else if (before > 0 && after === 0) {
+            resolvedFindings.push({ id, count: before });
+          } else if (before === after) {
+            unchanged.push({ id, count: after });
+          } else {
+            changed.push({ id, before, after, delta: after - before });
+          }
+        }
+        const savedDate = new Date(baseline.savedAt).toISOString().slice(0, 16).replace("T", " ");
+        const lines = [
+          `# Pattern Diff: "${label}" (saved ${savedDate}) \u2192 current`,
+          "",
+          `NEW: ${newFindings.length}  RESOLVED: ${resolvedFindings.length}  CHANGED: ${changed.length}  UNCHANGED: ${unchanged.length}`
+        ];
+        if (newFindings.length > 0) {
+          lines.push("", "## New Findings (not in baseline)");
+          for (const f of newFindings.sort((a, b) => b.count - a.count)) {
+            lines.push(`  + ${f.id}: ${f.count} matches`);
+          }
+        }
+        if (resolvedFindings.length > 0) {
+          lines.push("", "## Resolved (in baseline, not in current)");
+          for (const f of resolvedFindings.sort((a, b) => b.count - a.count)) {
+            lines.push(`  - ${f.id}: was ${f.count} matches`);
+          }
+        }
+        if (changed.length > 0) {
+          lines.push("", "## Changed");
+          for (const f of changed.sort((a, b) => Math.abs(b.delta) - Math.abs(a.delta))) {
+            const sign = f.delta > 0 ? "+" : "";
+            lines.push(`  ~ ${f.id}: ${f.before} \u2192 ${f.after} (${sign}${f.delta})`);
+          }
+        }
+        return lines.join("\n");
+      }
       default:
         return `Unknown tool: ${toolName}`;
     }
@@ -2997,6 +3393,7 @@ ${lines.join("\n")}`;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   KIROGRAPH_TOOL_NAMES,
+  LIVE_SEARCH_TOOL_DEFINITION,
   ToolHandler,
   tools
 });