code-graph-context 1.0.0 → 1.1.0

package/dist/core/embeddings/natural-language-to-cypher.service.js

@@ -7,10 +7,11 @@ export class NaturalLanguageToCypherService {
     messageInstructions = `
 The schema file (neo4j-apoc-schema.json) contains two sections:
 1. rawSchema: Complete Neo4j APOC schema with all node labels, properties, and relationships in the graph
-2. domainContext: Framework-specific semantics including:
-   - nodeTypes: Descriptions and example queries for each node type
-   - relationships: How nodes connect with context about relationship properties
-   - commonQueryPatterns: Pre-built example queries for common use cases
+2. discoveredSchema: Dynamically discovered graph structure including:
+   - nodeTypes: Array of {label, count, properties} for each node type in the graph
+   - relationshipTypes: Array of {type, count, connections} showing relationship types and what they connect
+   - semanticTypes: Array of {type, count} showing semantic node classifications (e.g., Service, Controller)
+   - commonPatterns: Array of {from, relationship, to, count} showing frequent relationship patterns
 
 Your response must be a valid JSON object with this exact structure:
 {
@@ -20,19 +21,17 @@ Your response must be a valid JSON object with this exact structure:
 }
 
 Query Generation Process:
-1. CHECK DOMAIN CONTEXT: Look at domainContext.nodeTypes to understand available node types and their properties
-2. REVIEW EXAMPLES: Check domainContext.commonQueryPatterns for similar query examples
-3. CHECK RELATIONSHIPS: Look at domainContext.relationships to understand how nodes connect
-4. EXAMINE NODE PROPERTIES: Use rawSchema to see exact property names and types
-5. HANDLE JSON PROPERTIES: If properties or relationship context are stored as JSON strings, use apoc.convert.fromJsonMap() to parse them
+1. CHECK NODE TYPES: Look at discoveredSchema.nodeTypes to see available node labels and their properties
+2. CHECK RELATIONSHIPS: Look at discoveredSchema.relationshipTypes to understand how nodes connect
+3. CHECK SEMANTIC TYPES: Look at discoveredSchema.semanticTypes for higher-level node classifications
+4. REVIEW PATTERNS: Check discoveredSchema.commonPatterns for frequent relationship patterns in the graph
+5. EXAMINE PROPERTIES: Use rawSchema for exact property names and types
 6. GENERATE QUERY: Write the Cypher query using only node labels, relationships, and properties that exist in the schema
 
 Critical Rules:
 - Use the schema information from the file_search tool - do not guess node labels or relationships
-- Use ONLY node labels and properties found in rawSchema
-- For nested JSON data in properties, use: apoc.convert.fromJsonMap(node.propertyName) or apoc.convert.fromJsonMap(relationship.context)
-- Check domainContext for parsing instructions specific to certain node types (e.g., some nodes may store arrays of objects in JSON format)
-- Follow the example queries in commonQueryPatterns for proper syntax patterns
+- Use ONLY node labels and properties found in the schema
+- For nested JSON data in properties, use: apoc.convert.fromJsonMap(node.propertyName)
 - Use parameterized queries with $ syntax for any dynamic values
 - Return only the data relevant to the user's request
 

package/dist/core/parsers/parser-factory.js

@@ -69,9 +69,7 @@ export class ParserFactory {
                 ...packageJson.devDependencies,
             };
             const hasNestJS = '@nestjs/common' in deps || '@nestjs/core' in deps;
-            const hasFairSquare = '@fairsquare/core' in deps ||
-                '@fairsquare/server' in deps ||
-                packageJson.name === '@fairsquare/source';
+            const hasFairSquare = '@fairsquare/core' in deps || '@fairsquare/server' in deps || packageJson.name === '@fairsquare/source';
             if (hasFairSquare && hasNestJS) {
                 return ProjectType.BOTH;
             }

package/dist/core/parsers/typescript-parser.js

@@ -171,6 +171,14 @@ export class TypeScriptParser {
                 this.addNode(coreNode);
                 const coreEdge = this.createCoreEdge(edgeType, parentNode.id, coreNode.id);
                 this.addEdge(coreEdge);
+                const SKELETONIZE_TYPES = new Set([
+                    CoreNodeType.METHOD_DECLARATION,
+                    CoreNodeType.FUNCTION_DECLARATION,
+                    CoreNodeType.PROPERTY_DECLARATION,
+                ]);
+                if (SKELETONIZE_TYPES.has(type)) {
+                    this.skeletonizeChildInParent(parentNode, coreNode);
+                }
                 const childNodeConfig = this.coreSchema.nodeTypes[type];
                 if (childNodeConfig) {
                     this.queueRelationshipNodes(childNodeConfig, coreNode, child);
@@ -179,6 +187,15 @@ export class TypeScriptParser {
             }
         }
     }
+    skeletonizeChildInParent(parent, child) {
+        const childText = child.properties.sourceCode;
+        const bodyStart = childText.indexOf('{');
+        if (bodyStart > -1) {
+            const signature = childText.substring(0, bodyStart).trim();
+            const placeholder = `${signature} { /* NodeID: ${child.id} */ }`;
+            parent.properties.sourceCode = parent.properties.sourceCode.replace(childText, placeholder);
+        }
+    }
     /**
      * Queue relationship edges for deferred processing
      * These are resolved after all nodes are parsed since the target may not exist yet
@@ -218,8 +235,12 @@ export class TypeScriptParser {
             return target.getName();
         if (Node.isInterfaceDeclaration(target))
             return target.getName();
-        if (Node.isExpressionWithTypeArguments(target))
-            return target.getExpression().getText();
+        if (Node.isExpressionWithTypeArguments(target)) {
+            const expression = target.getExpression();
+            const text = expression.getText();
+            const genericIndex = text.indexOf('<');
+            return genericIndex > 0 ? text.substring(0, genericIndex) : text;
+        }
         return undefined;
     }
     /**
@@ -231,6 +252,11 @@ export class TypeScriptParser {
                 return node;
             }
         }
+        for (const node of this.existingNodes.values()) {
+            if (node.coreType === coreType && node.properties.name === name) {
+                return node;
+            }
+        }
         return undefined;
     }
     /**

package/dist/mcp/constants.js

@@ -21,6 +21,7 @@ export const TOOL_NAMES = {
     traverseFromNode: 'traverse_from_node',
     parseTypescriptProject: 'parse_typescript_project',
     testNeo4jConnection: 'test_neo4j_connection',
+    impactAnalysis: 'impact_analysis',
 };
 // Tool Metadata
 export const TOOL_METADATA = {
@@ -39,7 +40,6 @@ Start with default parameters for richest context in a single call. Most queries
 
 Parameters:
 - query: Natural language description of what you're looking for
-- limit (default: 10): Number of initial vector search results to consider
 
 **Token Optimization (Only if needed)**:
 Use these parameters ONLY if you encounter token limit errors (>25,000 tokens):
@@ -87,10 +87,27 @@ Best practices:
         title: 'Test Neo4j Connection & APOC',
         description: 'Test connection to Neo4j database and verify APOC plugin is available',
     },
+    [TOOL_NAMES.impactAnalysis]: {
+        title: 'Impact Analysis',
+        description: `Analyze the impact of modifying a code node. Shows what depends on this node and helps assess risk before making changes.
+
+Returns:
+- Risk level (LOW/MEDIUM/HIGH/CRITICAL) based on dependency count and relationship types
+- Direct dependents: nodes that directly reference the target
+- Transitive dependents: nodes affected through dependency chains
+- Affected files: list of files that would need review
+- Critical paths: high-risk dependency chains
+
+Parameters:
+- nodeId: Node ID from search_codebase or traverse_from_node results
+- filePath: Alternative - analyze all exports from a file
+- maxDepth: How far to trace transitive dependencies (default: 4)
+
+Use this before refactoring to understand blast radius of changes.`,
+    },
 };
 // Default Values
 export const DEFAULTS = {
-    searchLimit: 10,
     traversalDepth: 3,
     skipOffset: 0,
     batchSize: 500,

package/dist/mcp/mcp.server.js

@@ -6,8 +6,8 @@
  */
 // Load environment variables from .env file
 import dotenv from 'dotenv';
-import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 // Go up two levels from dist/mcp/mcp.server.js to the root

package/dist/mcp/services.js

@@ -4,7 +4,7 @@
  */
 import fs from 'fs/promises';
 import { join } from 'path';
-import { Neo4jService } from '../storage/neo4j/neo4j.service.js';
+import { Neo4jService, QUERIES } from '../storage/neo4j/neo4j.service.js';
 import { FILE_PATHS, LOG_CONFIG } from './constants.js';
 import { initializeNaturalLanguageService } from './tools/natural-language-to-cypher.tool.js';
 import { debugLog } from './utils.js';
@@ -15,141 +15,62 @@ export const initializeServices = async () => {
     await Promise.all([initializeNeo4jSchema(), initializeNaturalLanguageService()]);
 };
 /**
- * Enrich raw Neo4j schema with FairSquare domain context
+ * Dynamically discover schema from the actual graph contents.
+ * This is framework-agnostic - it discovers what's actually in the graph.
  */
-const enrichSchemaWithDomainContext = (rawSchema) => {
-    return {
-        rawSchema,
-        domainContext: {
-            framework: 'FairSquare',
-            description: 'Custom TypeScript framework for microservices with dependency injection and repository patterns',
-            nodeTypes: {
-                Controller: {
-                    description: 'HTTP request handlers that extend the Controller base class',
-                    purpose: 'Entry points for HTTP API endpoints',
-                    commonProperties: ['name', 'filePath', 'sourceCode'],
-                    exampleQuery: 'MATCH (c:Controller) WHERE c.name =~ ".*Credit.*" RETURN c',
-                },
-                Service: {
-                    description: 'Business logic layer with @Injectable decorator',
-                    purpose: 'Encapsulate business logic and orchestrate data operations',
-                    commonProperties: ['name', 'filePath', 'dependencies'],
-                    exampleQuery: 'MATCH (s:Service)-[:INJECTS]->(dep) RETURN s.name, collect(dep.name) as dependencies',
-                },
-                Repository: {
-                    description: 'Data access layer that extends Repository base class',
-                    purpose: 'Abstract database operations and provide data access interface',
-                    commonProperties: ['name', 'filePath', 'dals'],
-                    exampleQuery: 'MATCH (r:Repository)-[:USES_DAL]->(d:DAL) RETURN r.name, collect(d.name) as dals',
-                },
-                DAL: {
-                    description: 'Data Access Layer - direct database interaction classes',
-                    purpose: 'Execute database queries and manage data persistence',
-                    commonProperties: ['name', 'filePath'],
-                    exampleQuery: 'MATCH (d:DAL)<-[:USES_DAL]-(r:Repository) RETURN d.name, count(r) as usedByCount',
-                },
-                PermissionManager: {
-                    description: 'Security layer for authorization checks',
-                    purpose: 'Control access to resources and validate permissions',
-                    commonProperties: ['name', 'filePath'],
-                    exampleQuery: 'MATCH (c:Controller)-[:PROTECTED_BY]->(pm:PermissionManager) RETURN c.name, pm.name',
-                },
-                VendorClient: {
-                    description: 'External service integration clients',
-                    purpose: 'Interface with third-party APIs and services',
-                    commonProperties: ['name', 'filePath'],
-                    exampleQuery: 'MATCH (v:VendorClient)<-[:INJECTS]-(s) RETURN v.name, collect(s.name) as usedBy',
-                },
-                RouteDefinition: {
-                    description: 'Explicit route definitions from route files. CRITICAL: Individual route details (method, path, authenticated, handler, controllerName) are stored in the "context" property as a JSON string.',
-                    purpose: 'Map HTTP paths and methods to controller handlers',
-                    commonProperties: ['name', 'context', 'filePath', 'sourceCode'],
-                    contextStructure: 'The context property contains JSON with structure: {"routes": [{"method": "POST", "path": "/v1/endpoint", "controllerName": "SomeController", "handler": "methodName", "authenticated": true}]}',
-                    parsingInstructions: 'To get individual routes: (1) Parse JSON with apoc.convert.fromJsonMap(rd.context) (2) UNWIND the routes array (3) Access route.method, route.path, route.handler, route.authenticated, route.controllerName',
-                    exampleQuery: 'MATCH (rd:RouteDefinition) WITH rd, apoc.convert.fromJsonMap(rd.context) AS ctx UNWIND ctx.routes AS route RETURN route.method, route.path, route.controllerName, route.handler, route.authenticated ORDER BY route.path',
-                },
-                HttpEndpoint: {
-                    description: 'Methods that handle HTTP requests',
-                    purpose: 'Process incoming HTTP requests and return responses',
-                    commonProperties: ['name', 'filePath', 'sourceCode'],
-                    exampleQuery: 'MATCH (e:HttpEndpoint)<-[r:ROUTES_TO_HANDLER]-(rd) WHERE apoc.convert.fromJsonMap(r.context).authenticated = true RETURN e.name, apoc.convert.fromJsonMap(r.context).path as path',
-                },
-            },
-            relationships: {
-                INJECTS: {
-                    description: 'Dependency injection relationship from @Injectable decorator',
-                    direction: 'OUTGOING',
-                    example: 'Controller -[:INJECTS]-> Service',
-                    commonPatterns: ['Controller -> Service', 'Service -> Repository', 'Service -> VendorClient'],
-                },
-                USES_DAL: {
-                    description: 'Repository uses Data Access Layer for database operations',
-                    direction: 'OUTGOING',
-                    example: 'Repository -[:USES_DAL]-> DAL',
-                    commonPatterns: ['Repository -> DAL'],
-                },
-                ROUTES_TO: {
-                    description: 'Route definition points to a Controller',
-                    direction: 'OUTGOING',
-                    example: 'RouteDefinition -[:ROUTES_TO]-> Controller',
-                    commonPatterns: ['RouteDefinition -> Controller'],
-                },
-                ROUTES_TO_HANDLER: {
-                    description: 'Route definition points to a specific handler method',
-                    direction: 'OUTGOING',
-                    example: 'RouteDefinition -[:ROUTES_TO_HANDLER]-> HttpEndpoint',
-                    contextProperties: ['path', 'method', 'authenticated', 'handler', 'controllerName'],
-                    contextNote: 'IMPORTANT: context is stored as a JSON string. Access properties using apoc.convert.fromJsonMap(r.context).propertyName',
-                    commonPatterns: ['RouteDefinition -> HttpEndpoint (Method)'],
-                },
-                PROTECTED_BY: {
-                    description: 'Controller is protected by a PermissionManager',
-                    direction: 'OUTGOING',
-                    example: 'Controller -[:PROTECTED_BY]-> PermissionManager',
-                    commonPatterns: ['Controller -> PermissionManager'],
-                },
-            },
-            commonQueryPatterns: [
-                {
-                    intent: 'Find all HTTP endpoints',
-                    query: 'MATCH (e:HttpEndpoint) RETURN e.name, e.filePath',
-                },
-                {
-                    intent: 'Find service dependency chain',
-                    query: 'MATCH path = (c:Controller)-[:INJECTS*1..3]->(s) RETURN [n in nodes(path) | n.name] as chain',
-                },
-                {
-                    intent: 'Find all authenticated routes',
-                    query: 'MATCH (rd:RouteDefinition)-[r:ROUTES_TO_HANDLER]->(m) WHERE apoc.convert.fromJsonMap(r.context).authenticated = true RETURN apoc.convert.fromJsonMap(r.context).path as path, apoc.convert.fromJsonMap(r.context).method as method, m.name',
-                },
-                {
-                    intent: 'Find controllers without permission managers',
-                    query: 'MATCH (c:Controller) WHERE NOT (c)-[:PROTECTED_BY]->(:PermissionManager) RETURN c.name',
-                },
-                {
-                    intent: 'Find what services a controller uses',
-                    query: 'MATCH (c:Controller {name: $controllerName})-[:INJECTS]->(s:Service) RETURN s.name',
-                },
-                {
-                    intent: 'Find complete execution path from controller to database',
-                    query: 'MATCH path = (c:Controller)-[:INJECTS*1..3]->(r:Repository)-[:USES_DAL]->(d:DAL) WHERE c.name = $controllerName RETURN [n in nodes(path) | n.name] as executionPath',
-                },
-            ],
-        },
-    };
+const discoverSchemaFromGraph = async (neo4jService) => {
+    try {
+        // Discover actual node types, relationships, and patterns from the graph
+        const [nodeTypes, relationshipTypes, semanticTypes, commonPatterns] = await Promise.all([
+            neo4jService.run(QUERIES.DISCOVER_NODE_TYPES),
+            neo4jService.run(QUERIES.DISCOVER_RELATIONSHIP_TYPES),
+            neo4jService.run(QUERIES.DISCOVER_SEMANTIC_TYPES),
+            neo4jService.run(QUERIES.DISCOVER_COMMON_PATTERNS),
+        ]);
+        return {
+            nodeTypes: nodeTypes.map((r) => ({
+                label: r.label,
+                count: typeof r.nodeCount === 'object' ? r.nodeCount.toNumber() : r.nodeCount,
+                properties: r.sampleProperties || [],
+            })),
+            relationshipTypes: relationshipTypes.map((r) => ({
+                type: r.relationshipType,
+                count: typeof r.relCount === 'object' ? r.relCount.toNumber() : r.relCount,
+                connections: r.connections || [],
+            })),
+            semanticTypes: semanticTypes.map((r) => ({
+                type: r.semanticType,
+                count: typeof r.count === 'object' ? r.count.toNumber() : r.count,
+            })),
+            commonPatterns: commonPatterns.map((r) => ({
+                from: r.fromType,
+                relationship: r.relType,
+                to: r.toType,
+                count: typeof r.count === 'object' ? r.count.toNumber() : r.count,
+            })),
+        };
+    }
+    catch (error) {
+        await debugLog('Failed to discover schema from graph', error);
+        return null;
+    }
 };
 /**
- * Initialize Neo4j schema by fetching and caching it locally
+ * Initialize Neo4j schema by fetching from APOC and discovering actual graph structure
  */
 const initializeNeo4jSchema = async () => {
     try {
         const neo4jService = new Neo4jService();
         const rawSchema = await neo4jService.getSchema();
-        // Enrich schema with FairSquare domain context
-        const enrichedSchema = enrichSchemaWithDomainContext(rawSchema);
+        // Dynamically discover what's actually in the graph
+        const discoveredSchema = await discoverSchemaFromGraph(neo4jService);
+        const schema = {
+            rawSchema,
+            discoveredSchema,
+        };
         const schemaPath = join(process.cwd(), FILE_PATHS.schemaOutput);
-        await fs.writeFile(schemaPath, JSON.stringify(enrichedSchema, null, LOG_CONFIG.jsonIndentation));
-        await debugLog('Neo4j schema cached successfully with domain context', { schemaPath });
+        await fs.writeFile(schemaPath, JSON.stringify(schema, null, LOG_CONFIG.jsonIndentation));
+        await debugLog('Neo4j schema cached successfully', { schemaPath });
     }
     catch (error) {
         await debugLog('Failed to initialize Neo4j schema', error);

package/dist/mcp/tools/impact-analysis.tool.js

@@ -0,0 +1,253 @@
+/**
+ * Impact Analysis Tool
+ * Analyzes what would be affected if a node is modified
+ * Reuses cross-file edge pattern from incremental parsing
+ */
+import { z } from 'zod';
+import { Neo4jService, QUERIES } from '../../storage/neo4j/neo4j.service.js';
+import { TOOL_NAMES, TOOL_METADATA } from '../constants.js';
+import { createErrorResponse, createSuccessResponse, debugLog } from '../utils.js';
+// Default relationship weights for core AST relationships
+const DEFAULT_RELATIONSHIP_WEIGHTS = {
+    // Critical - inheritance/interface contracts
+    EXTENDS: 0.95,
+    IMPLEMENTS: 0.95,
+    // High - direct code dependencies
+    CALLS: 0.75,
+    HAS_MEMBER: 0.65,
+    TYPED_AS: 0.6,
+    // Medium - module dependencies
+    IMPORTS: 0.5,
+    EXPORTS: 0.5,
+    // Lower - structural
+    CONTAINS: 0.3,
+    HAS_PARAMETER: 0.3,
+    DECORATED_WITH: 0.4,
+};
+// Schema for framework-specific configuration
+const FrameworkConfigSchema = z.object({
+    relationshipWeights: z.record(z.string(), z.number().min(0).max(1)).optional(),
+    highRiskTypes: z.array(z.string()).optional(),
+    name: z.string().optional(),
+});
+export const createImpactAnalysisTool = (server) => {
+    server.registerTool(TOOL_NAMES.impactAnalysis, {
+        title: TOOL_METADATA[TOOL_NAMES.impactAnalysis].title,
+        description: TOOL_METADATA[TOOL_NAMES.impactAnalysis].description,
+        inputSchema: {
+            nodeId: z
+                .string()
+                .optional()
+                .describe('The node ID to analyze impact for (from search_codebase or traverse_from_node results)'),
+            filePath: z
+                .string()
+                .optional()
+                .describe('Alternatively, provide a file path to analyze all exports from that file'),
+            maxDepth: z
+                .number()
+                .int()
+                .min(1)
+                .max(6)
+                .optional()
+                .describe('Maximum depth to traverse for transitive dependents (default: 4)')
+                .default(4),
+            frameworkConfig: FrameworkConfigSchema.optional().describe('Framework-specific configuration for risk scoring. Includes relationshipWeights (e.g., {"INJECTS": 0.9}), highRiskTypes (e.g., ["Controller", "Service"]), and optional name.'),
+        },
+    }, async ({ nodeId, filePath, maxDepth = 4, frameworkConfig }) => {
+        try {
+            if (!nodeId && !filePath) {
+                return createErrorResponse('Either nodeId or filePath must be provided');
+            }
+            await debugLog('Impact analysis started', { nodeId, filePath, maxDepth, frameworkConfig });
+            const neo4jService = new Neo4jService();
+            // Merge default weights with framework-specific weights
+            const weights = { ...DEFAULT_RELATIONSHIP_WEIGHTS, ...frameworkConfig?.relationshipWeights };
+            const highRiskTypes = new Set(frameworkConfig?.highRiskTypes ?? []);
+            let targetInfo;
+            let directDependents;
+            if (nodeId) {
+                // Get target node info
+                const targetResult = await neo4jService.run(QUERIES.GET_NODE_BY_ID, { nodeId });
+                if (targetResult.length === 0) {
+                    return createErrorResponse(`Node with ID "${nodeId}" not found`);
+                }
+                const target = targetResult[0];
+                targetInfo = {
+                    id: target.id,
+                    name: target.name ?? 'Unknown',
+                    type: target.semanticType ?? target.coreType ?? target.labels?.[0] ?? 'Unknown',
+                    filePath: target.filePath ?? '',
+                };
+                // Get direct dependents using cross-file edge pattern
+                const directResult = await neo4jService.run(QUERIES.GET_NODE_IMPACT, { nodeId });
+                directDependents = normalizeDependents(directResult);
+            }
+            else {
+                // File-based analysis
+                targetInfo = {
+                    id: filePath,
+                    name: filePath.split('/').pop() ?? filePath,
+                    type: 'SourceFile',
+                    filePath: filePath,
+                };
+                // Get all external dependents on this file
+                const fileResult = await neo4jService.run(QUERIES.GET_FILE_IMPACT, { filePath });
+                directDependents = normalizeDependents(fileResult);
+            }
+            // Get transitive dependents if nodeId provided
+            let transitiveDependents = [];
+            if (nodeId && maxDepth > 1) {
+                const transitiveResult = await neo4jService.run(QUERIES.GET_TRANSITIVE_DEPENDENTS(maxDepth), { nodeId });
+                transitiveDependents = normalizeTransitiveDependents(transitiveResult);
+                // Filter out direct dependents from transitive
+                const directIds = new Set(directDependents.map((d) => d.nodeId));
+                transitiveDependents = transitiveDependents.filter((d) => !directIds.has(d.nodeId));
+            }
+            // Calculate risk score
+            const riskScore = calculateRiskScore(directDependents, transitiveDependents, weights, highRiskTypes);
+            const riskLevel = getRiskLevel(riskScore);
+            // Group dependents by type
+            const directByType = groupByType(directDependents);
+            const directByRelationship = groupByRelationship(directDependents);
+            const transitiveByType = groupByType(transitiveDependents);
+            // Get affected files
+            const affectedFiles = getAffectedFiles([...directDependents, ...transitiveDependents]);
+            // Find critical paths (high-weight relationships)
+            const criticalPaths = findCriticalPaths(directDependents, targetInfo, weights);
+            // Build summary
+            const summary = buildSummary(targetInfo, directDependents.length, transitiveDependents.length, affectedFiles.length, riskLevel);
+            const result = {
+                target: targetInfo,
+                riskLevel,
+                riskScore: Math.round(riskScore * 100) / 100,
+                summary,
+                directDependents: {
+                    count: directDependents.length,
+                    byType: directByType,
+                    byRelationship: directByRelationship,
+                },
+                transitiveDependents: {
+                    count: transitiveDependents.length,
+                    maxDepth: getMaxDepth(transitiveDependents),
+                    byType: transitiveByType,
+                },
+                affectedFiles,
+                criticalPaths,
+            };
+            await debugLog('Impact analysis complete', {
+                nodeId: nodeId ?? filePath,
+                riskLevel,
+                directCount: directDependents.length,
+                transitiveCount: transitiveDependents.length,
+            });
+            return createSuccessResponse(JSON.stringify(result, null, 2));
+        }
+        catch (error) {
+            console.error('Impact analysis error:', error);
+            await debugLog('Impact analysis error', { nodeId, filePath, error });
+            return createErrorResponse(error);
+        }
+    });
+};
+// Helper functions
+const normalizeDependents = (results) => {
+    return results.map((r) => ({
+        nodeId: r.nodeId,
+        name: r.name ?? 'Unknown',
+        labels: r.labels ?? [],
+        semanticType: r.semanticType,
+        coreType: r.coreType,
+        filePath: r.filePath ?? '',
+        relationshipType: r.relationshipType ?? 'UNKNOWN',
+        weight: typeof r.weight === 'object'
+            ? r.weight.toNumber()
+            : (r.weight ?? 0.5),
+    }));
+};
+const normalizeTransitiveDependents = (results) => {
+    return results.map((r) => ({
+        nodeId: r.nodeId,
+        name: r.name ?? 'Unknown',
+        labels: r.labels ?? [],
+        semanticType: r.semanticType,
+        coreType: r.coreType,
+        filePath: r.filePath ?? '',
+        relationshipType: r.relationshipPath?.[0] ?? 'UNKNOWN',
+        weight: 0.5,
+        depth: typeof r.depth === 'object' ? r.depth.toNumber() : r.depth,
+        relationshipPath: r.relationshipPath,
+    }));
+};
+const calculateRiskScore = (directDependents, transitiveDependents, weights, highRiskTypes) => {
+    if (directDependents.length === 0)
+        return 0;
+    let score = 0;
+    // Factor 1: Number of direct dependents (logarithmic, max 0.3)
+    score += Math.min(Math.log10(directDependents.length + 1) / 2, 0.3);
+    // Factor 2: Average relationship weight of direct deps (max 0.3)
+    const avgWeight = directDependents.reduce((sum, d) => sum + (weights[d.relationshipType] ?? d.weight), 0) / directDependents.length;
+    score += avgWeight * 0.3;
+    // Factor 3: High-risk types affected (max 0.2)
+    const highRiskCount = directDependents.filter((d) => highRiskTypes.has(d.semanticType ?? '') || highRiskTypes.has(d.coreType ?? '')).length;
+    if (highRiskTypes.size > 0) {
+        score += Math.min(highRiskCount / Math.max(highRiskTypes.size, 3), 1) * 0.2;
+    }
+    // Factor 4: Transitive impact (max 0.2)
+    score += Math.min(Math.log10(transitiveDependents.length + 1) / 3, 0.2);
+    return Math.min(score, 1);
+};
+const getRiskLevel = (score) => {
+    if (score >= 0.75)
+        return 'CRITICAL';
+    if (score >= 0.5)
+        return 'HIGH';
+    if (score >= 0.25)
+        return 'MEDIUM';
+    return 'LOW';
+};
+const groupByType = (dependents) => {
+    const groups = {};
+    for (const dep of dependents) {
+        const type = dep.semanticType ?? dep.coreType ?? dep.labels?.[0] ?? 'Unknown';
+        groups[type] = (groups[type] ?? 0) + 1;
+    }
+    return groups;
+};
+const groupByRelationship = (dependents) => {
+    const groups = {};
+    for (const dep of dependents) {
+        groups[dep.relationshipType] = (groups[dep.relationshipType] ?? 0) + 1;
+    }
+    return groups;
+};
+const getAffectedFiles = (dependents) => {
+    const files = new Set();
+    for (const dep of dependents) {
+        if (dep.filePath)
+            files.add(dep.filePath);
+    }
+    return Array.from(files).sort();
+};
+const getMaxDepth = (dependents) => {
+    if (dependents.length === 0)
+        return 0;
+    return Math.max(...dependents.map((d) => d.depth ?? 1));
+};
+const findCriticalPaths = (directDependents, target, weights) => {
+    const paths = [];
+    for (const dep of directDependents) {
+        const relWeight = weights[dep.relationshipType] ?? 0.5;
+        // Only include high-weight relationships
+        if (relWeight >= 0.6) {
+            const depType = dep.semanticType ?? dep.coreType ?? '';
+            paths.push(`${dep.name} (${depType}) -[${dep.relationshipType}]-> ${target.name} (${target.type})`);
+        }
+    }
+    return paths.slice(0, 10);
+};
+const buildSummary = (target, directCount, transitiveCount, fileCount, riskLevel) => {
+    if (directCount === 0) {
+        return `${target.name} (${target.type}) has no external dependents - safe to modify`;
+    }
+    return `Modifying ${target.name} (${target.type}) affects ${directCount} direct and ${transitiveCount} transitive dependents across ${fileCount} files. Risk: ${riskLevel}`;
+};

package/dist/mcp/tools/index.js

@@ -3,6 +3,7 @@
  * Centralized tool creation and registration
  */
 import { createHelloTool } from './hello.tool.js';
+import { createImpactAnalysisTool } from './impact-analysis.tool.js';
 import { createNaturalLanguageToCypherTool } from './natural-language-to-cypher.tool.js';
 import { createParseTypescriptProjectTool } from './parse-typescript-project.tool.js';
 import { createSearchCodebaseTool } from './search-codebase.tool.js';
@@ -19,6 +20,7 @@ export const registerAllTools = (server) => {
     createSearchCodebaseTool(server);
     createTraverseFromNodeTool(server);
     createNaturalLanguageToCypherTool(server);
+    createImpactAnalysisTool(server);
     // Register project parsing tool
     createParseTypescriptProjectTool(server);
 };

package/dist/mcp/tools/parse-typescript-project.tool.js

@@ -63,7 +63,9 @@ export const createParseTypescriptProjectTool = (server) => {
                 // Recreate cross-file edges after incremental parse
                 if (!clearExisting && savedCrossFileEdges.length > 0) {
                     await debugLog('Recreating cross-file edges', { edgesToRecreate: savedCrossFileEdges.length });
-                    const recreateResult = await neo4jService.run(QUERIES.RECREATE_CROSS_FILE_EDGES, { edges: savedCrossFileEdges });
+                    const recreateResult = await neo4jService.run(QUERIES.RECREATE_CROSS_FILE_EDGES, {
+                        edges: savedCrossFileEdges,
+                    });
                     const recreatedCount = recreateResult[0]?.recreatedCount ?? 0;
                     await debugLog('Cross-file edges recreated', { recreatedCount, expected: savedCrossFileEdges.length });
                 }
@@ -112,7 +114,10 @@ const parseProject = async (options) => {
             await deleteSourceFileSubgraphs(neo4jService, filesToRemoveFromGraph);
         }
         if (filesToReparse.length > 0) {
-            await debugLog('Incremental parse starting', { filesChanged: filesToReparse.length, filesDeleted: filesToDelete.length });
+            await debugLog('Incremental parse starting', {
+                filesChanged: filesToReparse.length,
+                filesDeleted: filesToDelete.length,
+            });
             // Load existing nodes from Neo4j for edge target matching
             const existingNodes = await loadExistingNodesForEdgeDetection(neo4jService, filesToRemoveFromGraph);
             await debugLog('Loaded existing nodes for edge detection', { count: existingNodes.length });

package/dist/mcp/tools/search-codebase.tool.js

@@ -14,12 +14,6 @@ export const createSearchCodebaseTool = (server) => {
         description: TOOL_METADATA[TOOL_NAMES.searchCodebase].description,
         inputSchema: {
             query: z.string().describe('Natural language query to search the codebase'),
-            limit: z
-                .number()
-                .int()
-                .optional()
-                .describe(`Maximum number of results to return (default: ${DEFAULTS.searchLimit})`)
-                .default(DEFAULTS.searchLimit),
             maxDepth: z
                 .number()
                 .int()
@@ -50,19 +44,19 @@ export const createSearchCodebaseTool = (server) => {
                 .describe('Use weighted traversal strategy that scores each node for relevance (default: false)')
                 .default(true),
         },
-    }, async ({ query, limit = DEFAULTS.searchLimit, maxDepth = DEFAULTS.traversalDepth, maxNodesPerChain = 5, skip = 0, includeCode = true, snippetLength = DEFAULTS.codeSnippetLength, useWeightedTraversal = true, }) => {
+    }, async ({ query, maxDepth = DEFAULTS.traversalDepth, maxNodesPerChain = 5, skip = 0, includeCode = true, snippetLength = DEFAULTS.codeSnippetLength, useWeightedTraversal = true, }) => {
         try {
-            await debugLog('Search codebase started', { query, limit });
+            await debugLog('Search codebase started', { query });
             const neo4jService = new Neo4jService();
             const embeddingsService = new EmbeddingsService();
             const traversalHandler = new TraversalHandler(neo4jService);
             const embedding = await embeddingsService.embedText(query);
             const vectorResults = await neo4jService.run(QUERIES.VECTOR_SEARCH, {
-                limit: parseInt(limit.toString()),
+                limit: 1,
                 embedding,
             });
             if (vectorResults.length === 0) {
-                await debugLog('No relevant code found', { query, limit });
+                await debugLog('No relevant code found', { query });
                 return createSuccessResponse(MESSAGES.errors.noRelevantCode);
             }
             const startNode = vectorResults[0].node;

package/dist/mcp/utils.js

@@ -55,7 +55,8 @@ export const formatNodeInfo = (value, key) => {
             else {
                 // Show first 500 and last 500 characters
                 const half = Math.floor(maxLength / 2);
-                result.sourceCode = code.substring(0, half) + '\n\n... [truncated] ...\n\n' + code.substring(code.length - half);
+                result.sourceCode =
+                    code.substring(0, half) + '\n\n... [truncated] ...\n\n' + code.substring(code.length - half);
                 result.hasMore = true;
                 result.truncated = code.length - maxLength;
             }

package/dist/storage/neo4j/neo4j.service.js

@@ -329,4 +329,144 @@ export const QUERIES = {
       LIMIT ${maxNodesPerDepth}
     `;
     },
+    // ============================================
+    // DYNAMIC SCHEMA DISCOVERY QUERIES
+    // ============================================
+    /**
+     * Get all distinct node labels with counts and sample properties
+     */
+    DISCOVER_NODE_TYPES: `
+    CALL db.labels() YIELD label
+    CALL {
+      WITH label
+      MATCH (n) WHERE label IN labels(n)
+      WITH n LIMIT 1
+      RETURN keys(n) AS sampleProperties
+    }
+    CALL {
+      WITH label
+      MATCH (n) WHERE label IN labels(n)
+      RETURN count(n) AS nodeCount
+    }
+    RETURN label, nodeCount, sampleProperties
+    ORDER BY nodeCount DESC
+  `,
+    /**
+     * Get all distinct relationship types with counts and which node types they connect
+     */
+    DISCOVER_RELATIONSHIP_TYPES: `
+    CALL db.relationshipTypes() YIELD relationshipType
+    CALL {
+      WITH relationshipType
+      MATCH (a)-[r]->(b) WHERE type(r) = relationshipType
+      WITH labels(a)[0] AS fromLabel, labels(b)[0] AS toLabel
+      RETURN fromLabel, toLabel
+      LIMIT 10
+    }
+    CALL {
+      WITH relationshipType
+      MATCH ()-[r]->() WHERE type(r) = relationshipType
+      RETURN count(r) AS relCount
+    }
+    RETURN relationshipType, relCount, collect(DISTINCT {from: fromLabel, to: toLabel}) AS connections
+    ORDER BY relCount DESC
+  `,
+    /**
+     * Get sample nodes of each semantic type for context
+     */
+    DISCOVER_SEMANTIC_TYPES: `
+    MATCH (n)
+    WHERE n.semanticType IS NOT NULL
+    WITH n.semanticType AS semanticType, count(*) AS count
+    ORDER BY count DESC
+    RETURN semanticType, count
+  `,
+    /**
+     * Get example query patterns based on actual graph structure
+     */
+    DISCOVER_COMMON_PATTERNS: `
+    MATCH (a)-[r]->(b)
+    WITH labels(a)[0] AS fromType, type(r) AS relType, labels(b)[0] AS toType, count(*) AS count
+    WHERE count > 5
+    RETURN fromType, relType, toType, count
+    ORDER BY count DESC
+    LIMIT 20
+  `,
+    // ============================================
+    // IMPACT ANALYSIS QUERIES
+    // Reuses cross-file edge pattern to find dependents
+    // ============================================
+    /**
+     * Get node details by ID
+     */
+    GET_NODE_BY_ID: `
+    MATCH (n) WHERE n.id = $nodeId
+    RETURN n.id AS id,
+           n.name AS name,
+           labels(n) AS labels,
+           n.semanticType AS semanticType,
+           n.coreType AS coreType,
+           n.filePath AS filePath
+  `,
+    /**
+     * Get impact of changing a node - finds all external nodes that depend on it
+     * Based on GET_CROSS_FILE_EDGES pattern but for a single node
+     */
+    GET_NODE_IMPACT: `
+    MATCH (target) WHERE target.id = $nodeId
+    MATCH (dependent)-[r]->(target)
+    WHERE dependent.id <> target.id
+    RETURN DISTINCT
+      dependent.id AS nodeId,
+      dependent.name AS name,
+      labels(dependent) AS labels,
+      dependent.semanticType AS semanticType,
+      dependent.coreType AS coreType,
+      dependent.filePath AS filePath,
+      type(r) AS relationshipType,
+      coalesce(r.relationshipWeight, 0.5) AS weight
+  `,
+    /**
+     * Get impact of changing a file - finds all external nodes that depend on nodes in this file
+     * Directly reuses GET_CROSS_FILE_EDGES pattern
+     */
+    GET_FILE_IMPACT: `
+    MATCH (sf:SourceFile {filePath: $filePath})
+    OPTIONAL MATCH (sf)-[*]->(child)
+    WITH collect(DISTINCT sf) + collect(DISTINCT child) AS nodesInFile
+    UNWIND nodesInFile AS n
+    MATCH (dependent)-[r]->(n)
+    WHERE NOT dependent IN nodesInFile
+    RETURN DISTINCT
+      dependent.id AS nodeId,
+      dependent.name AS name,
+      labels(dependent) AS labels,
+      dependent.semanticType AS semanticType,
+      dependent.coreType AS coreType,
+      dependent.filePath AS filePath,
+      type(r) AS relationshipType,
+      coalesce(r.relationshipWeight, 0.5) AS weight,
+      n.id AS targetNodeId,
+      n.name AS targetNodeName
+  `,
+    /**
+     * Get transitive dependents - nodes that depend on dependents (for deeper impact)
+     */
+    GET_TRANSITIVE_DEPENDENTS: (maxDepth = 4) => `
+    MATCH (target) WHERE target.id = $nodeId
+    MATCH path = (dependent)-[*2..${maxDepth}]->(target)
+    WITH dependent,
+         length(path) AS depth,
+         [r IN relationships(path) | type(r)] AS relationshipPath
+    RETURN DISTINCT
+      dependent.id AS nodeId,
+      dependent.name AS name,
+      labels(dependent) AS labels,
+      dependent.semanticType AS semanticType,
+      dependent.coreType AS coreType,
+      dependent.filePath AS filePath,
+      depth,
+      relationshipPath
+    ORDER BY depth ASC
+  `,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-graph-context",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "MCP server that builds code graphs to provide rich context to LLMs",
   "type": "module",
   "homepage": "https://github.com/drewdrewH/code-graph-context#readme",