@grafema/mcp 0.3.29 → 0.4.0

package/src/definitions/query-tools.ts

@@ -353,6 +353,133 @@ The question parameter guides what graph data to fetch and how to frame the summ
       required: ['target'],
     },
   },
+  {
+    name: 'explain_fact',
+    description: `Explain WHY a derived (Datalog) fact holds — returns the rule that derived it plus the supporting body facts (why()/provenance).
+
+This is the inverse of "what holds": instead of listing results, it justifies ONE
+result. Provenance is computed on demand against the current graph snapshot.
+
+Default program is the bundled depends.dl, so the common use is explaining a
+MODULE→MODULE dependency edge:
+- "Why does module A depend on B?" → explain_fact(predicate="depends", key=["<A_id>", "<B_id>"])
+
+For a custom rule, pass its source. \`key\` is the fact's ground tuple as wire-string
+terms (node ids as their decimal id). A null/"no derivation" result means the fact
+is not derivable by the program (it does not hold as a derived fact).`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        predicate: {
+          type: 'string',
+          description: 'The derived predicate to explain (e.g. "depends").',
+        },
+        key: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'The fact\'s ground key tuple as wire-string terms (node ids as decimal).',
+        },
+        source: {
+          type: 'string',
+          description: 'Optional Datalog program (derive engine); empty/omitted ⇒ the bundled depends.dl.',
+        },
+      },
+      required: ['predicate', 'key'],
+    },
+  },
+  {
+    name: 'sim_datalog',
+    description: `Predict which NEW derived facts a hypothetical change would create — WITHOUT committing anything (what-if simulation).
+
+Give it hypothetical nodes and/or edges; it evaluates the program over base ∪ overlay
+and returns only the facts that are NEW vs the current graph (sim ∖ base).
+
+Default program is the bundled depends.dl, so the common use is previewing module
+dependencies:
+- "If module A imported B, which NEW dependencies appear?" →
+  sim_datalog(predicate="depends", edges=[{src:"<A_id>", dst:"<B_id>", edgeType:"IMPORTS_FROM"}])
+
+Hypothetical node ids may be NEW (invent a decimal id) — an edge may reference them,
+so you can simulate a wholly new module/import, not only bridge existing nodes.
+The committed graph is never touched. Companion to explain_gap: gap names the missing
+premise, sim verifies that adding it produces the fact.`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        predicate: {
+          type: 'string',
+          description: 'The derived predicate whose NEW facts to predict (e.g. "depends").',
+        },
+        nodes: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              id: { type: 'string', description: 'Decimal node id (may be a new, invented id).' },
+              nodeType: { type: 'string', description: 'Node type (e.g. "MODULE").' },
+              name: { type: 'string', description: 'Node name attr.' },
+              file: { type: 'string', description: 'Node file attr.' },
+            },
+            required: ['id', 'nodeType'],
+          },
+          description: 'Hypothetical nodes to overlay.',
+        },
+        edges: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              src: { type: 'string', description: 'Source node id (existing or hypothetical).' },
+              dst: { type: 'string', description: 'Target node id (existing or hypothetical).' },
+              edgeType: { type: 'string', description: 'Edge type (e.g. "IMPORTS_FROM").' },
+            },
+            required: ['src', 'dst', 'edgeType'],
+          },
+          description: 'Hypothetical edges to overlay.',
+        },
+        source: {
+          type: 'string',
+          description: 'Optional Datalog program (derive engine); empty/omitted ⇒ the bundled depends.dl.',
+        },
+      },
+      required: ['predicate'],
+    },
+  },
+  {
+    name: 'explain_gap',
+    description: `Explain why a derived (Datalog) fact does NOT hold — the why-not dual of explain_fact.
+
+Returns the rule whose gap it characterizes, the body premises that WERE satisfiable
+(with the head bound), and the first premise no binding satisfies:
+- a MISSING positive premise → the gap closes by ADDING such a fact (verify with sim_datalog)
+- a PRESENT negated premise → the gap closes by REMOVING the blocking fact
+
+Default program is the bundled depends.dl, so the common use is explaining a missing
+MODULE→MODULE dependency:
+- "Why does module A NOT depend on B?" → explain_gap(predicate="depends", key=["<A_id>", "<B_id>"])
+
+A "no gap" result means the fact actually IS derivable (use explain_fact), or no rule
+head matches the key.`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        predicate: {
+          type: 'string',
+          description: 'The derived predicate of the missing fact (e.g. "depends").',
+        },
+        key: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'The missing fact\'s ground key tuple as wire-string terms (node ids as decimal).',
+        },
+        source: {
+          type: 'string',
+          description: 'Optional Datalog program (derive engine); empty/omitted ⇒ the bundled depends.dl.',
+        },
+      },
+      required: ['predicate', 'key'],
+    },
+  },
   {
     name: 'check_invariant',
     description: `Check a one-off code invariant using a Datalog rule. Returns violations if broken.

package/src/handlers/coverage-handlers.ts

@@ -31,9 +31,19 @@ export async function handleGetCoverage(args: GetCoverageArgs): Promise<ToolResu
     output += `File breakdown:\n`;
     output += `  Total files:     ${result.total}\n`;
     output += `  Analyzed:        ${result.analyzed.count} (${result.percentages.analyzed}%) - in graph\n`;
+    if (result.failed.count > 0) {
+      output += `  Failed:          ${result.failed.count} (${result.percentages.failed}%) - skipped/failed during analysis\n`;
+    }
     output += `  Unsupported:     ${result.unsupported.count} (${result.percentages.unsupported}%) - no indexer available\n`;
     output += `  Unreachable:     ${result.unreachable.count} (${result.percentages.unreachable}%) - not imported from entrypoints\n`;
 
+    if (result.failed.count > 0) {
+      output += `\nFailed files by reason:\n`;
+      for (const [category, files] of Object.entries(result.failed.byCategory)) {
+        output += `  ${category}: ${files.length} files\n`;
+      }
+    }
+
     if (result.unsupported.count > 0) {
       output += `\nUnsupported files by extension:\n`;
       for (const [ext, files] of Object.entries(result.unsupported.byExtension)) {

package/src/handlers/documentation-handlers.ts

@@ -40,11 +40,21 @@ Grafema is a static code analyzer that builds a graph of your codebase.
 ## Syntax
 violation(X) :- node(X, "TYPE"), attr(X, "name", "value").
 
-## Available Predicates
-- type(Id, Type) - match nodes (alias: node)
-- edge(Src, Dst, Type) - match edges
-- attr(Id, Name, Value) - match node attributes (name, file, line, etc.)
-- \\+ - negation (not)
+## Node / Edge / Attribute Predicates
+- node(Id, Type) - match nodes by type (alias: type(Id, Type))
+- edge(Src, Dst, Type) - match outgoing edges Src -> Dst of the given type
+- incoming(Dst, Src, Type) - match edges pointing TO Dst (reverse of edge)
+- path(Src, Dst) - transitive reachability Src -> Dst (BFS over edges)
+- attr(Id, Name, Value) - match node attributes (name, file, line, ...; nested paths like "a.b" supported)
+- attr_edge(Src, Dst, EdgeType, AttrName, Value) - match EDGE attributes; Src/Dst/EdgeType/AttrName must be bound, Value may be variable/constant/wildcard
+- parent_function(NodeId, FunctionId) - bind the enclosing FUNCTION of NodeId via CONTAINS; NodeId must be bound; empty at module level
+
+## Negation & String Predicates
+- \\+ - negation (not); also for negative joins on a dst-position variable, e.g. \\+ edge(X, _, "CALLS")
+- neq(X, Y) - inequality; BOTH arguments must be bound
+- starts_with(Value, Prefix) - string prefix match
+- not_starts_with(Value, Prefix) - negative string prefix match
+- string_contains(Value, Substring) - substring match
 
 ## Numeric Comparison Predicates
 - gt(Value, Threshold) - greater than
@@ -55,6 +65,11 @@ violation(X) :- node(X, "TYPE"), attr(X, "name", "value").
 Values are parsed as floating-point numbers. Non-numeric values produce no matches.
 Use with attr() to filter by metadata values (e.g., metrics, line numbers).
 
+## Limitations
+- No aggregations (count/sum/avg), no GROUP BY, no ORDER BY - aggregate/sort client-side.
+- Predicate ORDER matters: bind a variable (via node/edge/attr) before a comparison /
+  string / attr_edge predicate uses it, or the query fails to place ("circular dependency").
+
 ## Examples
 Find all functions:
   violation(X) :- node(X, "FUNCTION").
@@ -67,6 +82,12 @@ Find files where parsing took > 500ms:
 
 Find functions with more than 100 lines:
   violation(X, Lines) :- node(X, "FUNCTION"), attr(X, "line", Start), attr(X, "endLine", End), gt(End, Start).
+
+Find the enclosing function of every call:
+  violation(C, F) :- node(C, "CALL"), parent_function(C, F).
+
+Find nodes that have incoming CALLS edges (i.e. are called):
+  violation(D) :- incoming(D, _, "CALLS").
 `,
     types: `
 # Node & Edge Types

package/src/handlers/enox-handlers.ts

@@ -348,14 +348,25 @@ export async function handleRecall(args: RecallArgs): Promise<ToolResult> {
 
 export interface SemanticSearchArgs {
   query: string;
-  limit?: number;
+  top_k?: number;
   domain?: string;
 }
 
-export async function handleSemanticSearch(args: SemanticSearchArgs): Promise<ToolResult> {
+/**
+ * Handle the `semantic_search` MCP tool.
+ *
+ * @param args - tool input. `top_k` (matching the published schema) caps the
+ *   number of results; defaults to 10 per the schema's documented default.
+ * @param clientOverride - optional RFDB client, injected by tests; production
+ *   callers omit it and the shared knowledge client is used.
+ */
+export async function handleSemanticSearch(
+  args: SemanticSearchArgs,
+  clientOverride?: RFDBClient,
+): Promise<ToolResult> {
   try {
-    const client = await getKnowledgeClient();
-    const limit = args.limit ?? 20;
+    const client = clientOverride ?? await getKnowledgeClient();
+    const limit = args.top_k ?? 10;
 
     // TODO: Wire to RFDB embedding engine when enabled.
     // For now, fall back to substring search via queryNodes.
@@ -378,9 +389,9 @@ export async function handleSemanticSearch(args: SemanticSearchArgs): Promise<To
     for (let i = 0; i < results.length; i++) {
       const node = results[i];
       const meta = parseMeta(node);
-      // Pseudo-similarity score based on match quality (placeholder until embeddings)
-      const similarity = (1.0 - (i * 0.05)).toFixed(2);
-      lines.push(`${i + 1}. [${similarity}] ${node.name} (${node.nodeType})`);
+      // NOTE: this is substring matching, not embeddings — do not fabricate a
+      // similarity score (it would read to an agent as a real metric). Just rank.
+      lines.push(`${i + 1}. ${node.name} (${node.nodeType})`);
       if (meta.domain) lines.push(`   Domain: ${meta.domain}`);
       if (meta.content) lines.push(`   ${String(meta.content).slice(0, 200)}`);
       lines.push('');

package/src/handlers/index.ts

@@ -2,7 +2,7 @@
  * MCP Tool Handlers — barrel export
  */
 
-export { handleQueryGraph, handleFindCalls, handleFindNodes } from './query-handlers.js';
+export { handleQueryGraph, handleFindCalls, handleFindNodes, handleExplainFact, handleExplainGap, handleSimDatalog } from './query-handlers.js';
 export { handleTraceAlias, handleTraceDataflow, handleTraceCalls, handleCheckInvariant, handleExplain, handleTraceEffects } from './dataflow-handlers.js';
 export type { ExplainArgs } from './dataflow-handlers.js';
 export { handleDiscoverServices, handleAnalyzeProject, handleGetAnalysisStatus, handleGetStats, handleGetSchema } from './analysis-handlers.js';

package/src/handlers/query-handlers.ts

@@ -13,7 +13,7 @@ import {
   textResult,
   errorResult,
 } from '../utils.js';
-import type { DatalogExplainResult, CypherResult } from '@grafema/types';
+import type { DatalogExplainResult, CypherResult, FactWitness, GapWitness, SimEdge, SimNode } from '@grafema/types';
 import type {
   ToolResult,
   QueryGraphArgs,
@@ -22,6 +22,9 @@ import type {
   GraphNode,
   DatalogBinding,
   CallResult,
+  ExplainFactArgs,
+  ExplainGapArgs,
+  SimDatalogArgs,
 } from '../types.js';
 
 // === QUERY HANDLERS ===
@@ -524,22 +527,35 @@ async function enrichNodes(
 
 /** Convert a semantic ID to human-readable "name in file.ts" format.
  * Handles: grafema://host/path/file.ts#TYPE->name[scope], path/file.ts#TYPE->name,
- * TYPE-%3Ename (URL-encoded, no file prefix), or raw node IDs. */
-function humanReadableId(semanticId: string): string {
+ * TYPE-%3Ename (URL-encoded, no file prefix), or raw node IDs.
+ *
+ * Exported for unit testing.
+ * @internal */
+export function humanReadableId(semanticId: string): string {
   if (!semanticId) return '?';
-  // Decode URI components first
-  let id = semanticId;
-  try { id = decodeURIComponent(id); } catch { /* keep as-is */ }
-
-  // Find the # separator between file path and node descriptor
-  const hashIdx = id.lastIndexOf('#');
-  let filePart = '';
-  let nodePart = id;
+
+  // Split file path from node descriptor on the FIRST literal '#' of the RAW
+  // (still percent-encoded) id, BEFORE decoding. The grafema:// URI form encodes
+  // the disambiguation counter ('#N', appended by computeSemanticIdV2 for hash
+  // collisions) as '%23N' inside the fragment. Decoding first and then splitting
+  // on the LAST '#' would mistake that counter for the path/fragment boundary and
+  // corrupt the label. A file path never contains a literal '#'. This mirrors the
+  // canonical parseSemanticIdV2 (packages/util/src/core/SemanticId.ts).
+  const hashIdx = semanticId.indexOf('#');
+  let rawFile = '';
+  let rawNode = semanticId;
   if (hashIdx !== -1) {
-    filePart = id.slice(0, hashIdx);
-    nodePart = id.slice(hashIdx + 1);
+    rawFile = semanticId.slice(0, hashIdx);
+    rawNode = semanticId.slice(hashIdx + 1);
   }
 
+  const decode = (s: string): string => {
+    try { return decodeURIComponent(s); } catch { return s; }
+  };
+  const filePart = decode(rawFile);
+  // Strip the trailing disambiguation counter ('#N') from the decoded descriptor.
+  const nodePart = decode(rawNode).replace(/#\d+$/, '');
+
   const fileName = filePart ? (filePart.split('/').pop() || '') : '';
 
   // Extract name from TYPE->name or TYPE->name[in:scope,h:hash]
@@ -619,3 +635,155 @@ async function grepAndEnrich(
     return [];
   }
 }
+
+/**
+ * explain_fact (why(), spec §11): explain WHY a derived fact holds — return the rule that derived
+ * it and the supporting body facts. Empty `source` ⇒ the bundled depends.dl (so `explain_fact`
+ * with predicate "depends" explains a DEPENDS_ON edge). v2-only.
+ */
+export async function handleExplainFact(args: ExplainFactArgs): Promise<ToolResult> {
+  const { predicate, key, source } = args;
+  if (!predicate || !Array.isArray(key)) {
+    return errorResult('explain_fact requires `predicate` (string) and `key` (array of wire-string terms).');
+  }
+
+  const db = await ensureAnalyzed();
+  if (!('explainDatalogFact' in db)) {
+    return errorResult('Backend does not support explain_fact (needs an rfdb-server with the derive engine enabled, i.e. RFDB_DERIVE_ENGINE not set to off).');
+  }
+  const fn = (db as unknown as {
+    explainDatalogFact: (s: string, p: string, k: string[]) => Promise<FactWitness | null>;
+  }).explainDatalogFact;
+
+  let witness: FactWitness | null;
+  try {
+    witness = await fn.call(db, source ?? '', predicate, key.map(String));
+  } catch (e) {
+    return errorResult(`explain_fact failed: ${e instanceof Error ? e.message : String(e)}`);
+  }
+
+  const factStr = `${predicate}(${key.join(', ')})`;
+  if (!witness) {
+    return textResult(
+      `No derivation: ${factStr} is not derivable by the program (it does not hold as a derived fact).`,
+    );
+  }
+
+  const lines = [`${factStr} holds — derived by rule ${witness.ruleAstHash}:`];
+  if (witness.body.length === 0) {
+    lines.push('  (the rule body has no positive facts — supported by builtins/constants alone)');
+  } else {
+    for (const f of witness.body) {
+      lines.push(`  • ${f.predicate}(${f.tuple.join(', ')})`);
+    }
+  }
+  return textResult(guardResponseSize(lines.join('\n')));
+}
+
+/**
+ * sim_datalog (what-if, spec §6): predict the NEW `predicate` facts a hypothetical overlay of
+ * nodes+edges would create — WITHOUT committing anything. Empty `source` ⇒ the bundled
+ * depends.dl (so the common use is "which NEW module dependencies would this import create?").
+ * v2-only. The companion to explain_gap: gap names the missing premise, sim verifies that
+ * adding it produces the fact.
+ */
+export async function handleSimDatalog(args: SimDatalogArgs): Promise<ToolResult> {
+  const { predicate, nodes, edges, source } = args;
+  if (!predicate) {
+    return errorResult('sim_datalog requires `predicate` (string).');
+  }
+  const hypNodes: SimNode[] = (nodes ?? []).map((n) => ({
+    id: String(n.id),
+    nodeType: n.nodeType,
+    name: n.name ?? '',
+    file: n.file ?? '',
+  }));
+  const hypEdges: SimEdge[] = (edges ?? []).map((e) => ({
+    src: String(e.src),
+    dst: String(e.dst),
+    edgeType: e.edgeType,
+  }));
+  if (hypNodes.length === 0 && hypEdges.length === 0) {
+    return errorResult('sim_datalog requires at least one hypothetical node or edge.');
+  }
+
+  const db = await ensureAnalyzed();
+  if (!('simDatalog' in db)) {
+    return errorResult('Backend does not support sim_datalog (needs an rfdb-server with the derive engine enabled, i.e. RFDB_DERIVE_ENGINE not set to off).');
+  }
+  const fn = (db as unknown as {
+    simDatalog: (s: string, p: string, n: SimNode[], e: SimEdge[]) => Promise<string[][]>;
+  }).simDatalog;
+
+  let rows: string[][];
+  try {
+    rows = await fn.call(db, source ?? '', predicate, hypNodes, hypEdges);
+  } catch (e) {
+    return errorResult(`sim_datalog failed: ${e instanceof Error ? e.message : String(e)}`);
+  }
+
+  if (rows.length === 0) {
+    return textResult(
+      `No new facts: the hypothetical change creates no NEW ${predicate}() facts (anything it derives already holds).`,
+    );
+  }
+  const lines = [`${rows.length} NEW ${predicate}() fact(s) the hypothetical change would create:`];
+  for (const row of rows) {
+    lines.push(`  • ${predicate}(${row.join(', ')})`);
+  }
+  return textResult(guardResponseSize(lines.join('\n')));
+}
+
+/**
+ * explain_gap (why-not, spec §6): explain why a fact is NOT derived — the satisfied premise
+ * prefix and the first premise no binding satisfies. Empty `source` ⇒ the bundled depends.dl
+ * (so the common use is "why is there NO dependency A→B?"). v2-only.
+ */
+export async function handleExplainGap(args: ExplainGapArgs): Promise<ToolResult> {
+  const { predicate, key, source } = args;
+  if (!predicate || !Array.isArray(key)) {
+    return errorResult('explain_gap requires `predicate` (string) and `key` (array of wire-string terms).');
+  }
+
+  const db = await ensureAnalyzed();
+  if (!('explainDatalogGap' in db)) {
+    return errorResult('Backend does not support explain_gap (needs an rfdb-server with the derive engine enabled, i.e. RFDB_DERIVE_ENGINE not set to off).');
+  }
+  const fn = (db as unknown as {
+    explainDatalogGap: (s: string, p: string, k: string[]) => Promise<GapWitness | null>;
+  }).explainDatalogGap;
+
+  let gap: GapWitness | null;
+  try {
+    gap = await fn.call(db, source ?? '', predicate, key.map(String));
+  } catch (e) {
+    return errorResult(`explain_gap failed: ${e instanceof Error ? e.message : String(e)}`);
+  }
+
+  const factStr = `${predicate}(${key.join(', ')})`;
+  if (!gap) {
+    return textResult(
+      `No gap: ${factStr} is derivable (it holds — use explain_fact for its derivation), or no rule head matches this key.`,
+    );
+  }
+
+  const lines = [`${factStr} does NOT hold — gap in rule ${gap.ruleAstHash}:`];
+  if (gap.satisfied.length === 0) {
+    lines.push('  satisfied premises: (none)');
+  } else {
+    lines.push('  satisfied premises:');
+    for (const f of gap.satisfied) {
+      lines.push(`    • ${f.predicate}(${f.tuple.join(', ')})`);
+    }
+  }
+  if (gap.failingIsNegative) {
+    lines.push(
+      `  blocking premise: NOT ${gap.failingPredicate}(…) — a PRESENT fact blocks the derivation; the gap closes by REMOVING it.`,
+    );
+  } else {
+    lines.push(
+      `  missing premise: ${gap.failingPredicate}(…) — no binding satisfies it; the gap closes by ADDING such a fact (verify with sim_datalog).`,
+    );
+  }
+  return textResult(guardResponseSize(lines.join('\n')));
+}

package/src/server.ts

@@ -39,6 +39,9 @@ import { errorResult, log } from './utils.js';
 import { getSocketPathOverride } from './state.js';
 import {
   handleQueryGraph,
+  handleExplainFact,
+  handleExplainGap,
+  handleSimDatalog,
   handleFindCalls,
   handleFindNodes,
   handleTraceAlias,
@@ -101,6 +104,9 @@ import type {
   GetFunctionDetailsArgs,
   GetContextArgs,
   QueryGraphArgs,
+  ExplainFactArgs,
+  ExplainGapArgs,
+  SimDatalogArgs,
   FindCallsArgs,
   FindNodesArgs,
   TraceAliasArgs,
@@ -282,6 +288,18 @@ server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
         result = await handleExplain(asArgs<ExplainArgs>(args));
         break;
 
+      case 'explain_fact':
+        result = await handleExplainFact(asArgs<ExplainFactArgs>(args));
+        break;
+
+      case 'sim_datalog':
+        result = await handleSimDatalog(asArgs<SimDatalogArgs>(args));
+        break;
+
+      case 'explain_gap':
+        result = await handleExplainGap(asArgs<ExplainGapArgs>(args));
+        break;
+
       case 'trace_effects':
         result = await handleTraceEffects(asArgs<TraceEffectsArgs>(args));
         break;

package/src/types.ts

@@ -51,6 +51,35 @@ export interface QueryGraphArgs {
   count?: boolean;
 }
 
+export interface ExplainFactArgs {
+  /** The derived predicate (e.g. "depends"). */
+  predicate: string;
+  /** The fact's ground key tuple as wire-string terms (node ids as decimal, else string). */
+  key: string[];
+  /** Optional Datalog program (derive engine); empty/omitted ⇒ the bundled depends.dl. */
+  source?: string;
+}
+
+export interface SimDatalogArgs {
+  /** The derived predicate whose NEW facts to predict (e.g. "depends"). */
+  predicate: string;
+  /** Hypothetical nodes: { id (decimal string), nodeType, name?, file? }. May be new ids. */
+  nodes?: Array<{ id: string; nodeType: string; name?: string; file?: string }>;
+  /** Hypothetical edges: { src, dst, edgeType }; endpoints existing OR hypothetical ids. */
+  edges?: Array<{ src: string; dst: string; edgeType: string }>;
+  /** Optional Datalog program (derive engine); empty/omitted ⇒ the bundled depends.dl. */
+  source?: string;
+}
+
+export interface ExplainGapArgs {
+  /** The derived predicate of the MISSING fact (e.g. "depends"). */
+  predicate: string;
+  /** The missing fact's ground key tuple as wire-string terms (node ids as decimal). */
+  key: string[];
+  /** Optional Datalog program (derive engine); empty/omitted ⇒ the bundled depends.dl. */
+  source?: string;
+}
+
 export interface FindCallsArgs {
   name: string;
   limit?: number;

package/dist/definitions.d.ts

@@ -1,23 +0,0 @@
-/**
- * MCP Tool Definitions
- */
-interface SchemaProperty {
-    type: string;
-    description?: string;
-    enum?: string[];
-    items?: SchemaProperty;
-    properties?: Record<string, SchemaProperty>;
-    required?: string[];
-}
-export interface ToolDefinition {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: 'object';
-        properties: Record<string, SchemaProperty>;
-        required?: string[];
-    };
-}
-export declare const TOOLS: ToolDefinition[];
-export {};
-//# sourceMappingURL=definitions.d.ts.map

package/dist/definitions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../src/definitions.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,UAAU,cAAc;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,CAAC,EAAE,cAAc,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAC5C,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAED,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,cAAc,CAAC,CAAC;QAC3C,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;KACrB,CAAC;CACH;AAED,eAAO,MAAM,KAAK,EAAE,cAAc,EA+nBjC,CAAC"}