gitnexus 1.3.3 → 1.3.5

package/README.md

@@ -156,7 +156,7 @@ GitNexus supports indexing multiple repositories. Each `gitnexus analyze` regist
 
 ## Supported Languages
 
-TypeScript, JavaScript, Python, Java, C, C++, C#, Go, Rust
+TypeScript, JavaScript, Python, Java, C, C++, C#, Go, Rust, PHP, Swift
 
 ## Agent Skills
 

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,7 @@ export declare enum SupportedLanguages {
     CPlusPlus = "cpp",
     CSharp = "csharp",
     Go = "go",
-    Rust = "rust"
+    Rust = "rust",
+    PHP = "php",
+    Swift = "swift"
 }

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["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/call-processor.js

@@ -31,6 +31,9 @@ const FUNCTION_NODE_TYPES = new Set([
     // Rust
     'function_item',
     'impl_item', // Methods inside impl blocks
+    // Swift
+    'init_declaration',
+    'deinit_declaration',
 ]);
 /**
  * Walk up the AST from a node to find the enclosing function/method.
@@ -44,6 +47,11 @@ const findEnclosingFunction = (node, filePath, symbolTable) => {
             let funcName = null;
             let label = 'Function';
             // Different node types have different name locations
+            // Swift init/deinit — handle before generic cases (more specific)
+            if (current.type === 'init_declaration' || current.type === 'deinit_declaration') {
+                const funcName = current.type === 'init_declaration' ? 'init' : 'deinit';
+                return generateId('Constructor', `${filePath}:${funcName}`);
+            }
             if (current.type === 'function_declaration' ||
                 current.type === 'function_definition' ||
                 current.type === 'async_function_declaration' ||
@@ -282,6 +290,37 @@ const BUILT_IN_NAMES = new Set([
     'mutex_lock', 'mutex_unlock', 'mutex_init',
     'kfree', 'kmalloc', 'kzalloc', 'kcalloc', 'krealloc', 'kvmalloc', 'kvfree',
     'get', 'put',
+    // Swift/iOS built-ins and standard library
+    'print', 'debugPrint', 'dump', 'fatalError', 'precondition', 'preconditionFailure',
+    'assert', 'assertionFailure', 'NSLog',
+    'abs', 'min', 'max', 'zip', 'stride', 'sequence', 'repeatElement',
+    'swap', 'withUnsafePointer', 'withUnsafeMutablePointer', 'withUnsafeBytes',
+    'autoreleasepool', 'unsafeBitCast', 'unsafeDowncast', 'numericCast',
+    'type', 'MemoryLayout',
+    // Swift collection/string methods (common noise)
+    'map', 'flatMap', 'compactMap', 'filter', 'reduce', 'forEach', 'contains',
+    'first', 'last', 'prefix', 'suffix', 'dropFirst', 'dropLast',
+    'sorted', 'reversed', 'enumerated', 'joined', 'split',
+    'append', 'insert', 'remove', 'removeAll', 'removeFirst', 'removeLast',
+    'isEmpty', 'count', 'index', 'startIndex', 'endIndex',
+    // UIKit/Foundation common methods (noise in call graph)
+    'addSubview', 'removeFromSuperview', 'layoutSubviews', 'setNeedsLayout',
+    'layoutIfNeeded', 'setNeedsDisplay', 'invalidateIntrinsicContentSize',
+    'addTarget', 'removeTarget', 'addGestureRecognizer',
+    'addConstraint', 'addConstraints', 'removeConstraint', 'removeConstraints',
+    'NSLocalizedString', 'Bundle',
+    'reloadData', 'reloadSections', 'reloadRows', 'performBatchUpdates',
+    'register', 'dequeueReusableCell', 'dequeueReusableSupplementaryView',
+    'beginUpdates', 'endUpdates', 'insertRows', 'deleteRows', 'insertSections', 'deleteSections',
+    'present', 'dismiss', 'pushViewController', 'popViewController', 'popToRootViewController',
+    'performSegue', 'prepare',
+    // GCD / async
+    'DispatchQueue', 'async', 'sync', 'asyncAfter',
+    'Task', 'withCheckedContinuation', 'withCheckedThrowingContinuation',
+    // Combine
+    'sink', 'store', 'assign', 'receive', 'subscribe',
+    // Notification / KVO
+    'addObserver', 'removeObserver', 'post', 'NotificationCenter',
 ]);
 const isBuiltInOrNoise = (name) => BUILT_IN_NAMES.has(name);
 /**

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

@@ -91,6 +91,45 @@ const ENTRY_POINT_PATTERNS = {
         /^Run$/, // Run methods
         /^Start$/, // Start methods
     ],
+    // Swift / iOS
+    'swift': [
+        /^viewDidLoad$/, // UIKit lifecycle
+        /^viewWillAppear$/, // UIKit lifecycle
+        /^viewDidAppear$/, // UIKit lifecycle
+        /^viewWillDisappear$/, // UIKit lifecycle
+        /^viewDidDisappear$/, // UIKit lifecycle
+        /^application\(/, // AppDelegate methods
+        /^scene\(/, // SceneDelegate methods
+        /^body$/, // SwiftUI View.body
+        /Coordinator$/, // Coordinator pattern
+        /^sceneDidBecomeActive$/, // SceneDelegate lifecycle
+        /^sceneWillResignActive$/, // SceneDelegate lifecycle
+        /^didFinishLaunchingWithOptions$/, // AppDelegate
+        /ViewController$/, // ViewController classes
+        /^configure[A-Z]/, // Configuration methods
+        /^setup[A-Z]/, // Setup methods
+        /^makeBody$/, // SwiftUI ViewModifier
+    ],
+    // 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
@@ -209,9 +248,18 @@ export function isTestFile(filePath) {
         p.includes('/src/test/') ||
         // Rust test patterns (inline tests are different, but test files)
         p.includes('/tests/') ||
+        // Swift/iOS test patterns
+        p.endsWith('tests.swift') ||
+        p.endsWith('test.swift') ||
+        p.includes('uitests/') ||
         // 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/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,16 @@ export declare const FRAMEWORK_AST_PATTERNS: {
     jaxrs: string[];
     aspnet: string[];
     'go-http': string[];
+    laravel: string[];
     actix: string[];
     axum: string[];
     rocket: string[];
+    uikit: string[];
+    swiftui: string[];
+    combine: 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;