code-graph-context 2.3.0 → 2.4.1

package/README.md

@@ -65,100 +65,90 @@ The system uses a dual-schema approach:
 
 Choose the installation method that works best for you:
 
-#### Option 1: Development Install (From Source)
+#### Option 1: NPM Install (Recommended)
 
-Best for: Contributing to the project or customizing the code
-
-1. **Clone the repository:**
 ```bash
-git clone https://github.com/drewdrewH/code-graph-context.git
-cd code-graph-context
-```
+# Install globally
+npm install -g code-graph-context
 
-2. **Install dependencies:**
-```bash
-npm install
+# Set up Neo4j (requires Docker)
+code-graph-context init
+
+# Add to Claude Code
+claude mcp add code-graph-context code-graph-context
 ```
 
-3. **Set up Neo4j using Docker:**
-```bash
-docker-compose up -d
+Then configure your OpenAI API key in `~/.config/claude/config.json`:
+```json
+{
+  "mcpServers": {
+    "code-graph-context": {
+      "command": "code-graph-context",
+      "env": {
+        "OPENAI_API_KEY": "sk-your-key-here"
+      }
+    }
+  }
+}
 ```
 
-This will start Neo4j with:
-- Web interface: http://localhost:7474
-- Bolt connection: bolt://localhost:7687
-- Username: `neo4j`, Password: `PASSWORD`
+#### Option 2: From Source
 
-4. **Configure environment variables:**
 ```bash
-cp .env.example .env
-# Edit .env with your configuration
+# Clone and build
+git clone https://github.com/drewdrewH/code-graph-context.git
+cd code-graph-context
+npm install
+npm run build
+
+# Set up Neo4j
+code-graph-context init
+
+# Add to Claude Code (use absolute path)
+claude mcp add code-graph-context node /absolute/path/to/code-graph-context/dist/cli/cli.js
 ```
 
-5. **Build the project:**
+### CLI Commands
+
+The package includes a CLI for managing Neo4j:
+
 ```bash
-npm run build
+code-graph-context init [options]   # Set up Neo4j container
+code-graph-context status           # Check Docker/Neo4j status
+code-graph-context stop             # Stop Neo4j container
 ```
 
-6. **Add to Claude Code:**
-```bash
-claude mcp add code-graph-context node /absolute/path/to/code-graph-context/dist/mcp/mcp.server.js
+**Init options:**
+```
+-p, --port <port>       Bolt port (default: 7687)
+--http-port <port>      Browser port (default: 7474)
+--password <password>   Neo4j password (default: PASSWORD)
+-m, --memory <size>     Heap memory (default: 2G)
+-f, --force             Recreate container
 ```
 
-#### Option 2: NPM Install (Global Package)
+### Alternative Neo4j Setup
 
-Best for: Easy setup and automatic updates
+If you prefer not to use the CLI, you can set up Neo4j manually:
 
-1. **Install the package globally:**
+**Docker Compose:**
 ```bash
-npm install -g code-graph-context
+docker-compose up -d
 ```
 
-2. **Set up Neo4j** (choose one):
-
-**Option A: Docker (Recommended)**
+**Docker Run:**
 ```bash
 docker run -d \
   --name code-graph-neo4j \
   -p 7474:7474 -p 7687:7687 \
   -e NEO4J_AUTH=neo4j/PASSWORD \
-  -e NEO4J_PLUGINS='["apoc"]' \
+  -e 'NEO4J_PLUGINS=["apoc"]' \
   neo4j:5.23
 ```
 
-**Option B: Neo4j Desktop**
-- Download from [neo4j.com/download](https://neo4j.com/download/)
-- Install APOC plugin
-- Start database
-
-**Option C: Neo4j Aura (Cloud)**
-- Create free account at [neo4j.com/cloud/aura](https://neo4j.com/cloud/platform/aura-graph-database/)
-- Note your connection URI and credentials
-
-3. **Add to Claude Code:**
-```bash
-claude mcp add code-graph-context code-graph-context
-```
-
-Then configure in your MCP config file (`~/.config/claude/config.json`):
-```json
-{
-  "mcpServers": {
-    "code-graph-context": {
-      "command": "code-graph-context",
-      "env": {
-        "OPENAI_API_KEY": "sk-your-key-here",
-        "NEO4J_URI": "bolt://localhost:7687",
-        "NEO4J_USER": "neo4j",
-        "NEO4J_PASSWORD": "PASSWORD"
-      }
-    }
-  }
-}
-```
+**Neo4j Desktop:** Download from [neo4j.com/download](https://neo4j.com/download/) and install APOC plugin.
 
-**Note:** The env vars can be configured for any Neo4j instance - local, Docker, cloud (Aura), or enterprise.
+**Neo4j Aura (Cloud):** Create account at [neo4j.com/cloud/aura](https://neo4j.com/cloud/platform/aura-graph-database/) and configure connection URI in env vars.
 
 ### Verify Installation
 

package/dist/cli/cli.js

@@ -0,0 +1,266 @@
+#!/usr/bin/env node
+/**
+ * CLI Entry Point for Code Graph Context
+ *
+ * Handles CLI commands (init, status, stop) and delegates to MCP server
+ */
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { Command } from 'commander';
+import { NEO4J_CONFIG, createContainer, getContainerStatus, getFullStatus, isApocAvailable, isDockerInstalled, isDockerRunning, removeContainer, startContainer, stopContainer, waitForNeo4j, } from './neo4j-docker.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// ANSI colors
+const c = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    green: '\x1b[32m',
+    red: '\x1b[31m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    cyan: '\x1b[36m',
+};
+const sym = {
+    ok: `${c.green}✓${c.reset}`,
+    err: `${c.red}✗${c.reset}`,
+    warn: `${c.yellow}⚠${c.reset}`,
+    info: `${c.blue}ℹ${c.reset}`,
+};
+const log = (symbol, msg) => {
+    console.log(`  ${symbol} ${msg}`);
+};
+const header = (text) => {
+    console.log(`\n${c.bold}${text}${c.reset}\n`);
+};
+/**
+ * Spinner for async operations
+ */
+const spinner = (msg) => {
+    const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    let i = 0;
+    const interval = setInterval(() => {
+        process.stdout.write(`\r  ${c.blue}${frames[i]}${c.reset} ${msg}`);
+        i = (i + 1) % frames.length;
+    }, 80);
+    return {
+        stop: (ok, finalMsg) => {
+            clearInterval(interval);
+            process.stdout.write(`\r  ${ok ? sym.ok : sym.err} ${finalMsg || msg}\n`);
+        },
+    };
+};
+/**
+ * Print config instructions
+ */
+const printConfigInstructions = (password, boltPort) => {
+    console.log(`
+${c.bold}Next steps:${c.reset}
+
+  1. Add to Claude Code:
+     ${c.dim}claude mcp add code-graph-context code-graph-context${c.reset}
+
+  2. Configure in ${c.cyan}~/.config/claude/config.json${c.reset}:
+
+     ${c.dim}{
+       "mcpServers": {
+         "code-graph-context": {
+           "command": "code-graph-context",
+           "env": {
+             "OPENAI_API_KEY": "sk-..."${password !== NEO4J_CONFIG.defaultPassword
+        ? `,
+             "NEO4J_PASSWORD": "${password}"`
+        : ''}${boltPort !== NEO4J_CONFIG.boltPort
+        ? `,
+             "NEO4J_URI": "bolt://localhost:${boltPort}"`
+        : ''}
+           }
+         }
+       }
+     }${c.reset}
+
+     ${c.yellow}Get your OpenAI API key:${c.reset} https://platform.openai.com/api-keys
+
+  3. Restart Claude Code
+`);
+};
+/**
+ * Init command - set up Neo4j
+ */
+const runInit = async (options) => {
+    const boltPort = options.port ? parseInt(options.port, 10) : NEO4J_CONFIG.boltPort;
+    const httpPort = options.httpPort ? parseInt(options.httpPort, 10) : NEO4J_CONFIG.httpPort;
+    const password = options.password || NEO4J_CONFIG.defaultPassword;
+    const memory = options.memory || '4G';
+    header('Code Graph Context Setup');
+    // Check Docker
+    if (!isDockerInstalled()) {
+        log(sym.err, 'Docker is not installed');
+        console.log(`\n  Install Docker: ${c.cyan}https://docs.docker.com/get-docker/${c.reset}\n`);
+        process.exit(1);
+    }
+    log(sym.ok, 'Docker installed');
+    if (!isDockerRunning()) {
+        log(sym.err, 'Docker daemon is not running');
+        console.log(`\n  Start Docker Desktop or run: ${c.dim}sudo systemctl start docker${c.reset}\n`);
+        process.exit(1);
+    }
+    log(sym.ok, 'Docker daemon running');
+    // Handle existing container
+    const status = getContainerStatus();
+    if (status === 'running' && !options.force) {
+        log(sym.ok, 'Neo4j container already running');
+        const apocOk = isApocAvailable(NEO4J_CONFIG.containerName, password);
+        log(apocOk ? sym.ok : sym.warn, apocOk ? 'APOC plugin available' : 'APOC plugin not detected');
+        console.log(`\n  ${c.dim}Use --force to recreate the container${c.reset}`);
+        printConfigInstructions(password, boltPort);
+        return;
+    }
+    if (status !== 'not-found' && options.force) {
+        const s = spinner('Removing existing container...');
+        stopContainer();
+        removeContainer();
+        s.stop(true, 'Removed existing container');
+    }
+    if (status === 'stopped' && !options.force) {
+        const s = spinner('Starting existing container...');
+        const started = startContainer();
+        if (!started) {
+            s.stop(false, 'Failed to start container');
+            console.log(`\n  Try: ${c.dim}code-graph-context init --force${c.reset}\n`);
+            process.exit(1);
+        }
+        s.stop(true, 'Container started');
+    }
+    else if (status === 'not-found' || options.force) {
+        const s = spinner('Creating Neo4j container...');
+        const created = createContainer({ httpPort, boltPort, password, memory });
+        if (!created) {
+            s.stop(false, 'Failed to create container');
+            console.log(`
+  Check if ports are in use:
+    ${c.dim}lsof -i :${httpPort}${c.reset}
+    ${c.dim}lsof -i :${boltPort}${c.reset}
+`);
+            process.exit(1);
+        }
+        s.stop(true, 'Container created');
+    }
+    // Wait for Neo4j
+    const healthSpinner = spinner('Waiting for Neo4j to be ready (this may take a minute)...');
+    const ready = await waitForNeo4j(NEO4J_CONFIG.containerName, password);
+    healthSpinner.stop(ready, ready ? 'Neo4j is ready' : 'Neo4j failed to start');
+    if (!ready) {
+        console.log(`\n  Check logs: ${c.dim}docker logs ${NEO4J_CONFIG.containerName}${c.reset}\n`);
+        process.exit(1);
+    }
+    // Check APOC
+    const apocOk = isApocAvailable(NEO4J_CONFIG.containerName, password);
+    log(apocOk ? sym.ok : sym.warn, apocOk ? 'APOC plugin verified' : 'APOC still loading (should be ready shortly)');
+    // Print connection info
+    console.log(`
+${c.bold}Neo4j is ready${c.reset}
+
+  Browser:     ${c.cyan}http://localhost:${httpPort}${c.reset}
+  Bolt URI:    ${c.cyan}bolt://localhost:${boltPort}${c.reset}
+  Credentials: ${c.dim}neo4j / ${password}${c.reset}`);
+    printConfigInstructions(password, boltPort);
+};
+/**
+ * Status command
+ */
+const runStatus = () => {
+    header('Code Graph Context Status');
+    const status = getFullStatus();
+    log(status.dockerInstalled ? sym.ok : sym.err, `Docker installed: ${status.dockerInstalled ? 'yes' : 'no'}`);
+    if (!status.dockerInstalled) {
+        console.log(`\n  Install: ${c.cyan}https://docs.docker.com/get-docker/${c.reset}\n`);
+        return;
+    }
+    log(status.dockerRunning ? sym.ok : sym.err, `Docker running: ${status.dockerRunning ? 'yes' : 'no'}`);
+    if (!status.dockerRunning) {
+        console.log(`\n  Start Docker Desktop or: ${c.dim}sudo systemctl start docker${c.reset}\n`);
+        return;
+    }
+    const containerIcon = status.containerStatus === 'running' ? sym.ok : status.containerStatus === 'stopped' ? sym.warn : sym.err;
+    log(containerIcon, `Container: ${status.containerStatus}`);
+    if (status.containerStatus === 'running') {
+        log(status.neo4jReady ? sym.ok : sym.warn, `Neo4j responding: ${status.neo4jReady ? 'yes' : 'no'}`);
+        log(status.apocAvailable ? sym.ok : sym.warn, `APOC plugin: ${status.apocAvailable ? 'available' : 'not available'}`);
+    }
+    console.log('');
+    if (status.containerStatus !== 'running') {
+        console.log(`  Run ${c.dim}code-graph-context init${c.reset} to start Neo4j\n`);
+    }
+    else if (!status.apocAvailable) {
+        console.log(`  APOC may still be loading. Wait a moment and check again.\n`);
+    }
+};
+/**
+ * Stop command
+ */
+const runStop = () => {
+    const status = getContainerStatus();
+    if (status === 'not-found') {
+        log(sym.info, 'No Neo4j container found');
+        return;
+    }
+    if (status === 'stopped') {
+        log(sym.info, 'Container already stopped');
+        return;
+    }
+    const s = spinner('Stopping Neo4j...');
+    const stopped = stopContainer();
+    s.stop(stopped, stopped ? 'Neo4j stopped' : 'Failed to stop container');
+};
+/**
+ * Start MCP server
+ */
+const startMcpServer = async () => {
+    // The MCP server is in a sibling directory after build
+    // cli/cli.js -> mcp/mcp.server.js
+    const mcpPath = join(__dirname, '..', 'mcp', 'mcp.server.js');
+    await import(mcpPath);
+};
+/**
+ * Get package version
+ */
+const getVersion = () => {
+    try {
+        // Go up from dist/cli to root
+        const pkgPath = join(__dirname, '..', '..', 'package.json');
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        return pkg.version;
+    }
+    catch {
+        return 'unknown';
+    }
+};
+// Build CLI
+const program = new Command();
+program.name('code-graph-context').description('MCP server for code graph analysis with Neo4j').version(getVersion());
+program
+    .command('init')
+    .description('Set up Neo4j container and show configuration steps')
+    .option('-p, --port <port>', 'Neo4j Bolt port', '7687')
+    .option('--http-port <port>', 'Neo4j Browser port', '7474')
+    .option('--password <password>', 'Neo4j password', 'PASSWORD')
+    .option('-m, --memory <size>', 'Max heap memory (e.g., 2G, 4G)', '2G')
+    .option('-f, --force', 'Recreate container even if exists')
+    .action(runInit);
+program.command('status').description('Check Neo4j and Docker status').action(runStatus);
+program.command('stop').description('Stop the Neo4j container').action(runStop);
+// Default action: start MCP server if no command given
+const knownCommands = ['init', 'status', 'stop', 'help'];
+const args = process.argv.slice(2);
+const hasCommand = args.some((arg) => knownCommands.includes(arg) || arg.startsWith('-'));
+if (args.length === 0 || !hasCommand) {
+    startMcpServer().catch((err) => {
+        console.error('Failed to start MCP server:', err);
+        process.exit(1);
+    });
+}
+else {
+    program.parse();
+}

package/dist/cli/neo4j-docker.js

@@ -0,0 +1,159 @@
+/**
+ * Neo4j Docker Management
+ *
+ * Handles Docker container lifecycle for Neo4j
+ */
+import { execSync } from 'child_process';
+// Container configuration
+export const NEO4J_CONFIG = {
+    containerName: 'code-graph-neo4j',
+    image: 'neo4j:5.23',
+    httpPort: 7474,
+    boltPort: 7687,
+    defaultPassword: 'PASSWORD',
+    defaultUser: 'neo4j',
+    healthCheckTimeoutMs: 120000,
+    healthCheckIntervalMs: 2000,
+};
+/**
+ * Execute a command and return stdout, or null if failed
+ */
+const exec = (command) => {
+    try {
+        return execSync(command, {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * Check if Docker CLI is available
+ */
+export const isDockerInstalled = () => exec('docker --version') !== null;
+/**
+ * Check if Docker daemon is running
+ */
+export const isDockerRunning = () => exec('docker info') !== null;
+/**
+ * Get container status
+ */
+export const getContainerStatus = (containerName = NEO4J_CONFIG.containerName) => {
+    const result = exec(`docker inspect --format='{{.State.Running}}' ${containerName} 2>/dev/null`);
+    if (result === null)
+        return 'not-found';
+    return result === 'true' ? 'running' : 'stopped';
+};
+/**
+ * Start an existing stopped container
+ */
+export const startContainer = (containerName = NEO4J_CONFIG.containerName) => exec(`docker start ${containerName}`) !== null;
+/**
+ * Stop a running container
+ */
+export const stopContainer = (containerName = NEO4J_CONFIG.containerName) => exec(`docker stop ${containerName}`) !== null;
+/**
+ * Remove a container
+ */
+export const removeContainer = (containerName = NEO4J_CONFIG.containerName) => exec(`docker rm ${containerName}`) !== null;
+/**
+ * Create and start a new Neo4j container
+ */
+export const createContainer = (options = {}) => {
+    const { containerName = NEO4J_CONFIG.containerName, httpPort = NEO4J_CONFIG.httpPort, boltPort = NEO4J_CONFIG.boltPort, password = NEO4J_CONFIG.defaultPassword, memory = '2G', } = options;
+    const cmd = [
+        'docker run -d',
+        `--name ${containerName}`,
+        `--restart unless-stopped`,
+        `-p ${httpPort}:7474`,
+        `-p ${boltPort}:7687`,
+        `-e NEO4J_AUTH=neo4j/${password}`,
+        `-e 'NEO4J_PLUGINS=["apoc"]'`,
+        `-e NEO4J_dbms_security_procedures_unrestricted=apoc.*`,
+        `-e NEO4J_server_memory_heap_initial__size=1G`,
+        `-e NEO4J_server_memory_heap_max__size=${memory}`,
+        `-e NEO4J_server_memory_pagecache_size=2G`,
+        NEO4J_CONFIG.image,
+    ].join(' ');
+    return exec(cmd) !== null;
+};
+/**
+ * Check if Neo4j is accepting connections
+ */
+export const isNeo4jReady = (containerName = NEO4J_CONFIG.containerName, password = NEO4J_CONFIG.defaultPassword) => {
+    const result = exec(`docker exec ${containerName} cypher-shell -u neo4j -p ${password} "RETURN 1" 2>/dev/null`);
+    return result !== null;
+};
+/**
+ * Check if APOC plugin is available
+ */
+export const isApocAvailable = (containerName = NEO4J_CONFIG.containerName, password = NEO4J_CONFIG.defaultPassword) => {
+    const result = exec(`docker exec ${containerName} cypher-shell -u neo4j -p ${password} "CALL apoc.help('apoc') YIELD name RETURN count(name)" 2>/dev/null`);
+    return result !== null && !result.includes('error');
+};
+/**
+ * Wait for Neo4j to be ready
+ */
+export const waitForNeo4j = async (containerName = NEO4J_CONFIG.containerName, password = NEO4J_CONFIG.defaultPassword, timeoutMs = NEO4J_CONFIG.healthCheckTimeoutMs) => {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+        if (isNeo4jReady(containerName, password)) {
+            return true;
+        }
+        await new Promise((resolve) => setTimeout(resolve, NEO4J_CONFIG.healthCheckIntervalMs));
+    }
+    return false;
+};
+/**
+ * Ensure Neo4j is running - start if needed
+ */
+export const ensureNeo4jRunning = async (options = {}) => {
+    const containerName = options.containerName ?? NEO4J_CONFIG.containerName;
+    const status = getContainerStatus(containerName);
+    if (status === 'running') {
+        return { success: true, action: 'already-running' };
+    }
+    if (!isDockerInstalled()) {
+        return { success: false, action: 'failed', error: 'Docker not installed' };
+    }
+    if (!isDockerRunning()) {
+        return { success: false, action: 'failed', error: 'Docker daemon not running' };
+    }
+    // Start existing container
+    if (status === 'stopped') {
+        if (startContainer(containerName)) {
+            const ready = await waitForNeo4j(containerName, options.password);
+            return ready
+                ? { success: true, action: 'started' }
+                : { success: false, action: 'failed', error: 'Container started but Neo4j not responding' };
+        }
+        return { success: false, action: 'failed', error: 'Failed to start existing container' };
+    }
+    // Create new container
+    if (createContainer(options)) {
+        const ready = await waitForNeo4j(containerName, options.password);
+        return ready
+            ? { success: true, action: 'created' }
+            : { success: false, action: 'failed', error: 'Container created but Neo4j not responding' };
+    }
+    return { success: false, action: 'failed', error: 'Failed to create container' };
+};
+/**
+ * Get full status for diagnostics
+ */
+export const getFullStatus = () => {
+    const dockerInstalled = isDockerInstalled();
+    const dockerRunning = dockerInstalled && isDockerRunning();
+    const containerStatus = dockerRunning ? getContainerStatus() : 'not-found';
+    const neo4jReady = containerStatus === 'running' && isNeo4jReady();
+    const apocAvailable = neo4jReady && isApocAvailable();
+    return {
+        dockerInstalled,
+        dockerRunning,
+        containerStatus,
+        neo4jReady,
+        apocAvailable,
+    };
+};

package/dist/core/config/fairsquare-framework-schema.js

@@ -525,13 +525,11 @@ export const FAIRSQUARE_FRAMEWORK_SCHEMA = {
                 {
                     type: 'function',
                     pattern: (parsedNode) => {
-                        const node = parsedNode.sourceNode;
-                        if (!node || !Node.isVariableDeclaration(node))
-                            return false;
-                        const name = node.getName();
-                        const typeNode = node.getTypeNode();
+                        // Use pre-extracted properties (works after AST cleanup in streaming/chunking)
+                        const name = parsedNode.properties.name;
+                        const typeAnnotation = parsedNode.properties.typeAnnotation;
                         // Check if variable name ends with "Routes" AND has type ModuleRoute[]
-                        return !!name.endsWith('Routes') && !!typeNode?.getText().includes('ModuleRoute');
+                        return !!name?.endsWith('Routes') && !!typeAnnotation?.includes('ModuleRoute');
                     },
                     confidence: 1.0,
                     priority: 10,
@@ -696,14 +694,8 @@ export const FAIRSQUARE_FRAMEWORK_SCHEMA = {
                 if (matchingRoutes.length === 0)
                     return false;
                 // CRITICAL FIX: Verify the method belongs to the correct controller
-                // Find the parent class of this method by checking the AST node
-                const targetNode = parsedTargetNode.sourceNode;
-                if (!targetNode || !Node.isMethodDeclaration(targetNode))
-                    return false;
-                const parentClass = targetNode.getParent();
-                if (!parentClass || !Node.isClassDeclaration(parentClass))
-                    return false;
-                const parentClassName = parentClass.getName();
+                // Use pre-extracted parentClassName property (works after AST cleanup in streaming/chunking)
+                const parentClassName = parsedTargetNode.properties.parentClassName;
                 if (!parentClassName)
                     return false;
                 // Check if any matching route's controller name matches the parent class

package/dist/core/config/nestjs-framework-schema.js

@@ -434,7 +434,7 @@ export const NESTJS_FRAMEWORK_SCHEMA = {
                 },
                 {
                     type: 'function',
-                    pattern: (node) => node.getName()?.endsWith('Service'),
+                    pattern: (parsedNode) => parsedNode.sourceNode?.getName()?.endsWith('Service'),
                     confidence: 0.7,
                     priority: 7,
                 },
@@ -516,7 +516,10 @@ export const NESTJS_FRAMEWORK_SCHEMA = {
             detectionPatterns: [
                 {
                     type: 'function',
-                    pattern: (node) => {
+                    pattern: (parsedNode) => {
+                        const node = parsedNode.sourceNode;
+                        if (!node)
+                            return false;
                         const decorators = node.getDecorators?.() ?? [];
                         const messageDecorators = ['MessagePattern', 'EventPattern'];
                         return decorators.some((d) => messageDecorators.includes(d.getName()));
@@ -567,7 +570,10 @@ export const NESTJS_FRAMEWORK_SCHEMA = {
             detectionPatterns: [
                 {
                     type: 'function',
-                    pattern: (node) => {
+                    pattern: (parsedNode) => {
+                        const node = parsedNode.sourceNode;
+                        if (!node)
+                            return false;
                         const decorators = node.getDecorators?.() ?? [];
                         const httpDecorators = ['Get', 'Post', 'Put', 'Delete', 'Patch', 'Head', 'Options'];
                         return decorators.some((d) => httpDecorators.includes(d.getName()));

package/dist/core/config/schema.js

@@ -480,6 +480,12 @@ export const CORE_TYPESCRIPT_SCHEMA = {
                     extraction: { method: 'static', defaultValue: false }, // We'll set this manually
                     neo4j: { indexed: true, unique: false, required: true },
                 },
+                {
+                    name: 'typeAnnotation',
+                    type: 'string',
+                    extraction: { method: 'ast', source: 'getTypeNode', transform: 'getText' },
+                    neo4j: { indexed: false, unique: false, required: false },
+                },
             ],
             relationships: [],
             children: {},

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

@@ -277,16 +277,24 @@ Provide ONLY the JSON response with no additional text, markdown formatting, or
                 frameworkHint = '\nFRAMEWORK DETECTED: React/functional codebase. Use Function nodes for components.';
             }
             return `
-ACTUAL GRAPH SCHEMA (use these exact labels):
+=== VALID NODE LABELS (use ONLY these after the colon) ===
+${nodeTypes}
 
-Node Types: ${nodeTypes}
-Relationship Types: ${relTypes}
-Semantic Types: ${semTypes}
+=== VALID RELATIONSHIP TYPES ===
+${relTypes}
+
+=== SEMANTIC TYPES (these are PROPERTY values, NOT labels) ===
+${semTypes}
+Query semantic types via property: WHERE n.semanticType = 'TypeName'
 ${frameworkHint}
-CRITICAL: Use ONLY these node labels. Do NOT invent labels like :DbService, :UserService, etc.
-For queries about specific classes/services, use: (n:Class {name: 'ClassName'})
-For inheritance: (child:Class)-[:EXTENDS]->(parent:Class {name: 'ParentName'})
-For decorator-based queries: Use semanticType property with values from the discovered semantic types above.
+
+=== CRITICAL RULES ===
+1. Use ONLY the labels listed above after the colon (:Label)
+2. Semantic types are PROPERTY values, NOT labels
+3. Class/service names are PROPERTY values, NOT labels
+4. WRONG: (n:MyService), (n:MyController) - names as labels
+5. CORRECT: (n:Service {name: 'MyService'}), (n:Controller {name: 'MyController'})
+6. CORRECT: (n:Class) WHERE n.semanticType = 'Service'
 `.trim();
         }
         catch (error) {
@@ -507,7 +515,7 @@ Remember to include WHERE n.projectId = $projectId for all node patterns.
     }
     /**
      * Load valid labels dynamically from the schema file.
-     * Returns all keys from rawSchema which represent actual Neo4j labels.
+     * Returns all keys from rawSchema AND discoveredSchema.nodeTypes which represent actual Neo4j labels.
      */
     loadValidLabelsFromSchema() {
         // Fallback to core TypeScript labels if schema not available
@@ -535,12 +543,21 @@ Remember to include WHERE n.projectId = $projectId for all node patterns.
         try {
             const content = fs.readFileSync(this.schemaPath, 'utf-8');
             const schema = JSON.parse(content);
-            if (!schema.rawSchema?.records?.[0]?._fields?.[0]) {
-                return coreLabels;
+            const allLabels = new Set(coreLabels);
+            // Extract labels from rawSchema keys
+            if (schema.rawSchema?.records?.[0]?._fields?.[0]) {
+                const schemaLabels = Object.keys(schema.rawSchema.records[0]._fields[0]);
+                schemaLabels.forEach((label) => allLabels.add(label));
+            }
+            // Also extract labels from discoveredSchema.nodeTypes (includes framework labels)
+            if (schema.discoveredSchema?.nodeTypes) {
+                for (const nodeType of schema.discoveredSchema.nodeTypes) {
+                    if (nodeType.label) {
+                        allLabels.add(nodeType.label);
+                    }
+                }
             }
-            // Extract all keys from rawSchema - these are the valid labels
-            const schemaLabels = Object.keys(schema.rawSchema.records[0]._fields[0]);
-            return new Set([...coreLabels, ...schemaLabels]);
+            return allLabels;
         }
         catch {
             return coreLabels;

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

@@ -542,6 +542,11 @@ export class TypeScriptParser {
                         return astNode.getName();
                     }
                     break;
+                case CoreNodeType.VARIABLE_DECLARATION:
+                    if (Node.isVariableDeclaration(astNode)) {
+                        return astNode.getName();
+                    }
+                    break;
                 default:
                     return astNode.getKindName();
             }
@@ -552,13 +557,18 @@ export class TypeScriptParser {
         return 'Unknown';
     }
     extractProperty(astNode, propDef) {
-        const { method, source, defaultValue } = propDef.extraction;
+        const { method, source, defaultValue, transform } = propDef.extraction;
         try {
             switch (method) {
                 case 'ast':
                     if (typeof source === 'string') {
                         const fn = astNode[source];
-                        return typeof fn === 'function' ? fn.call(astNode) : defaultValue;
+                        let result = typeof fn === 'function' ? fn.call(astNode) : defaultValue;
+                        // Apply transform if specified (e.g., 'getText' on a returned node)
+                        if (result && transform && typeof result[transform] === 'function') {
+                            result = result[transform]();
+                        }
+                        return result ?? defaultValue;
                     }
                     return defaultValue;
                 case 'function':
@@ -1284,11 +1294,9 @@ export class TypeScriptParser {
                         }
                     case 'function':
                         if (typeof pattern.pattern === 'function') {
-                            // Pass the AST sourceNode to pattern functions, not the ParsedNode wrapper
-                            const astNode = node.sourceNode;
-                            if (!astNode)
-                                return false;
-                            return pattern.pattern(astNode);
+                            // Pass the ParsedNode to pattern functions
+                            // Patterns should use pre-extracted properties for cross-chunk compatibility
+                            return pattern.pattern(node);
                         }
                         return false;
                     case 'classname':

package/dist/mcp/service-init.js

@@ -4,14 +4,67 @@
  */
 import fs from 'fs/promises';
 import { join } from 'path';
+import { ensureNeo4jRunning, isDockerInstalled, isDockerRunning, } from '../cli/neo4j-docker.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';
+/**
+ * Log startup warnings for missing configuration
+ */
+const checkConfiguration = async () => {
+    if (!process.env.OPENAI_API_KEY) {
+        console.error(JSON.stringify({
+            level: 'warn',
+            message: '[code-graph-context] OPENAI_API_KEY not set. Semantic search and NL queries unavailable.',
+        }));
+        await debugLog('Configuration warning', { warning: 'OPENAI_API_KEY not set' });
+    }
+};
+/**
+ * Ensure Neo4j is running - auto-start if Docker available, fail if not
+ */
+const ensureNeo4j = async () => {
+    // Check if Docker is available
+    if (!isDockerInstalled()) {
+        const msg = 'Docker not installed. Install Docker or run: code-graph-context init';
+        console.error(JSON.stringify({ level: 'error', message: `[code-graph-context] ${msg}` }));
+        throw new Error(msg);
+    }
+    if (!isDockerRunning()) {
+        const msg = 'Docker not running. Start Docker or run: code-graph-context init';
+        console.error(JSON.stringify({ level: 'error', message: `[code-graph-context] ${msg}` }));
+        throw new Error(msg);
+    }
+    const result = await ensureNeo4jRunning();
+    if (!result.success) {
+        const msg = `Neo4j failed to start: ${result.error}. Run: code-graph-context init`;
+        console.error(JSON.stringify({ level: 'error', message: `[code-graph-context] ${msg}` }));
+        throw new Error(msg);
+    }
+    if (result.action === 'created') {
+        console.error(JSON.stringify({
+            level: 'info',
+            message: '[code-graph-context] Neo4j container created and started',
+        }));
+    }
+    else if (result.action === 'started') {
+        console.error(JSON.stringify({
+            level: 'info',
+            message: '[code-graph-context] Neo4j container started',
+        }));
+    }
+    await debugLog('Neo4j ready', result);
+};
 /**
  * Initialize all external services required by the MCP server
  */
 export const initializeServices = async () => {
+    // Check for missing configuration (non-fatal warnings)
+    await checkConfiguration();
+    // Ensure Neo4j is running (fatal if not)
+    await ensureNeo4j();
+    // Initialize services
     await Promise.all([initializeNeo4jSchema(), initializeNaturalLanguageService()]);
 };
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-graph-context",
-  "version": "2.3.0",
+  "version": "2.4.1",
   "description": "MCP server that builds code graphs to provide rich context to LLMs",
   "type": "module",
   "homepage": "https://github.com/drewdrewH/code-graph-context#readme",
@@ -30,7 +30,7 @@
   "license": "MIT",
   "main": "dist/mcp/mcp.server.js",
   "bin": {
-    "code-graph-context": "dist/mcp/mcp.server.js"
+    "code-graph-context": "dist/cli/cli.js"
   },
   "files": [
     "dist/**/*",