gitnexus 1.3.2 → 1.3.4

package/dist/cli/ai-context.js

@@ -29,12 +29,8 @@ function generateGitNexusContent(projectName, stats) {
 
 This project is indexed by GitNexus as **${projectName}** (${stats.nodes || 0} symbols, ${stats.edges || 0} relationships, ${stats.processes || 0} execution flows).
 
-GitNexus provides a knowledge graph over this codebase — call chains, blast radius, execution flows, and semantic search.
-
 ## Always Start Here
 
-For any task involving code understanding, debugging, impact analysis, or refactoring, you must:
-
 1. **Read \`gitnexus://repo/{name}/context\`** — codebase overview + check index freshness
 2. **Match your task to a skill below** and **read that skill file**
 3. **Follow the skill's workflow and checklist**
@@ -45,45 +41,12 @@ For any task involving code understanding, debugging, impact analysis, or refact
 
 | Task | Read this skill file |
 |------|---------------------|
-| Understand architecture / "How does X work?" | \`.claude/skills/gitnexus/exploring/SKILL.md\` |
-| Blast radius / "What breaks if I change X?" | \`.claude/skills/gitnexus/impact-analysis/SKILL.md\` |
-| Trace bugs / "Why is X failing?" | \`.claude/skills/gitnexus/debugging/SKILL.md\` |
-| Rename / extract / split / refactor | \`.claude/skills/gitnexus/refactoring/SKILL.md\` |
-
-## Tools Reference
-
-| Tool | What it gives you |
-|------|-------------------|
-| \`query\` | Process-grouped code intelligence — execution flows related to a concept |
-| \`context\` | 360-degree symbol view — categorized refs, processes it participates in |
-| \`impact\` | Symbol blast radius — what breaks at depth 1/2/3 with confidence |
-| \`detect_changes\` | Git-diff impact — what do your current changes affect |
-| \`rename\` | Multi-file coordinated rename with confidence-tagged edits |
-| \`cypher\` | Raw graph queries (read \`gitnexus://repo/{name}/schema\` first) |
-| \`list_repos\` | Discover indexed repos |
-
-## Resources Reference
-
-Lightweight reads (~100-500 tokens) for navigation:
-
-| Resource | Content |
-|----------|---------|
-| \`gitnexus://repo/{name}/context\` | Stats, staleness check |
-| \`gitnexus://repo/{name}/clusters\` | All functional areas with cohesion scores |
-| \`gitnexus://repo/{name}/cluster/{clusterName}\` | Area members |
-| \`gitnexus://repo/{name}/processes\` | All execution flows |
-| \`gitnexus://repo/{name}/process/{processName}\` | Step-by-step trace |
-| \`gitnexus://repo/{name}/schema\` | Graph schema for Cypher |
-
-## Graph Schema
-
-**Nodes:** File, Function, Class, Interface, Method, Community, Process
-**Edges (via CodeRelation.type):** CALLS, IMPORTS, EXTENDS, IMPLEMENTS, DEFINES, MEMBER_OF, STEP_IN_PROCESS
-
-\`\`\`cypher
-MATCH (caller)-[:CodeRelation {type: 'CALLS'}]->(f:Function {name: "myFunc"})
-RETURN caller.name, caller.filePath
-\`\`\`
+| Understand architecture / "How does X work?" | \`.claude/skills/gitnexus/gitnexus-exploring/SKILL.md\` |
+| Blast radius / "What breaks if I change X?" | \`.claude/skills/gitnexus/gitnexus-impact-analysis/SKILL.md\` |
+| Trace bugs / "Why is X failing?" | \`.claude/skills/gitnexus/gitnexus-debugging/SKILL.md\` |
+| Rename / extract / split / refactor | \`.claude/skills/gitnexus/gitnexus-refactoring/SKILL.md\` |
+| Tools, resources, schema reference | \`.claude/skills/gitnexus/gitnexus-guide/SKILL.md\` |
+| Index, status, clean, wiki CLI commands | \`.claude/skills/gitnexus/gitnexus-cli/SKILL.md\` |
 
 ${GITNEXUS_END_MARKER}`;
 }
@@ -138,20 +101,28 @@ async function installSkills(repoPath) {
     // Skill definitions bundled with the package
     const skills = [
         {
-            name: 'exploring',
-            description: 'Navigate unfamiliar code using GitNexus knowledge graph',
+            name: 'gitnexus-exploring',
+            description: 'Use when the user asks how code works, wants to understand architecture, trace execution flows, or explore unfamiliar parts of the codebase. Examples: "How does X work?", "What calls this function?", "Show me the auth flow"',
+        },
+        {
+            name: 'gitnexus-debugging',
+            description: 'Use when the user is debugging a bug, tracing an error, or asking why something fails. Examples: "Why is X failing?", "Where does this error come from?", "Trace this bug"',
+        },
+        {
+            name: 'gitnexus-impact-analysis',
+            description: 'Use when the user wants to know what will break if they change something, or needs safety analysis before editing code. Examples: "Is it safe to change X?", "What depends on this?", "What will break?"',
         },
         {
-            name: 'debugging',
-            description: 'Trace bugs through call chains using knowledge graph',
+            name: 'gitnexus-refactoring',
+            description: 'Use when the user wants to rename, extract, split, move, or restructure code safely. Examples: "Rename this function", "Extract this into a module", "Refactor this class", "Move this to a separate file"',
         },
         {
-            name: 'impact-analysis',
-            description: 'Analyze blast radius before making code changes',
+            name: 'gitnexus-guide',
+            description: 'Use when the user asks about GitNexus itself — available tools, how to query the knowledge graph, MCP resources, graph schema, or workflow reference. Examples: "What GitNexus tools are available?", "How do I use GitNexus?"',
         },
         {
-            name: 'refactoring',
-            description: 'Plan safe refactors using blast radius and dependency mapping',
+            name: 'gitnexus-cli',
+            description: 'Use when the user needs to run GitNexus CLI commands like analyze/index a repo, check status, clean the index, generate a wiki, or list indexed repos. Examples: "Index this repo", "Reanalyze the codebase", "Generate a wiki"',
         },
     ];
     for (const skill of skills) {
@@ -169,7 +140,7 @@ async function installSkills(repoPath) {
             catch {
                 // Fallback: generate minimal skill content
                 skillContent = `---
-name: gitnexus-${skill.name}
+name: ${skill.name}
 description: ${skill.description}
 ---
 

package/dist/cli/analyze.js

@@ -9,7 +9,9 @@ import v8 from 'v8';
 import cliProgress from 'cli-progress';
 import { runPipelineFromRepo } from '../core/ingestion/pipeline.js';
 import { initKuzu, loadGraphToKuzu, getKuzuStats, executeQuery, executeWithReusedStatement, closeKuzu, createFTSIndex, loadCachedEmbeddings } from '../core/kuzu/kuzu-adapter.js';
-import { runEmbeddingPipeline } from '../core/embeddings/embedding-pipeline.js';
+// Embedding imports are lazy (dynamic import) so onnxruntime-node is never
+// loaded when embeddings are not requested. This avoids crashes on Node
+// versions whose ABI is not yet supported by the native binary (#89).
 // disposeEmbedder intentionally not called — ONNX Runtime segfaults on cleanup (see #38)
 import { getStoragePaths, saveMeta, loadMeta, addToGitignore, registerRepo, getGlobalRegistryPath } from '../storage/repo-manager.js';
 import { getCurrentCommit, isGitRepo, getGitRoot } from '../storage/git.js';
@@ -231,6 +233,7 @@ export const analyzeCommand = async (inputPath, options) => {
     if (!embeddingSkipped) {
         updateBar(90, 'Loading embedding model...');
         const t0Emb = Date.now();
+        const { runEmbeddingPipeline } = await import('../core/embeddings/embedding-pipeline.js');
         await runEmbeddingPipeline(executeQuery, executeWithReusedStatement, (progress) => {
             const scaled = 90 + Math.round((progress.percent / 100) * 8);
             const label = progress.phase === 'loading-model' ? 'Loading embedding model...' : `Embedding ${progress.nodesProcessed || 0}/${progress.totalNodes || '?'}`;

package/dist/cli/index.js

@@ -50,6 +50,7 @@ program
     .command('serve')
     .description('Start local HTTP server for web UI connection')
     .option('-p, --port <port>', 'Port number', '4747')
+    .option('--host <host>', 'Bind address (default: 127.0.0.1, use 0.0.0.0 for remote access)')
     .action(serveCommand);
 program
     .command('mcp')

package/dist/cli/mcp.js

@@ -7,7 +7,6 @@
  */
 import { startMCPServer } from '../mcp/server.js';
 import { LocalBackend } from '../mcp/local/local-backend.js';
-import { listRegisteredRepos } from '../storage/repo-manager.js';
 export const mcpCommand = async () => {
     // Prevent unhandled errors from crashing the MCP server process.
     // KuzuDB lock conflicts and transient errors should degrade gracefully.
@@ -18,28 +17,18 @@ export const mcpCommand = async () => {
         const msg = reason instanceof Error ? reason.message : String(reason);
         console.error(`GitNexus MCP: unhandled rejection — ${msg}`);
     });
-    // Load all registered repos
-    const entries = await listRegisteredRepos({ validate: true });
-    if (entries.length === 0) {
-        console.error('');
-        console.error('  GitNexus: No indexed repositories found.');
-        console.error('');
-        console.error('  To get started:');
-        console.error('    1. cd into a git repository');
-        console.error('    2. Run: gitnexus analyze');
-        console.error('    3. Restart your editor');
-        console.error('');
-        process.exit(1);
-    }
-    // Initialize multi-repo backend from registry
+    // Initialize multi-repo backend from registry.
+    // The server starts even with 0 repos — tools call refreshRepos() lazily,
+    // so repos indexed after the server starts are discovered automatically.
     const backend = new LocalBackend();
-    const ok = await backend.init();
-    if (!ok) {
-        console.error('GitNexus: Failed to initialize backend from registry.');
-        process.exit(1);
+    await backend.init();
+    const repos = await backend.listRepos();
+    if (repos.length === 0) {
+        console.error('GitNexus: No indexed repos yet. Run `gitnexus analyze` in a git repo — the server will pick it up automatically.');
+    }
+    else {
+        console.error(`GitNexus: MCP server starting with ${repos.length} repo(s): ${repos.map(r => r.name).join(', ')}`);
     }
-    const repoNames = (await backend.listRepos()).map(r => r.name);
-    console.error(`GitNexus: MCP server starting with ${repoNames.length} repo(s): ${repoNames.join(', ')}`);
-    // Start MCP server (serves all repos)
+    // Start MCP server (serves all repos, discovers new ones lazily)
     await startMCPServer(backend);
 };

package/dist/cli/serve.d.ts

@@ -1,3 +1,4 @@
 export declare const serveCommand: (options?: {
     port?: string;
+    host?: string;
 }) => Promise<void>;

package/dist/cli/serve.js

@@ -1,5 +1,6 @@
 import { createServer } from '../server/api.js';
 export const serveCommand = async (options) => {
     const port = Number(options?.port ?? 4747);
-    await createServer(port);
+    const host = options?.host ?? '127.0.0.1';
+    await createServer(port, host);
 };

package/dist/cli/setup.js

@@ -198,7 +198,7 @@ async function setupOpenCode(result) {
     }
 }
 // ─── Skill Installation ───────────────────────────────────────────
-const SKILL_NAMES = ['exploring', 'debugging', 'impact-analysis', 'refactoring'];
+const SKILL_NAMES = ['gitnexus-exploring', 'gitnexus-debugging', 'gitnexus-impact-analysis', 'gitnexus-refactoring', 'gitnexus-guide', 'gitnexus-cli'];
 /**
  * Install GitNexus skills to a target directory.
  * Each skill is installed as {targetDir}/gitnexus-{skillName}/SKILL.md
@@ -212,7 +212,7 @@ async function installSkillsTo(targetDir) {
     const installed = [];
     const skillsRoot = path.join(__dirname, '..', '..', 'skills');
     for (const skillName of SKILL_NAMES) {
-        const skillDir = path.join(targetDir, `gitnexus-${skillName}`);
+        const skillDir = path.join(targetDir, skillName);
         try {
             // Try directory-based skill first (skills/{name}/SKILL.md)
             const dirSource = path.join(skillsRoot, skillName);

package/dist/cli/wiki.js

@@ -6,7 +6,7 @@
  */
 import path from 'path';
 import readline from 'readline';
-import { execSync } from 'child_process';
+import { execSync, execFileSync } from 'child_process';
 import cliProgress from 'cli-progress';
 import { getGitRoot, isGitRepo } from '../storage/git.js';
 import { getStoragePaths, loadMeta, loadCLIConfig, saveCLIConfig } from '../storage/repo-manager.js';
@@ -299,7 +299,11 @@ function hasGhCLI() {
 }
 function publishGist(htmlPath) {
     try {
-        const output = execSync(`gh gist create "${htmlPath}" --desc "Repository Wiki — generated by GitNexus" --public`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+        const output = execFileSync('gh', [
+            'gist', 'create', htmlPath,
+            '--desc', 'Repository Wiki — generated by GitNexus',
+            '--public',
+        ], { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
         // gh gist create prints the gist URL as the last line
         const lines = output.split('\n');
         const gistUrl = lines.find(l => l.includes('gist.github.com')) || lines[lines.length - 1];

package/dist/config/supported-languages.d.ts

@@ -7,5 +7,6 @@ export declare enum SupportedLanguages {
     CPlusPlus = "cpp",
     CSharp = "csharp",
     Go = "go",
-    Rust = "rust"
+    Rust = "rust",
+    PHP = "php"
 }

package/dist/config/supported-languages.js

@@ -9,7 +9,7 @@ export var SupportedLanguages;
     SupportedLanguages["CSharp"] = "csharp";
     SupportedLanguages["Go"] = "go";
     SupportedLanguages["Rust"] = "rust";
-    // PHP = 'php',
+    SupportedLanguages["PHP"] = "php";
     // Ruby = 'ruby',
     // Swift = 'swift',
 })(SupportedLanguages || (SupportedLanguages = {}));

package/dist/core/embeddings/embedder.js

@@ -13,7 +13,44 @@ if (!process.env.ORT_LOG_LEVEL) {
     process.env.ORT_LOG_LEVEL = '3';
 }
 import { pipeline, env } from '@huggingface/transformers';
+import { existsSync } from 'fs';
+import { execFileSync } from 'child_process';
+import { join } from 'path';
 import { DEFAULT_EMBEDDING_CONFIG } from './types.js';
+/**
+ * Check whether CUDA libraries are actually available on this system.
+ * ONNX Runtime's native layer crashes (uncatchable) if we attempt CUDA
+ * without the required shared libraries, so we probe first.
+ *
+ * Checks the dynamic linker cache (ldconfig) which covers all architectures
+ * and install paths, then falls back to CUDA_PATH / LD_LIBRARY_PATH env vars.
+ */
+function isCudaAvailable() {
+    // Primary: query the dynamic linker cache — covers all architectures,
+    // distro layouts, and custom install paths registered with ldconfig
+    try {
+        const out = execFileSync('ldconfig', ['-p'], { timeout: 3000, encoding: 'utf-8' });
+        if (out.includes('libcublasLt.so.12'))
+            return true;
+    }
+    catch {
+        // ldconfig not available (e.g. non-standard container)
+    }
+    // Fallback: check CUDA_PATH and LD_LIBRARY_PATH for environments where
+    // ldconfig doesn't know about the CUDA install (conda, manual /opt/cuda, etc.)
+    for (const envVar of ['CUDA_PATH', 'LD_LIBRARY_PATH']) {
+        const val = process.env[envVar];
+        if (!val)
+            continue;
+        for (const dir of val.split(':').filter(Boolean)) {
+            if (existsSync(join(dir, 'lib64', 'libcublasLt.so.12')) ||
+                existsSync(join(dir, 'lib', 'libcublasLt.so.12')) ||
+                existsSync(join(dir, 'libcublasLt.so.12')))
+                return true;
+        }
+    }
+    return false;
+}
 // Module-level state for singleton pattern
 let embedderInstance = null;
 let isInitializing = false;
@@ -45,8 +82,10 @@ export const initEmbedder = async (onProgress, config = {}, forceDevice) => {
     const finalConfig = { ...DEFAULT_EMBEDDING_CONFIG, ...config };
     // On Windows, use DirectML for GPU acceleration (via DirectX12)
     // CUDA is only available on Linux x64 with onnxruntime-node
+    // Probe for CUDA first — ONNX Runtime crashes (uncatchable native error)
+    // if we attempt CUDA without the required shared libraries
     const isWindows = process.platform === 'win32';
-    const gpuDevice = isWindows ? 'dml' : 'cuda';
+    const gpuDevice = isWindows ? 'dml' : (isCudaAvailable() ? 'cuda' : 'cpu');
     let requestedDevice = forceDevice || (finalConfig.device === 'auto' ? gpuDevice : finalConfig.device);
     initPromise = (async () => {
         try {

package/dist/core/graph/types.d.ts

@@ -6,6 +6,8 @@ export type NodeProperties = {
     endLine?: number;
     language?: string;
     isExported?: boolean;
+    astFrameworkMultiplier?: number;
+    astFrameworkReason?: string;
     heuristicLabel?: string;
     cohesion?: number;
     symbolCount?: number;

package/dist/core/ingestion/entry-point-scoring.js

@@ -91,6 +91,26 @@ const ENTRY_POINT_PATTERNS = {
         /^Run$/, // Run methods
         /^Start$/, // Start methods
     ],
+    // PHP / Laravel
+    'php': [
+        /Controller$/, // UserController (class name convention)
+        /^handle$/, // Job::handle(), Listener::handle()
+        /^execute$/, // Command::execute()
+        /^boot$/, // ServiceProvider::boot()
+        /^register$/, // ServiceProvider::register()
+        /^__invoke$/, // Invokable controllers/actions
+        /^(index|show|store|update|destroy|create|edit)$/, // RESTful resource methods
+        /^(get|post|put|delete|patch)[A-Z]/, // Explicit HTTP method actions
+        /^run$/, // Command/Job run()
+        /^fire$/, // Event fire()
+        /^dispatch$/, // Dispatchable jobs
+        /Service$/, // UserService (Service layer)
+        /Repository$/, // UserRepository (Repository pattern)
+        /^find$/, // Repository::find()
+        /^findAll$/, // Repository::findAll()
+        /^save$/, // Repository::save()
+        /^delete$/, // Repository::delete()
+    ],
 };
 // ============================================================================
 // UTILITY PATTERNS - Functions that should be penalized
@@ -211,7 +231,12 @@ export function isTestFile(filePath) {
         p.includes('/tests/') ||
         // C# test patterns
         p.includes('.tests/') ||
-        p.includes('tests.cs'));
+        p.includes('tests.cs') ||
+        // PHP/Laravel test patterns
+        p.endsWith('test.php') ||
+        p.endsWith('spec.php') ||
+        p.includes('/tests/feature/') ||
+        p.includes('/tests/unit/'));
 }
 /**
  * Check if a file path is likely a utility/helper file

package/dist/core/ingestion/filesystem-walker.js

@@ -3,8 +3,8 @@ import path from 'path';
 import { glob } from 'glob';
 import { shouldIgnorePath } from '../../config/ignore-service.js';
 const READ_CONCURRENCY = 32;
-/** Skip files larger than 2MB — covers all real source files, excludes minified bundles/generated code */
-const MAX_FILE_SIZE = 2 * 1024 * 1024;
+/** Skip files larger than 512KB — they're usually generated/vendored and crash tree-sitter */
+const MAX_FILE_SIZE = 512 * 1024;
 /**
  * Phase 1: Scan repository — stat files to get paths + sizes, no content loaded.
  * Memory: ~10MB for 100K files vs ~1GB+ with content.
@@ -42,7 +42,7 @@ export const walkRepositoryPaths = async (repoPath, onProgress) => {
         }
     }
     if (skippedLarge > 0) {
-        console.warn(`  Skipped ${skippedLarge} files larger than ${Math.round(MAX_FILE_SIZE / 1024 / 1024)}MB (likely generated/vendored)`);
+        console.warn(`  Skipped ${skippedLarge} large files (>${MAX_FILE_SIZE / 1024}KB, likely generated/vendored)`);
     }
     return entries;
 };

package/dist/core/ingestion/framework-detection.d.ts

@@ -1,8 +1,10 @@
 /**
  * Framework Detection
  *
- * Detects frameworks from file path patterns and provides entry point multipliers.
- * This enables framework-aware entry point scoring.
+ * Detects frameworks from:
+ * 1) file path patterns
+ * 2) AST definition text (decorators/annotations/attributes)
+ * and provides entry point multipliers for process scoring.
  *
  * DESIGN: Returns null for unknown frameworks, which causes a 1.0 multiplier
  * (no bonus, no penalty) - same behavior as before this feature.
@@ -20,8 +22,8 @@ export interface FrameworkHint {
  */
 export declare function detectFrameworkFromPath(filePath: string): FrameworkHint | null;
 /**
- * Patterns that indicate entry points within code (for future AST-based detection)
- * These would require parsing decorators/annotations in the code itself.
+ * Patterns that indicate framework entry points within code definitions.
+ * These are matched against AST node text (class/method/function declaration text).
  */
 export declare const FRAMEWORK_AST_PATTERNS: {
     nestjs: string[];
@@ -32,7 +34,13 @@ export declare const FRAMEWORK_AST_PATTERNS: {
     jaxrs: string[];
     aspnet: string[];
     'go-http': string[];
+    laravel: string[];
     actix: string[];
     axum: string[];
     rocket: string[];
 };
+/**
+ * Detect framework entry points from AST definition text (decorators/annotations/attributes).
+ * Returns null if no known pattern is found.
+ */
+export declare function detectFrameworkFromAST(language: string, definitionText: string): FrameworkHint | null;

package/dist/core/ingestion/framework-detection.js

@@ -1,8 +1,10 @@
 /**
  * Framework Detection
  *
- * Detects frameworks from file path patterns and provides entry point multipliers.
- * This enables framework-aware entry point scoring.
+ * Detects frameworks from:
+ * 1) file path patterns
+ * 2) AST definition text (decorators/annotations/attributes)
+ * and provides entry point multipliers for process scoring.
  *
  * DESIGN: Returns null for unknown frameworks, which causes a 1.0 multiplier
  * (no bonus, no penalty) - same behavior as before this feature.
@@ -146,6 +148,55 @@ export function detectFrameworkFromPath(filePath) {
     if ((p.includes('/src/') && (p.endsWith('/app.c') || p.endsWith('/app.cpp')))) {
         return { framework: 'c-cpp', entryPointMultiplier: 2.5, reason: 'c-app' };
     }
+    // ========== PHP / LARAVEL FRAMEWORKS ==========
+    // Laravel routes (highest - these ARE the entry point definitions)
+    if (p.includes('/routes/') && p.endsWith('.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 3.0, reason: 'laravel-routes' };
+    }
+    // Laravel controllers (very high - receive HTTP requests)
+    if ((p.includes('/http/controllers/') || p.includes('/controllers/')) && p.endsWith('.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 3.0, reason: 'laravel-controller' };
+    }
+    // Laravel controller by file name convention
+    if (p.endsWith('controller.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 3.0, reason: 'laravel-controller-file' };
+    }
+    // Laravel console commands
+    if ((p.includes('/console/commands/') || p.includes('/commands/')) && p.endsWith('.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 2.5, reason: 'laravel-command' };
+    }
+    // Laravel jobs (queue entry points)
+    if (p.includes('/jobs/') && p.endsWith('.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 2.5, reason: 'laravel-job' };
+    }
+    // Laravel listeners (event-driven entry points)
+    if (p.includes('/listeners/') && p.endsWith('.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 2.5, reason: 'laravel-listener' };
+    }
+    // Laravel middleware
+    if (p.includes('/http/middleware/') && p.endsWith('.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 2.5, reason: 'laravel-middleware' };
+    }
+    // Laravel service providers
+    if (p.includes('/providers/') && p.endsWith('.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 1.8, reason: 'laravel-provider' };
+    }
+    // Laravel policies
+    if (p.includes('/policies/') && p.endsWith('.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 2.0, reason: 'laravel-policy' };
+    }
+    // Laravel models (important but not entry points per se)
+    if (p.includes('/models/') && p.endsWith('.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 1.5, reason: 'laravel-model' };
+    }
+    // Laravel services (Service Repository pattern)
+    if (p.includes('/services/') && p.endsWith('.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 1.8, reason: 'laravel-service' };
+    }
+    // Laravel repositories (Service Repository pattern)
+    if (p.includes('/repositories/') && p.endsWith('.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 1.5, reason: 'laravel-repository' };
+    }
     // ========== GENERIC PATTERNS ==========
     // Any language: index files in API folders
     if (p.includes('/api/') && (p.endsWith('/index.ts') || p.endsWith('/index.js') ||
@@ -156,11 +207,11 @@ export function detectFrameworkFromPath(filePath) {
     return null;
 }
 // ============================================================================
-// FUTURE: AST-BASED PATTERNS (for Phase 3)
+// AST-BASED FRAMEWORK DETECTION
 // ============================================================================
 /**
- * Patterns that indicate entry points within code (for future AST-based detection)
- * These would require parsing decorators/annotations in the code itself.
+ * Patterns that indicate framework entry points within code definitions.
+ * These are matched against AST node text (class/method/function declaration text).
  */
 export const FRAMEWORK_AST_PATTERNS = {
     // JavaScript/TypeScript decorators
@@ -176,8 +227,57 @@ export const FRAMEWORK_AST_PATTERNS = {
     'aspnet': ['[ApiController]', '[HttpGet]', '[HttpPost]', '[Route]'],
     // Go patterns (function signatures)
     'go-http': ['http.Handler', 'http.HandlerFunc', 'ServeHTTP'],
+    // PHP/Laravel
+    'laravel': ['Route::get', 'Route::post', 'Route::put', 'Route::delete',
+        'Route::resource', 'Route::apiResource', '#[Route('],
     // Rust macros
     'actix': ['#[get', '#[post', '#[put', '#[delete'],
     'axum': ['Router::new'],
     'rocket': ['#[get', '#[post'],
 };
+const AST_FRAMEWORK_PATTERNS_BY_LANGUAGE = {
+    javascript: [
+        { framework: 'nestjs', entryPointMultiplier: 3.2, reason: 'nestjs-decorator', patterns: FRAMEWORK_AST_PATTERNS.nestjs },
+    ],
+    typescript: [
+        { framework: 'nestjs', entryPointMultiplier: 3.2, reason: 'nestjs-decorator', patterns: FRAMEWORK_AST_PATTERNS.nestjs },
+    ],
+    python: [
+        { framework: 'fastapi', entryPointMultiplier: 3.0, reason: 'fastapi-decorator', patterns: FRAMEWORK_AST_PATTERNS.fastapi },
+        { framework: 'flask', entryPointMultiplier: 2.8, reason: 'flask-decorator', patterns: FRAMEWORK_AST_PATTERNS.flask },
+    ],
+    java: [
+        { framework: 'spring', entryPointMultiplier: 3.2, reason: 'spring-annotation', patterns: FRAMEWORK_AST_PATTERNS.spring },
+        { framework: 'jaxrs', entryPointMultiplier: 3.0, reason: 'jaxrs-annotation', patterns: FRAMEWORK_AST_PATTERNS.jaxrs },
+    ],
+    csharp: [
+        { framework: 'aspnet', entryPointMultiplier: 3.2, reason: 'aspnet-attribute', patterns: FRAMEWORK_AST_PATTERNS.aspnet },
+    ],
+    php: [
+        { framework: 'laravel', entryPointMultiplier: 3.0, reason: 'php-route-attribute', patterns: FRAMEWORK_AST_PATTERNS.laravel },
+    ],
+};
+/**
+ * Detect framework entry points from AST definition text (decorators/annotations/attributes).
+ * Returns null if no known pattern is found.
+ */
+export function detectFrameworkFromAST(language, definitionText) {
+    if (!language || !definitionText)
+        return null;
+    const configs = AST_FRAMEWORK_PATTERNS_BY_LANGUAGE[language.toLowerCase()];
+    if (!configs || configs.length === 0)
+        return null;
+    const normalized = definitionText.toLowerCase();
+    for (const cfg of configs) {
+        for (const pattern of cfg.patterns) {
+            if (normalized.includes(pattern.toLowerCase())) {
+                return {
+                    framework: cfg.framework,
+                    entryPointMultiplier: cfg.entryPointMultiplier,
+                    reason: cfg.reason,
+                };
+            }
+        }
+    }
+    return null;
+}