@grafema/mcp 0.2.11 → 0.3.0-beta

package/dist/definitions/notation-tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"notation-tools.js","sourceRoot":"","sources":["../../src/definitions/notation-tools.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,MAAM,CAAC,MAAM,cAAc,GAAqB;IAC9C;QACE,IAAI,EAAE,UAAU;QAChB,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2EA8B0D;QACvE,WAAW,EAAE;YACX,IAAI,EAAE,QAAQ;YACd,UAAU,EAAE;gBACV,MAAM,EAAE;oBACN,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,kDAAkD;iBAChE;gBACD,KAAK,EAAE;oBACL,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,yGAAyG;iBACvH;gBACD,WAAW,EAAE;oBACX,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,wKAAwK;oBACrL,IAAI,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,CAAC;iBACtD;aACF;YACD,QAAQ,EAAE,CAAC,QAAQ,CAAC;SACrB;KACF;CACF,CAAC"}

package/dist/definitions/project-tools.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Project Tools — structure, config, coverage, documentation, issue reporting
+ */
+import type { ToolDefinition } from './types.js';
+export declare const PROJECT_TOOLS: ToolDefinition[];
+//# sourceMappingURL=project-tools.d.ts.map

package/dist/definitions/project-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-tools.d.ts","sourceRoot":"","sources":["../../src/definitions/project-tools.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,eAAO,MAAM,aAAa,EAAE,cAAc,EAgLzC,CAAC"}

package/dist/definitions/project-tools.js

@@ -0,0 +1,181 @@
+/**
+ * Project Tools — structure, config, coverage, documentation, issue reporting
+ */
+export const PROJECT_TOOLS = [
+    {
+        name: 'read_project_structure',
+        description: `Get the directory structure of the project.
+Returns a tree of files and directories, useful for understanding
+project layout during onboarding.
+
+Excludes: node_modules, .git, dist, build, .grafema, coverage, .next, .nuxt
+
+Use this tool when studying a new project to identify services,
+packages, and entry points.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'Subdirectory to scan (relative to project root). Default: project root.',
+                },
+                depth: {
+                    type: 'number',
+                    description: 'Maximum directory depth (default: 3, max: 5)',
+                },
+                include_files: {
+                    type: 'boolean',
+                    description: 'Include files in output, not just directories (default: true)',
+                },
+            },
+        },
+    },
+    {
+        name: 'write_config',
+        description: `Write or update the Grafema configuration file (.grafema/config.yaml).
+Validates all inputs before writing. Creates .grafema/ directory if needed.
+
+Use this tool after studying the project to save the discovered configuration.
+Only include fields you want to override — defaults are used for omitted fields.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                services: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string', description: 'Service name (e.g., "backend")' },
+                            path: { type: 'string', description: 'Path relative to project root (e.g., "apps/backend")' },
+                            entryPoint: { type: 'string', description: 'Entry point file relative to service path (e.g., "src/index.ts")' },
+                        },
+                        required: ['name', 'path'],
+                    },
+                    description: 'Service definitions (leave empty to use auto-discovery)',
+                },
+                plugins: {
+                    type: 'object',
+                    properties: {
+                        indexing: { type: 'array', items: { type: 'string' }, description: 'Indexing plugins' },
+                        analysis: { type: 'array', items: { type: 'string' }, description: 'Analysis plugins' },
+                        enrichment: { type: 'array', items: { type: 'string' }, description: 'Enrichment plugins' },
+                        validation: { type: 'array', items: { type: 'string' }, description: 'Validation plugins' },
+                    },
+                    description: 'Plugin configuration (omit to use defaults)',
+                },
+                include: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Glob patterns for files to include (e.g., ["src/**/*.ts"])',
+                },
+                exclude: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Glob patterns for files to exclude (e.g., ["**/*.test.ts"])',
+                },
+                workspace: {
+                    type: 'object',
+                    properties: {
+                        roots: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Root directories for multi-root workspace',
+                        },
+                    },
+                    description: 'Multi-root workspace config (only for workspaces)',
+                },
+            },
+        },
+    },
+    {
+        name: 'get_coverage',
+        description: `Check which files were analyzed and which were skipped.
+
+Use this to:
+- Find gaps: "Why doesn't query find this file?" — check if it was analyzed
+- Verify include/exclude patterns work correctly
+- Debug empty query results: file not in graph → not analyzed
+- Identify unsupported file types or parse errors
+
+Returns: analyzed/skipped file counts, coverage percentage, skip reasons.
+
+Use AFTER analyze_project when queries return unexpected empty results.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'Path to check coverage for',
+                },
+                depth: {
+                    type: 'number',
+                    description: 'Directory depth to report (default: 2)',
+                },
+            },
+        },
+    },
+    {
+        name: 'get_documentation',
+        description: `Get documentation about Grafema usage and query syntax.
+
+Topics available:
+- queries: Datalog query syntax and examples
+- types: Available node and edge types
+- guarantees: How to create and manage code guarantees
+- notation: DSL notation reference (archetypes, operators, LOD, perspectives)
+- onboarding: Step-by-step guide for new projects
+- overview: High-level Grafema architecture
+
+Use this when you need to learn Datalog syntax, DSL notation, or understand available features.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                topic: {
+                    type: 'string',
+                    description: 'Topic: queries, types, guarantees, notation, onboarding, or overview',
+                },
+            },
+        },
+    },
+    {
+        name: 'report_issue',
+        description: `Report a bug or issue with Grafema to GitHub.
+
+Use this tool when you encounter:
+- Unexpected errors or crashes
+- Incorrect analysis results
+- Missing features that should exist
+- Documentation issues
+
+The tool will create a GitHub issue automatically if GITHUB_TOKEN is configured.
+If not configured, it will return a pre-formatted issue template that the user
+can manually submit at https://github.com/Disentinel/grafema/issues/new
+
+IMPORTANT: Always ask the user for permission before reporting an issue.
+Include relevant context: error messages, file paths, query used, etc.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                title: {
+                    type: 'string',
+                    description: 'Brief issue title (e.g., "Query returns empty results for FUNCTION nodes")',
+                },
+                description: {
+                    type: 'string',
+                    description: 'Detailed description of the issue',
+                },
+                context: {
+                    type: 'string',
+                    description: 'Relevant context: error messages, queries, file paths, etc.',
+                },
+                labels: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Labels: bug, enhancement, documentation, question',
+                },
+            },
+            required: ['title', 'description'],
+        },
+    },
+];
+//# sourceMappingURL=project-tools.js.map

package/dist/definitions/project-tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-tools.js","sourceRoot":"","sources":["../../src/definitions/project-tools.ts"],"names":[],"mappings":"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"}

package/dist/definitions/query-tools.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Query Tools — graph querying and tracing
+ */
+import type { ToolDefinition } from './types.js';
+export declare const QUERY_TOOLS: ToolDefinition[];
+//# sourceMappingURL=query-tools.d.ts.map

package/dist/definitions/query-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-tools.d.ts","sourceRoot":"","sources":["../../src/definitions/query-tools.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAGjD,eAAO,MAAM,WAAW,EAAE,cAAc,EA+OvC,CAAC"}

package/dist/definitions/query-tools.js

@@ -0,0 +1,245 @@
+/**
+ * Query Tools — graph querying and tracing
+ */
+import { DEFAULT_LIMIT, MAX_LIMIT } from '../utils.js';
+export const QUERY_TOOLS = [
+    {
+        name: 'query_graph',
+        description: `Execute a Datalog or Cypher query on the code graph.
+
+Set language to "cypher" for Cypher queries (e.g., MATCH (n:FUNCTION) RETURN n.name).
+Default is Datalog.
+
+Available Datalog predicates:
+- type(Id, Type) - match nodes by type (alias: node)
+- edge(Src, Dst, Type) - match edges
+- attr(Id, Name, Value) - match node attributes (name, file, line, etc.)
+
+NODE TYPES:
+- MODULE, FUNCTION, METHOD, CLASS, VARIABLE, PARAMETER
+- CALL, PROPERTY_ACCESS, METHOD_CALL, CALL_SITE
+- http:route, http:request, db:query, socketio:emit, socketio:on
+
+EDGE TYPES:
+- CONTAINS, CALLS, DEPENDS_ON, ASSIGNED_FROM, INSTANCE_OF, PASSES_ARGUMENT
+
+EXAMPLES:
+  violation(X) :- node(X, "MODULE").
+  violation(X) :- node(X, "FUNCTION"), attr(X, "file", "src/api.js").
+  violation(X) :- node(X, "CALL"), \\+ edge(X, _, "CALLS").`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'Datalog query (must define violation/1 predicate) or Cypher query (when language is "cypher").',
+                },
+                language: {
+                    type: 'string',
+                    description: 'Query language: "datalog" (default) or "cypher"',
+                    enum: ['datalog', 'cypher'],
+                },
+                limit: {
+                    type: 'number',
+                    description: `Max results to return (default: ${DEFAULT_LIMIT}, max: ${MAX_LIMIT})`,
+                },
+                offset: {
+                    type: 'number',
+                    description: 'Skip first N results for pagination (default: 0)',
+                },
+                explain: {
+                    type: 'boolean',
+                    description: 'Show step-by-step query execution to debug empty results',
+                },
+                count: {
+                    type: 'boolean',
+                    description: 'When true, returns only the count of matching results instead of the full result list',
+                },
+            },
+            required: ['query'],
+        },
+    },
+    {
+        name: 'find_calls',
+        description: `Find every place in the codebase that calls a specific function or method.
+
+Use this when you need to answer:
+- "Who calls getUserById?" → name="getUserById"
+- "Where is redis.get used?" → name="get", className="redis"
+- "Is this function dead code?" → if 0 calls found, likely unused
+
+Returns file, line, and whether the call target is resolved (linked to its definition in the graph).`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description: 'Function or method name to find calls for',
+                },
+                className: {
+                    type: 'string',
+                    description: 'Optional: class name for method calls',
+                },
+                limit: {
+                    type: 'number',
+                    description: `Max results (default: ${DEFAULT_LIMIT}, max: ${MAX_LIMIT})`,
+                },
+                offset: {
+                    type: 'number',
+                    description: 'Skip first N results (default: 0)',
+                },
+            },
+            required: ['name'],
+        },
+    },
+    {
+        name: 'find_nodes',
+        description: `Find nodes in the graph by type, name, or file pattern.
+
+Use this when you need to:
+- Find all functions in a specific file: type="FUNCTION", file="src/api.js"
+- Find a class by name: type="CLASS", name="UserService"
+- List all HTTP routes: type="http:route"
+- Get all modules in a directory: type="MODULE", file="services/"
+
+Returns semantic IDs that you can pass to get_context, get_node, get_neighbors, or find_guards.
+
+Supports partial matches on name and file. Use limit/offset for pagination.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                type: {
+                    type: 'string',
+                    description: 'Node type (e.g., FUNCTION, CLASS, MODULE, PROPERTY_ACCESS)',
+                },
+                name: {
+                    type: 'string',
+                    description: 'Node name pattern',
+                },
+                file: {
+                    type: 'string',
+                    description: 'File path pattern',
+                },
+                limit: {
+                    type: 'number',
+                    description: `Max results (default: ${DEFAULT_LIMIT}, max: ${MAX_LIMIT})`,
+                },
+                offset: {
+                    type: 'number',
+                    description: 'Skip first N results (default: 0)',
+                },
+            },
+        },
+    },
+    {
+        name: 'trace_alias',
+        description: `Trace an alias chain to find the original source.
+For code like: const alias = obj.method; alias();
+This traces "alias" back to "obj.method".`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                variableName: {
+                    type: 'string',
+                    description: 'Variable name to trace',
+                },
+                file: {
+                    type: 'string',
+                    description: 'File path where the variable is defined',
+                },
+            },
+            required: ['variableName', 'file'],
+        },
+    },
+    {
+        name: 'trace_dataflow',
+        description: `Trace data flow paths from or to a variable/expression.
+
+Use this when you need to:
+- Forward trace: "Where does this value flow to?" (assignments, function calls, returns)
+- Backward trace: "Where does this value come from?" (sources, assignments)
+- Both: Full data lineage from sources to sinks
+
+Direction options:
+- forward: Follow ASSIGNED_FROM, PASSES_ARGUMENT, FLOWS_INTO edges downstream
+- backward: Follow edges upstream to find data sources
+- both: Trace in both directions for complete context
+
+Use cases:
+- Track tainted data: "Does user input reach database query?" (forward from input)
+- Find data sources: "What feeds this API response?" (backward from response)
+- Impact analysis: "If I change this variable, what breaks?" (forward trace)
+
+Returns: List of nodes in the data flow chain with edge types and depth.
+Tip: Start with max_depth=5, increase if needed.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                source: {
+                    type: 'string',
+                    description: 'Variable or node ID to trace from',
+                },
+                file: {
+                    type: 'string',
+                    description: 'File path',
+                },
+                direction: {
+                    type: 'string',
+                    description: 'forward, backward, or both (default: forward)',
+                    enum: ['forward', 'backward', 'both'],
+                },
+                max_depth: {
+                    type: 'number',
+                    description: 'Maximum trace depth (default: 10)',
+                },
+                limit: {
+                    type: 'number',
+                    description: `Max results (default: ${DEFAULT_LIMIT})`,
+                },
+                detail: {
+                    type: 'string',
+                    description: 'Level of detail: summary (counts only), normal (auto-compressed, default), full (every node)',
+                    enum: ['summary', 'normal', 'full'],
+                },
+            },
+            required: ['source'],
+        },
+    },
+    {
+        name: 'check_invariant',
+        description: `Check a one-off code invariant using a Datalog rule. Returns violations if broken.
+
+Use this for ad-hoc checks without saving a permanent guarantee.
+For persistent rules, use create_guarantee + check_guarantees instead.
+
+Use cases:
+- Quick check: "Are there any eval() calls?" — rule: violation(X) :- node(X, "CALL"), attr(X, "name", "eval").
+- Audit: "Functions over 100 lines?" — check for excessive complexity
+- Pre-commit: "Any new SQL injection risks?" — one-time check before pushing
+
+Returns: List of nodes violating the rule, with file and line info.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                rule: {
+                    type: 'string',
+                    description: 'Datalog rule defining violation/1',
+                },
+                description: {
+                    type: 'string',
+                    description: 'Human-readable description',
+                },
+                limit: {
+                    type: 'number',
+                    description: `Max violations (default: ${DEFAULT_LIMIT})`,
+                },
+                offset: {
+                    type: 'number',
+                    description: 'Skip first N violations (default: 0)',
+                },
+            },
+            required: ['rule'],
+        },
+    },
+];
+//# sourceMappingURL=query-tools.js.map

package/dist/definitions/query-tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-tools.js","sourceRoot":"","sources":["../../src/definitions/query-tools.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAEvD,MAAM,CAAC,MAAM,WAAW,GAAqB;IAC3C;QACE,IAAI,EAAE,aAAa;QACnB,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;4DAqB2C;QACxD,WAAW,EAAE;YACX,IAAI,EAAE,QAAQ;YACd,UAAU,EAAE;gBACV,KAAK,EAAE;oBACL,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,gGAAgG;iBAC9G;gBACD,QAAQ,EAAE;oBACR,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,iDAAiD;oBAC9D,IAAI,EAAE,CAAC,SAAS,EAAE,QAAQ,CAAC;iBAC5B;gBACD,KAAK,EAAE;oBACL,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,mCAAmC,aAAa,UAAU,SAAS,GAAG;iBACpF;gBACD,MAAM,EAAE;oBACN,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,kDAAkD;iBAChE;gBACD,OAAO,EAAE;oBACP,IAAI,EAAE,SAAS;oBACf,WAAW,EAAE,0DAA0D;iBACxE;gBACD,KAAK,EAAE;oBACL,IAAI,EAAE,SAAS;oBACf,WAAW,EAAE,uFAAuF;iBACrG;aACF;YACD,QAAQ,EAAE,CAAC,OAAO,CAAC;SACpB;KACF;IACD;QACE,IAAI,EAAE,YAAY;QAClB,WAAW,EAAE;;;;;;;qGAOoF;QACjG,WAAW,EAAE;YACX,IAAI,EAAE,QAAQ;YACd,UAAU,EAAE;gBACV,IAAI,EAAE;oBACJ,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,2CAA2C;iBACzD;gBACD,SAAS,EAAE;oBACT,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,uCAAuC;iBACrD;gBACD,KAAK,EAAE;oBACL,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,yBAAyB,aAAa,UAAU,SAAS,GAAG;iBAC1E;gBACD,MAAM,EAAE;oBACN,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,mCAAmC;iBACjD;aACF;YACD,QAAQ,EAAE,CAAC,MAAM,CAAC;SACnB;KACF;IACD;QACE,IAAI,EAAE,YAAY;QAClB,WAAW,EAAE;;;;;;;;;;4EAU2D;QACxE,WAAW,EAAE;YACX,IAAI,EAAE,QAAQ;YACd,UAAU,EAAE;gBACV,IAAI,EAAE;oBACJ,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,4DAA4D;iBAC1E;gBACD,IAAI,EAAE;oBACJ,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,mBAAmB;iBACjC;gBACD,IAAI,EAAE;oBACJ,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,mBAAmB;iBACjC;gBACD,KAAK,EAAE;oBACL,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,yBAAyB,aAAa,UAAU,SAAS,GAAG;iBAC1E;gBACD,MAAM,EAAE;oBACN,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,mCAAmC;iBACjD;aACF;SACF;KACF;IACD;QACE,IAAI,EAAE,aAAa;QACnB,WAAW,EAAE;;0CAEyB;QACtC,WAAW,EAAE;YACX,IAAI,EAAE,QAAQ;YACd,UAAU,EAAE;gBACV,YAAY,EAAE;oBACZ,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,wBAAwB;iBACtC;gBACD,IAAI,EAAE;oBACJ,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,yCAAyC;iBACvD;aACF;YACD,QAAQ,EAAE,CAAC,cAAc,EAAE,MAAM,CAAC;SACnC;KACF;IACD;QACE,IAAI,EAAE,gBAAgB;QACtB,WAAW,EAAE;;;;;;;;;;;;;;;;;;iDAkBgC;QAC7C,WAAW,EAAE;YACX,IAAI,EAAE,QAAQ;YACd,UAAU,EAAE;gBACV,MAAM,EAAE;oBACN,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,mCAAmC;iBACjD;gBACD,IAAI,EAAE;oBACJ,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,WAAW;iBACzB;gBACD,SAAS,EAAE;oBACT,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,+CAA+C;oBAC5D,IAAI,EAAE,CAAC,SAAS,EAAE,UAAU,EAAE,MAAM,CAAC;iBACtC;gBACD,SAAS,EAAE;oBACT,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,mCAAmC;iBACjD;gBACD,KAAK,EAAE;oBACL,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,yBAAyB,aAAa,GAAG;iBACvD;gBACD,MAAM,EAAE;oBACN,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,8FAA8F;oBAC3G,IAAI,EAAE,CAAC,SAAS,EAAE,QAAQ,EAAE,MAAM,CAAC;iBACpC;aACF;YACD,QAAQ,EAAE,CAAC,QAAQ,CAAC;SACrB;KACF;IACD;QACE,IAAI,EAAE,iBAAiB;QACvB,WAAW,EAAE;;;;;;;;;;oEAUmD;QAChE,WAAW,EAAE;YACX,IAAI,EAAE,QAAQ;YACd,UAAU,EAAE;gBACV,IAAI,EAAE;oBACJ,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,mCAAmC;iBACjD;gBACD,WAAW,EAAE;oBACX,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,4BAA4B;iBAC1C;gBACD,KAAK,EAAE;oBACL,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,4BAA4B,aAAa,GAAG;iBAC1D;gBACD,MAAM,EAAE;oBACN,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,sCAAsC;iBACpD;aACF;YACD,QAAQ,EAAE,CAAC,MAAM,CAAC;SACnB;KACF;CACF,CAAC"}

package/dist/definitions/types.d.ts

@@ -0,0 +1,21 @@
+/**
+ * MCP Tool Definition Types
+ */
+export 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[];
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/definitions/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/definitions/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,cAAc;IAC7B,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"}

package/dist/definitions/types.js

@@ -0,0 +1,5 @@
+/**
+ * MCP Tool Definition Types
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/definitions/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/definitions/types.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/dev-proxy.d.ts

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+/**
+ * Grafema MCP Dev Proxy
+ *
+ * A thin stdio proxy that sits between Claude Code and the real MCP server.
+ * It transparently forwards all JSON-RPC messages, with two exceptions:
+ *
+ * 1. Intercepts `tools/call` with `name: "reload"` — kills and respawns the
+ *    child server process so it picks up new code from dist/ after `pnpm build`.
+ *
+ * 2. Injects a `reload` tool definition into `tools/list` responses from the
+ *    real server.
+ *
+ * Architecture:
+ *   Claude Code  <--stdio-->  dev-proxy  <--stdio-->  real server.js
+ *
+ * Usage in .claude/mcp.json:
+ *   {
+ *     "grafema-dev": {
+ *       "command": "node",
+ *       "args": ["packages/mcp/dist/dev-proxy.js", "--project", "/path/to/project"]
+ *     }
+ *   }
+ *
+ * The MCP SDK uses newline-delimited JSON framing (each message is a single
+ * JSON object followed by '\n'). No Content-Length headers.
+ */
+export {};
+//# sourceMappingURL=dev-proxy.d.ts.map

package/dist/dev-proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev-proxy.d.ts","sourceRoot":"","sources":["../src/dev-proxy.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG"}