gitnexus 1.6.6-rc.68 → 1.6.6-rc.69

package/dist/cli/doctor.js

@@ -1,6 +1,7 @@
 import { getRuntimeCapabilities, getRuntimeFingerprint } from '../core/platform/capabilities.js';
 import { resolveEmbeddingConfig } from '../core/embeddings/config.js';
 import { isHttpMode } from '../core/embeddings/http-client.js';
+import { checkLbugNative } from '../core/lbug/native-check.js';
 import { t } from './i18n/index.js';
 function isCombiningMark(codePoint) {
     return ((codePoint >= 0x0300 && codePoint <= 0x036f) ||
@@ -50,6 +51,14 @@ export const doctorCommand = async () => {
     console.log(`  ${label('doctor.labels.node', 10)}${fingerprint.node}`);
     console.log(`  ${label('doctor.labels.gitnexus', 10)}${fingerprint.gitnexus}`);
     console.log(`  ${label('doctor.labels.ladybugdb', 10)}${fingerprint.ladybugdb ?? 'unknown'}`);
+    const nativeCheck = checkLbugNative();
+    if (nativeCheck.ok) {
+        console.log(`  ${padDisplayEnd('native', 10)}✓ lbugjs.node loaded`);
+    }
+    else {
+        console.log(`  ${padDisplayEnd('native', 10)}✗ lbugjs.node missing`);
+        process.stderr.write(`\n${nativeCheck.message?.replace(/^/gm, '  ')}\n\n`);
+    }
     console.log(`  ${label('doctor.labels.onnx', 10)}${fingerprint.onnxruntime ?? 'unknown'}`);
     console.log('');
     console.log(t('doctor.capabilities'));

package/dist/cli/index.js

@@ -3,7 +3,7 @@
 // Removing it from here improves MCP server startup time significantly.
 import { Command } from 'commander';
 import { createRequire } from 'node:module';
-import { createLazyAction } from './lazy-action.js';
+import { createLazyAction, createLbugLazyAction } from './lazy-action.js';
 import { registerGroupCommands } from './group.js';
 import { localizeCliHelp } from './help-i18n.js';
 import { t } from './i18n/index.js';
@@ -48,7 +48,7 @@ program
     .option('--embedding-sub-batch-size <n>', 'Number of chunks per embedding model call')
     .option('--embedding-device <device>', 'Embedding device: auto, cpu, dml, cuda, or wasm')
     .addHelpText('after', () => t('help.analyze.environment'))
-    .action(createLazyAction(() => import('./analyze.js'), 'analyzeCommand'));
+    .action(createLbugLazyAction(() => import('./analyze.js'), 'analyzeCommand'));
 program
     .command('index [path...]')
     .description('Register an existing .gitnexus/ folder into the global registry (no re-analysis needed)')
@@ -60,11 +60,11 @@ program
     .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(createLazyAction(() => import('./serve.js'), 'serveCommand'));
+    .action(createLbugLazyAction(() => import('./serve.js'), 'serveCommand'));
 program
     .command('mcp')
     .description('Start MCP server (stdio) — serves all indexed repos')
-    .action(createLazyAction(() => import('./mcp.js'), 'mcpCommand'));
+    .action(createLbugLazyAction(() => import('./mcp.js'), 'mcpCommand'));
 program
     .command('list')
     .description('List all indexed repositories')
@@ -108,11 +108,11 @@ program
     .option('-v, --verbose', 'Enable verbose output (show LLM commands and responses)')
     .option('--review', 'Stop after grouping to review module structure before generating pages')
     .option('--lang <lang>', 'Output language for generated documentation (e.g. english, chinese, spanish, japanese)')
-    .action(createLazyAction(() => import('./wiki.js'), 'wikiCommand'));
+    .action(createLbugLazyAction(() => import('./wiki.js'), 'wikiCommand'));
 program
     .command('augment <pattern>')
     .description('Augment a search pattern with knowledge graph context (used by hooks)')
-    .action(createLazyAction(() => import('./augment.js'), 'augmentCommand'));
+    .action(createLbugLazyAction(() => import('./augment.js'), 'augmentCommand'));
 program
     .command('publish [path]')
     .description('Notify the understand-quickly registry that this repo has a fresh GitNexus index. ' +
@@ -132,7 +132,7 @@ program
     .option('-g, --goal <text>', 'What you want to find')
     .option('-l, --limit <n>', 'Max processes to return (default: 5)')
     .option('--content', 'Include full symbol source code')
-    .action(createLazyAction(() => import('./tool.js'), 'queryCommand'));
+    .action(createLbugLazyAction(() => import('./tool.js'), 'queryCommand'));
 program
     .command('context [name]')
     .description('360-degree view of a code symbol: callers, callees, processes')
@@ -140,7 +140,7 @@ program
     .option('-u, --uid <uid>', 'Direct symbol UID (zero-ambiguity lookup)')
     .option('-f, --file <path>', 'File path to disambiguate common names')
     .option('--content', 'Include full symbol source code')
-    .action(createLazyAction(() => import('./tool.js'), 'contextCommand'));
+    .action(createLbugLazyAction(() => import('./tool.js'), 'contextCommand'));
 program
     .command('impact <target>')
     .description('Blast radius analysis: what breaks if you change a symbol')
@@ -151,12 +151,12 @@ program
     .option('--limit <n>', 'Max symbols per depth level (default: 100)')
     .option('--offset <n>', 'Skip N symbols per depth level for pagination')
     .option('--summary-only', 'Return counts and risk only, omit symbol list')
-    .action(createLazyAction(() => import('./tool.js'), 'impactCommand'));
+    .action(createLbugLazyAction(() => import('./tool.js'), 'impactCommand'));
 program
     .command('cypher <query>')
     .description('Execute raw Cypher query against the knowledge graph')
     .option('-r, --repo <name>', 'Target repository')
-    .action(createLazyAction(() => import('./tool.js'), 'cypherCommand'));
+    .action(createLbugLazyAction(() => import('./tool.js'), 'cypherCommand'));
 program
     .command('detect-changes')
     .alias('detect_changes')
@@ -164,7 +164,7 @@ program
     .option('-s, --scope <scope>', 'What to analyze: unstaged, staged, all, or compare', 'unstaged')
     .option('-b, --base-ref <ref>', 'Branch/commit for compare scope (e.g. main)')
     .option('-r, --repo <name>', 'Target repository')
-    .action(createLazyAction(() => import('./tool.js'), 'detectChangesCommand'));
+    .action(createLbugLazyAction(() => import('./tool.js'), 'detectChangesCommand'));
 // ─── Eval Server (persistent daemon for SWE-bench) ─────────────────
 program
     .command('eval-server')
@@ -172,7 +172,7 @@ program
     .option('-p, --port <port>', 'Port number', '4848')
     .option('--host <host>', 'Bind address (default: 127.0.0.1, use 0.0.0.0 to expose to all interfaces)')
     .option('--idle-timeout <seconds>', 'Auto-shutdown after N seconds idle (0 = disabled)', '0')
-    .action(createLazyAction(() => import('./eval-server.js'), 'evalServerCommand'));
+    .action(createLbugLazyAction(() => import('./eval-server.js'), 'evalServerCommand'));
 registerGroupCommands(program);
 localizeCliHelp(program);
 program.parse(process.argv);

package/dist/cli/lazy-action.d.ts

@@ -4,3 +4,4 @@
  * at compile time — catching typos when used with concrete module imports.
  */
 export declare function createLazyAction<TModule extends Record<string, unknown>, TKey extends string & keyof TModule>(loader: () => Promise<TModule>, exportName: TKey): (...args: unknown[]) => Promise<void>;
+export declare function createLbugLazyAction<TModule extends Record<string, unknown>, TKey extends string & keyof TModule>(loader: () => Promise<TModule>, exportName: TKey): (...args: unknown[]) => Promise<void>;

package/dist/cli/lazy-action.js

@@ -3,6 +3,7 @@
  * The generic constraints ensure the export name is a valid key of the module
  * at compile time — catching typos when used with concrete module imports.
  */
+import { checkLbugNative } from '../core/lbug/native-check.js';
 function isCallable(value) {
     return typeof value === 'function';
 }
@@ -16,3 +17,19 @@ export function createLazyAction(loader, exportName) {
         await action(...args);
     };
 }
+export function createLbugLazyAction(loader, exportName) {
+    return async (...args) => {
+        const check = checkLbugNative();
+        if (!check.ok) {
+            process.stderr.write(`\n  ${check.message?.replace(/\n/g, '\n  ')}\n\n`);
+            process.exitCode = 1;
+            return;
+        }
+        const module = await loader();
+        const action = module[exportName];
+        if (!isCallable(action)) {
+            throw new Error(`Lazy action export not found: ${exportName}`);
+        }
+        await action(...args);
+    };
+}

package/dist/config/ignore-service.js

@@ -79,6 +79,7 @@ const DEFAULT_IGNORE_LIST = new Set([
     '.generated',
     'generated',
     'auto-generated',
+    'monaco-workers', // Monaco editor web-worker bundles generated for browser runtime
     '.terraform',
     '.serverless',
     // Documentation (optional - might want to keep)
@@ -294,13 +295,6 @@ export const shouldIgnorePath = (filePath) => {
                 return true;
         }
     }
-    // Ignore hidden files (starting with .)
-    if (fileName.startsWith('.') && fileName !== '.') {
-        // But allow some important config files
-        const allowedDotFiles = ['.env', '.gitignore']; // Already in IGNORED_FILES, so this is redundant
-        // Actually, let's NOT ignore all dot files - many are important configs
-        // Just rely on the explicit lists above
-    }
     // Ignore files that look like generated/bundled code
     if (fileNameLower.includes('.bundle.') ||
         fileNameLower.includes('.chunk.') ||

package/dist/core/ingestion/languages/ruby/arity.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Ruby arity check, accommodating `*args`, `**kwargs`, and defaults.
+ *
+ * The `def` metadata we care about (set by the existing Ruby method/
+ * function extractor):
+ *   - `parameterCount`         — total positional + keyword params
+ *   - `requiredParameterCount` — min required (excludes defaults / `*args` / `**kwargs`)
+ *   - `parameterTypes`         — present when types are known; we also use it
+ *                                as a "we have varargs" hint (`'*args'`,
+ *                                `'**kwargs'` literals appear in the array).
+ *
+ * Verdicts:
+ *   - `'compatible'`   — `requiredParameterCount <= argCount <= parameterCount`,
+ *                        OR the def takes `*args` (then any `argCount >= required` ok).
+ *   - `'incompatible'` — argCount is below required, OR above max with no `*args`.
+ *   - `'unknown'`      — def metadata is absent / incomplete.
+ *
+ * `'incompatible'` is a soft signal in `Registry.lookup` (penalized but
+ * still considered when no compatible candidate exists), per RFC 4.
+ */
+import type { Callsite, SymbolDefinition } from '../../../../_shared/index.js';
+export declare function rubyArityCompatibility(def: SymbolDefinition, callsite: Callsite): 'compatible' | 'unknown' | 'incompatible';

package/dist/core/ingestion/languages/ruby/arity.js

@@ -0,0 +1,38 @@
+/**
+ * Ruby arity check, accommodating `*args`, `**kwargs`, and defaults.
+ *
+ * The `def` metadata we care about (set by the existing Ruby method/
+ * function extractor):
+ *   - `parameterCount`         — total positional + keyword params
+ *   - `requiredParameterCount` — min required (excludes defaults / `*args` / `**kwargs`)
+ *   - `parameterTypes`         — present when types are known; we also use it
+ *                                as a "we have varargs" hint (`'*args'`,
+ *                                `'**kwargs'` literals appear in the array).
+ *
+ * Verdicts:
+ *   - `'compatible'`   — `requiredParameterCount <= argCount <= parameterCount`,
+ *                        OR the def takes `*args` (then any `argCount >= required` ok).
+ *   - `'incompatible'` — argCount is below required, OR above max with no `*args`.
+ *   - `'unknown'`      — def metadata is absent / incomplete.
+ *
+ * `'incompatible'` is a soft signal in `Registry.lookup` (penalized but
+ * still considered when no compatible candidate exists), per RFC 4.
+ */
+export function rubyArityCompatibility(def, callsite) {
+    const max = def.parameterCount;
+    const min = def.requiredParameterCount;
+    if (max === undefined && min === undefined)
+        return 'unknown';
+    const argCount = callsite.arity;
+    if (!Number.isFinite(argCount) || argCount < 0)
+        return 'unknown';
+    // Detect varargs/kwargs from parameterTypes if present (the Ruby
+    // method extractor stores `'*args'`/`'**kwargs'` in this list).
+    const hasVarArgs = def.parameterTypes !== undefined &&
+        def.parameterTypes.some((t) => t === '*args' || t === '**kwargs' || t.startsWith('*'));
+    if (min !== undefined && argCount < min)
+        return 'incompatible';
+    if (max !== undefined && argCount > max && !hasVarArgs)
+        return 'incompatible';
+    return 'compatible';
+}

package/dist/core/ingestion/languages/ruby/cache-stats.d.ts

@@ -0,0 +1,7 @@
+export declare function recordRubyCacheHit(): void;
+export declare function recordRubyCacheMiss(): void;
+export declare function getRubyCaptureCacheStats(): {
+    readonly hits: number;
+    readonly misses: number;
+};
+export declare function resetRubyCaptureCacheStats(): void;

package/dist/core/ingestion/languages/ruby/cache-stats.js

@@ -0,0 +1,15 @@
+let hits = 0;
+let misses = 0;
+export function recordRubyCacheHit() {
+    hits++;
+}
+export function recordRubyCacheMiss() {
+    misses++;
+}
+export function getRubyCaptureCacheStats() {
+    return { hits, misses };
+}
+export function resetRubyCaptureCacheStats() {
+    hits = 0;
+    misses = 0;
+}

package/dist/core/ingestion/languages/ruby/captures.d.ts

@@ -0,0 +1,2 @@
+import type { CaptureMatch } from '../../../../_shared/index.js';
+export declare function emitRubyScopeCaptures(sourceText: string, _filePath: string, cachedTree?: unknown): readonly CaptureMatch[];