gitnexus 1.6.6-rc.62 → 1.6.6-rc.63

package/dist/core/lbug/lbug-adapter.js

@@ -4,11 +4,13 @@ import { createInterface } from 'readline';
 import { once } from 'events';
 import { finished } from 'stream/promises';
 import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
 import lbug from '@ladybugdb/core';
 import { NODE_TABLES, REL_TABLE_NAME, SCHEMA_QUERIES, EMBEDDING_TABLE_NAME, STALE_HASH_SENTINEL, } from './schema.js';
 import { streamAllCSVsToDisk } from './csv-generator.js';
 import { extensionManager } from './extension-loader.js';
-import { closeLbugConnection, isDbBusyError, isOpenRetryExhausted, isWalCorruptionError, openLbugConnection, WAL_RECOVERY_SUGGESTION, waitForWindowsHandleRelease, } from './lbug-config.js';
+import { closeLbugConnection, isDbBusyError, isOpenRetryExhausted, isWalCorruptionError, openLbugConnection, toNativeSafePath, WAL_RECOVERY_SUGGESTION, waitForWindowsHandleRelease, } from './lbug-config.js';
 import { finalizeLbugSidecarsAfterClose, inspectLbugSidecars, isMissingShadowSidecarError, isReadOnlyShadowReplayError, preflightLbugSidecars, quarantineWalForMissingShadow, renameFailureMessage, shadowSidecarRecoveryMessage, } from './sidecar-recovery.js';
 import { isVectorExtensionSupportedByPlatform } from '../platform/capabilities.js';
 import { logger } from '../logger.js';
@@ -298,7 +300,7 @@ const runWithSessionLock = async (operation) => {
         release?.();
     }
 };
-const normalizeCopyPath = (filePath) => filePath.replace(/\\/g, '/');
+const normalizeCopyPath = (filePath) => toNativeSafePath(filePath).replace(/\\/g, '/');
 const closeQueryResult = async (result) => {
     try {
         await result.close();
@@ -718,7 +720,14 @@ export const loadGraphToLbug = async (graph, repoPath, storagePath, onProgress)
         throw new Error('LadybugDB not initialized. Call initLbug first.');
     }
     const log = onProgress || (() => { });
-    const csvDir = path.join(storagePath, 'csv');
+    let csvDir;
+    if (process.platform === 'win32' && /[^\x00-\x7F]/.test(storagePath)) {
+        const hash = crypto.createHash('sha256').update(storagePath).digest('hex').slice(0, 16);
+        csvDir = toNativeSafePath(path.join(os.tmpdir(), `gitnexus-csv-${hash}`));
+    }
+    else {
+        csvDir = path.join(storagePath, 'csv');
+    }
     log('Streaming CSVs to disk...');
     const csvResult = await streamAllCSVsToDisk(graph, repoPath, csvDir);
     const validTables = new Set(NODE_TABLES);

package/dist/core/lbug/lbug-config.d.ts

@@ -1,4 +1,6 @@
 import type lbug from '@ladybugdb/core';
+export declare function cleanupNativePathJunctions(): void;
+export declare function toNativeSafePath(p: string): string;
 /**
  * Shared configuration for `@ladybugdb/core` `Database` construction.
  *

package/dist/core/lbug/lbug-config.js

@@ -1,7 +1,184 @@
 import fs from 'fs/promises';
+import fsSync from 'fs';
 import os from 'os';
 import path from 'path';
+import crypto from 'crypto';
+import { execFileSync } from 'child_process';
+import { isMainThread } from 'worker_threads';
 import { logger } from '../logger.js';
+// ─── Windows non-ASCII path workaround (#1811) ───────────────────────────────
+//
+// KuzuDB's native C++ layer on Windows uses CreateFileA (ANSI), not
+// CreateFileW. Non-ASCII path bytes from Node.js (UTF-8) are
+// misinterpreted via the system's Active Code Page (e.g. GBK), producing
+// a garbled path — "Error 3: The system cannot find the path."
+//
+// Layered workaround:
+//   1. Try 8.3 short-name form (fast, no persistent state)
+//   2. Fall back to an NTFS junction from an ASCII temp path
+//   3. If both fail, log a diagnostic and return the original path
+const NON_ASCII_RE = /[^\x00-\x7F]/;
+const JUNCTION_PREFIX = 'gitnexus-junction-';
+const activeJunctions = new Set();
+let cleanupRegistered = false;
+let orphanScanDone = false;
+function junctionHash(targetDir) {
+    return crypto.createHash('sha256').update(targetDir).digest('hex').slice(0, 16);
+}
+function tryShortPath(p) {
+    try {
+        // Pass the path via environment variable so the command string is
+        // static — avoids CodeQL command-injection taint (the path never
+        // appears in the shell command text).
+        const result = execFileSync('cmd.exe', ['/c', 'for %I in ("%GITNEXUS_SP%") do @echo %~sI'], {
+            encoding: 'utf-8',
+            timeout: 5000,
+            windowsHide: true,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: { ...process.env, GITNEXUS_SP: p },
+        });
+        const shortPath = result.trim();
+        if (shortPath &&
+            !NON_ASCII_RE.test(shortPath) &&
+            (!shortPath.includes('?') || p.includes('?'))) {
+            return shortPath;
+        }
+    }
+    catch {
+        // 8.3 unavailable or cmd failed
+    }
+    return null;
+}
+function tryJunction(targetDir, leaf) {
+    const hash = junctionHash(targetDir);
+    const junctionLink = path.join(os.tmpdir(), `${JUNCTION_PREFIX}${hash}`);
+    if (fsSync.existsSync(junctionLink)) {
+        try {
+            const existing = fsSync.readlinkSync(junctionLink);
+            if (path.resolve(existing) === path.resolve(targetDir)) {
+                activeJunctions.add(junctionLink);
+                return path.join(junctionLink, leaf);
+            }
+            fsSync.rmSync(junctionLink, { recursive: true, force: true });
+        }
+        catch {
+            // Stale or broken junction — remove and recreate
+            try {
+                fsSync.rmSync(junctionLink, { recursive: true, force: true });
+            }
+            catch {
+                /* best effort */
+            }
+        }
+    }
+    try {
+        fsSync.symlinkSync(targetDir, junctionLink, 'junction');
+        activeJunctions.add(junctionLink);
+        return path.join(junctionLink, leaf);
+    }
+    catch (err) {
+        if (err.code === 'EEXIST') {
+            try {
+                const existing = fsSync.readlinkSync(junctionLink);
+                if (path.resolve(existing) === path.resolve(targetDir)) {
+                    activeJunctions.add(junctionLink);
+                    return path.join(junctionLink, leaf);
+                }
+            }
+            catch {
+                /* cannot verify — fall through */
+            }
+        }
+    }
+    return null;
+}
+function registerCleanupHandlers() {
+    if (cleanupRegistered)
+        return;
+    cleanupRegistered = true;
+    process.on('exit', () => cleanupNativePathJunctions());
+    for (const signal of ['SIGTERM', 'SIGINT']) {
+        process.on(signal, () => {
+            cleanupNativePathJunctions();
+            if (process.platform === 'win32') {
+                process.exit(signal === 'SIGINT' ? 130 : 143);
+            }
+            else {
+                process.kill(process.pid, signal);
+            }
+        });
+    }
+}
+function scanOrphanedJunctions() {
+    if (orphanScanDone)
+        return;
+    orphanScanDone = true;
+    try {
+        const tmpdir = os.tmpdir();
+        const entries = fsSync.readdirSync(tmpdir);
+        for (const entry of entries) {
+            if (!entry.startsWith(JUNCTION_PREFIX))
+                continue;
+            const junctionPath = path.join(tmpdir, entry);
+            try {
+                const target = fsSync.readlinkSync(junctionPath);
+                try {
+                    fsSync.lstatSync(target);
+                }
+                catch {
+                    fsSync.rmSync(junctionPath, { recursive: true, force: true });
+                }
+            }
+            catch {
+                // Not a symlink/junction or unreadable — leave it
+            }
+        }
+    }
+    catch {
+        // tmpdir unreadable — skip scan
+    }
+}
+export function cleanupNativePathJunctions() {
+    for (const junctionPath of activeJunctions) {
+        try {
+            fsSync.rmSync(junctionPath, { recursive: true, force: true });
+        }
+        catch {
+            // Best effort — EPERM on Windows is common during exit
+        }
+    }
+    activeJunctions.clear();
+}
+export function toNativeSafePath(p) {
+    if (process.platform !== 'win32')
+        return p;
+    if (!NON_ASCII_RE.test(p))
+        return p;
+    if (isMainThread) {
+        scanOrphanedJunctions();
+        registerCleanupHandlers();
+    }
+    const shortPath = tryShortPath(p);
+    if (shortPath)
+        return shortPath;
+    if (!isMainThread) {
+        logger.warn(`GitNexus: non-ASCII path in worker thread — junction fallback skipped. ` +
+            `Path: "${p}". 8.3 short names may need to be enabled on this volume.`);
+        return p;
+    }
+    const targetDir = path.dirname(p);
+    const leaf = path.basename(p);
+    if (fsSync.existsSync(targetDir)) {
+        const junctionResult = tryJunction(targetDir, leaf);
+        if (junctionResult)
+            return junctionResult;
+    }
+    logger.warn(`GitNexus: non-ASCII path "${p}" could not be converted to an ASCII-safe form. ` +
+        'LadybugDB may fail with "Cannot open file." To fix: move the repo to a path ' +
+        'without CJK/Unicode characters, or enable 8.3 short names on this volume ' +
+        '(fsutil 8dot3name set 0).');
+    return p;
+}
 /**
  * Shared configuration for `@ladybugdb/core` `Database` construction.
  *
@@ -306,9 +483,10 @@ const openWithLockRetry = async (construct, dbPath) => {
     throw tagOpenRetryExhausted(originalLockError);
 };
 export async function openLbugConnection(lbugModule, databasePath, options = {}) {
+    const safePath = toNativeSafePath(databasePath);
     let db;
     try {
-        db = await openWithLockRetry(() => createLbugDatabase(lbugModule, databasePath, options), databasePath);
+        db = await openWithLockRetry(() => createLbugDatabase(lbugModule, safePath, options), safePath);
         return { db, conn: new lbugModule.Connection(db) };
     }
     catch (err) {

package/dist/core/lbug/pool-adapter.js

@@ -19,7 +19,7 @@ import os from 'os';
 import path from 'path';
 import lbug from '@ladybugdb/core';
 import { isReadOnlyDbError, loadFTSExtension } from './lbug-adapter.js';
-import { createLbugDatabase, isWalCorruptionError, WAL_RECOVERY_SUGGESTION, } from './lbug-config.js';
+import { createLbugDatabase, isWalCorruptionError, toNativeSafePath, WAL_RECOVERY_SUGGESTION, } from './lbug-config.js';
 import { isMissingFsError, isMissingShadowSidecarError, isReadOnlyShadowReplayError, preflightLbugSidecars, quarantineWalForMissingShadow, renameFailureMessage, statIfExists, } from './sidecar-recovery.js';
 /**
  * Probe whether a Windows FTS extension binary is locally installed under
@@ -313,7 +313,7 @@ async function probeDatabaseForShadowReplay(db) {
 async function replayShadowPagesWithWritableOpen(dbPath) {
     let db;
     try {
-        db = createLbugDatabase(lbug, dbPath, { throwOnWalReplayFailure: false });
+        db = createLbugDatabase(lbug, toNativeSafePath(dbPath), { throwOnWalReplayFailure: false });
         await db.init();
         await probeDatabaseForShadowReplay(db);
     }
@@ -340,7 +340,7 @@ async function openReadOnlyDatabase(dbPath) {
             logger: poolSidecarLogger,
             allowQuarantine: true,
         });
-        db = createLbugDatabase(lbug, dbPath, {
+        db = createLbugDatabase(lbug, toNativeSafePath(dbPath), {
             readOnly: true,
             throwOnWalReplayFailure: false,
         });
@@ -360,7 +360,7 @@ async function openReadOnlyDatabase(dbPath) {
                     logger: poolSidecarLogger,
                     allowQuarantine: true,
                 });
-                db = createLbugDatabase(lbug, dbPath, {
+                db = createLbugDatabase(lbug, toNativeSafePath(dbPath), {
                     readOnly: true,
                     throwOnWalReplayFailure: false,
                 });
@@ -374,7 +374,7 @@ async function openReadOnlyDatabase(dbPath) {
             await db.close().catch(() => { });
             db = undefined;
             await replayShadowPagesWithWritableOpen(dbPath);
-            db = createLbugDatabase(lbug, dbPath, {
+            db = createLbugDatabase(lbug, toNativeSafePath(dbPath), {
                 readOnly: true,
                 throwOnWalReplayFailure: false,
             });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.6-rc.62",
+  "version": "1.6.6-rc.63",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",

package/scripts/cross-platform-tests.ts

@@ -59,6 +59,7 @@ const LBUG_NATIVE = [
   'test/integration/lbug-close-handle-release.test.ts',
   'test/integration/lbug-orphan-sidecar-recovery.test.ts',
   'test/integration/lbug-readonly-init.test.ts',
+  'test/integration/lbug-non-ascii-path.test.ts',
   'test/integration/local-backend.test.ts',
   'test/integration/local-backend-calltool.test.ts',
   'test/integration/search-core.test.ts',