gitnexus 1.6.4 → 1.6.5-rc.10

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

@@ -348,7 +348,18 @@ async function doInitLbug(repoId, dbPath) {
     // install; analyze owns extension installation. If LOAD fails, search
     // features degrade gracefully and the user-facing query path proceeds.
     if (!shared.ftsLoaded) {
-        shared.ftsLoaded = await loadFTSExtension(available[0], { policy: 'load-only' });
+        // Windows guard: LOAD EXTENSION fts crashes with SIGSEGV on Windows when
+        // the FTS extension binary is not installed locally (@ladybugdb/core native
+        // bug — the extension loader hits an unhandled error path that signals SIGSEGV
+        // rather than throwing a JS exception, so try/catch cannot protect here).
+        // Skip the load on Windows; bm25-index.js catches the resulting Kuzu catalog
+        // errors and returns empty BM25 results gracefully. Graph queries are unaffected.
+        if (process.platform === 'win32') {
+            shared.ftsLoaded = true;
+        }
+        else {
+            shared.ftsLoaded = await loadFTSExtension(available[0], { policy: 'load-only' });
+        }
     }
     // Register pool entry only after all connections are pre-warmed and FTS is
     // loaded.  Concurrent executeQuery calls see either "not initialized"
@@ -404,8 +415,14 @@ export async function initLbugWithDb(repoId, existingDb, dbPath) {
     // Load FTS extension if not already loaded on this Database.
     // policy: 'load-only' — same contract as initLbug above; the read pool
     // must not block on a network install during query execution.
+    // Windows guard: same SIGSEGV risk as doInitLbug above — skip on Windows.
     if (!shared.ftsLoaded) {
-        shared.ftsLoaded = await loadFTSExtension(available[0], { policy: 'load-only' });
+        if (process.platform === 'win32') {
+            shared.ftsLoaded = true;
+        }
+        else {
+            shared.ftsLoaded = await loadFTSExtension(available[0], { policy: 'load-only' });
+        }
     }
     pool.set(repoId, {
         db: existingDb,

package/dist/core/run-analyze.d.ts

@@ -42,6 +42,8 @@ export interface AnalyzeOptions {
     skipAgentsMd?: boolean;
     /** Omit volatile symbol/relationship counts from AGENTS.md and CLAUDE.md. */
     noStats?: boolean;
+    /** Skip installing standard GitNexus skill files to .claude/skills/gitnexus/. */
+    skipSkills?: boolean;
     /**
      * User-provided alias for the registry `name` (#829). When set,
      * forwarded to `registerRepo` so the indexed repo is stored under

package/dist/core/run-analyze.js

@@ -350,7 +350,11 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
                 communities: pipelineResult.communityResult?.stats.totalCommunities,
                 clusters: aggregatedClusterCount,
                 processes: pipelineResult.processResult?.stats.totalProcesses,
-            }, undefined, { skipAgentsMd: options.skipAgentsMd, noStats: options.noStats });
+            }, undefined, {
+                skipAgentsMd: options.skipAgentsMd,
+                skipSkills: options.skipSkills,
+                noStats: options.noStats,
+            });
         }
         catch {
             // Best-effort — don't fail the entire analysis for context file issues

package/dist/core/tree-sitter/safe-parse.d.ts

@@ -0,0 +1,6 @@
+import type Parser from 'tree-sitter';
+/**
+ * Parse `sourceText` safely on every platform. See {@link SAFE_PARSE_CHUNK_CHARS}
+ * for the underlying tree-sitter binding bug this works around.
+ */
+export declare function parseSourceSafe(parser: Parser, sourceText: string, oldTree?: Parser.Tree, options?: Parser.Options): Parser.Tree;

package/dist/core/tree-sitter/safe-parse.js

@@ -0,0 +1,32 @@
+/**
+ * tree-sitter 0.21.x's Node native binding crashes (SIGSEGV) on Windows when
+ * `parser.parse(string, …)` is handed a JS string longer than 32 767 chars.
+ * The crash happens inside the binding's V8 string-to-buffer conversion and
+ * cannot be intercepted from JavaScript. The callback (`Parser.Input`) overload
+ * pulls source in fixed-size chunks via repeated callback invocations and
+ * bypasses that conversion path entirely.
+ *
+ * Chunk size is comfortably below the boundary; any value < 32 767 works.
+ */
+const SAFE_PARSE_CHUNK_CHARS = 16 * 1024;
+/**
+ * Files at or below this length skip the callback machinery and use the
+ * direct string overload — the bug only manifests above the int16 boundary,
+ * so small inputs save the cost of N callback invocations per parse.
+ */
+const DIRECT_PARSE_LIMIT_CHARS = 16 * 1024;
+/**
+ * Parse `sourceText` safely on every platform. See {@link SAFE_PARSE_CHUNK_CHARS}
+ * for the underlying tree-sitter binding bug this works around.
+ */
+export function parseSourceSafe(parser, sourceText, oldTree, options) {
+    if (sourceText.length <= DIRECT_PARSE_LIMIT_CHARS) {
+        return parser.parse(sourceText, oldTree, options);
+    }
+    const input = (index) => {
+        if (index >= sourceText.length)
+            return null;
+        return sourceText.slice(index, index + SAFE_PARSE_CHUNK_CHARS);
+    };
+    return parser.parse(input, oldTree, options);
+}

package/dist/server/git-clone.js

@@ -10,6 +10,7 @@ import os from 'os';
 import fs from 'fs/promises';
 import { isIP } from 'net';
 import { logger } from '../core/logger.js';
+import { parseRepoNameFromUrl } from '../storage/git.js';
 /** Root directory for all cloned repositories. Targets must resolve inside this. */
 const CLONE_ROOT = path.resolve(path.join(os.homedir(), '.gitnexus', 'repos'));
 // A valid git repository name is filesystem-safe: alphanumerics plus `. _ -`.
@@ -25,19 +26,15 @@ const REPO_NAME_PATTERN = /^[a-zA-Z0-9._-]+$/;
  * clone root via path traversal.
  */
 export function extractRepoName(url) {
-    // Strip trailing slashes without a regex to avoid polynomial-ReDoS on
-    // pathological inputs like `https://x.com/y` + '/'.repeat(1e6). CodeQL's
-    // js/polynomial-redos flagged `/\/+$/` here.
-    let end = url.length;
-    while (end > 0 && url.charCodeAt(end - 1) === 47 /* '/' */)
-        end--;
-    const cleaned = url.slice(0, end);
-    const lastSegment = cleaned.split(/[/:]/).pop() || '';
-    const stripped = lastSegment.endsWith('.git') ? lastSegment.slice(0, -4) : lastSegment;
-    if (!stripped || stripped === '.' || stripped === '..' || !REPO_NAME_PATTERN.test(stripped)) {
+    const name = parseRepoNameFromUrl(url);
+    if (!name ||
+        name === '.' ||
+        name === '..' ||
+        name === 'unknown' ||
+        !REPO_NAME_PATTERN.test(name)) {
         throw new Error('Could not extract a valid repository name from URL');
     }
-    return stripped;
+    return name;
 }
 /** Get the clone target directory for a repo name. */
 export function getCloneDir(repoName) {
@@ -347,8 +344,8 @@ export async function cloneOrPull(url, targetDir, onProgress) {
         throw new Error(`Clone target must be a subdirectory of ${CLONE_ROOT}`);
     }
     // Always validate the requested URL — the prior shape only ran this in
-    // the clone branch, leaving the pull branch as an SSRF / blocked-host
-    // bypass when an existing clone shared the basename of an attacker URL.
+    // the code path where the repo was cloned. Now it runs unconditionally,
+    // preventing SSRF / blocked-host bypasses even when targetDir already exists.
     validateGitUrl(url);
     const exists = await fs.access(path.join(safeTarget, '.git')).then(() => true, () => false);
     if (exists) {

package/dist/storage/git.d.ts

@@ -108,13 +108,24 @@ export declare const hasGitDir: (dirPath: string) => boolean;
  */
 export declare const getRemoteOriginUrl: (repoPath: string) => string | null;
 /**
- * Parse a repository name out of a git remote URL. Handles the common
- * SSH (`git@host:owner/repo.git`), HTTPS (`https://host/owner/repo.git`),
- * `git://`, `ssh://`, and `file://` shapes. Returns `null` for empty /
- * unparseable input.
+ * Sanitize a repository name to prevent argument injection and ensure
+ * cross-platform filesystem compatibility.
  *
- * The heuristic: strip a trailing `.git` and trailing slashes, then
- * take the segment after the last `/` or `:`.
+ * 1. Strips leading dashes to prevent git command-line argument injection
+ *    (e.g., --upload-pack=evil).
+ * 2. Replaces characters that are unsafe for directory names across
+ *    platforms (Windows/macOS/Linux) with underscores.
+ * 3. Blocks path traversal segments ("." and "..") and Windows reserved
+ *    names (e.g., CON, NUL) to prevent directory escape.
+ */
+export declare const sanitizeRepoName: (name: string) => string;
+/**
+ * Parse a repository name out of a git remote URL. Handles common shapes
+ * including SSH (git@host:owner/repo.git) and HTTPS (https://host/owner/repo.git).
+ *
+ * Returns a sanitized, filesystem-safe name or null if no name could be inferred.
+ * Returning null (rather than 'unknown') allows callers to use ?? null-coalescing
+ * for fallbacks without risk of registry collisions on 'unknown'.
  */
 export declare const parseRepoNameFromUrl: (url: string | null | undefined) => string | null;
 /**

package/dist/storage/git.js

@@ -257,13 +257,36 @@ export const getRemoteOriginUrl = (repoPath) => {
     }
 };
 /**
- * Parse a repository name out of a git remote URL. Handles the common
- * SSH (`git@host:owner/repo.git`), HTTPS (`https://host/owner/repo.git`),
- * `git://`, `ssh://`, and `file://` shapes. Returns `null` for empty /
- * unparseable input.
+ * Sanitize a repository name to prevent argument injection and ensure
+ * cross-platform filesystem compatibility.
  *
- * The heuristic: strip a trailing `.git` and trailing slashes, then
- * take the segment after the last `/` or `:`.
+ * 1. Strips leading dashes to prevent git command-line argument injection
+ *    (e.g., --upload-pack=evil).
+ * 2. Replaces characters that are unsafe for directory names across
+ *    platforms (Windows/macOS/Linux) with underscores.
+ * 3. Blocks path traversal segments ("." and "..") and Windows reserved
+ *    names (e.g., CON, NUL) to prevent directory escape.
+ */
+export const sanitizeRepoName = (name) => {
+    // 1. Prevent argument injection by stripping leading dashes.
+    // 2. Remove characters that are not alphanumerics, dots, underscores, or dashes.
+    const sanitized = name.replace(/^-+/, '').replace(/[^a-zA-Z0-9._-]/g, '_');
+    // 3. Block path traversal segments and Windows reserved names.
+    // Windows reserved names like CON, PRN, AUX, NUL, COM1-9, LPT1-9 cannot
+    // be used as directory names on Windows even if they have an extension.
+    const reserved = /^(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(\..*)?$/i;
+    if (!sanitized || sanitized === '.' || sanitized === '..' || reserved.test(sanitized)) {
+        return 'unknown';
+    }
+    return sanitized;
+};
+/**
+ * Parse a repository name out of a git remote URL. Handles common shapes
+ * including SSH (git@host:owner/repo.git) and HTTPS (https://host/owner/repo.git).
+ *
+ * Returns a sanitized, filesystem-safe name or null if no name could be inferred.
+ * Returning null (rather than 'unknown') allows callers to use ?? null-coalescing
+ * for fallbacks without risk of registry collisions on 'unknown'.
  */
 export const parseRepoNameFromUrl = (url) => {
     if (!url)
@@ -271,12 +294,23 @@ export const parseRepoNameFromUrl = (url) => {
     const trimmed = url.trim();
     if (!trimmed)
         return null;
-    // Strip `.git` suffix (case-insensitive) and any trailing slashes.
-    const withoutSuffix = trimmed.replace(/\.git\/*$/i, '').replace(/\/+$/, '');
-    // Last path segment, splitting on either `/` or `:` (covers SSH form).
-    const m = withoutSuffix.match(/[/:]([^/:]+)$/);
-    const candidate = m ? m[1] : withoutSuffix;
-    return candidate || null;
+    // Strip trailing slashes without a regex to avoid polynomial-ReDoS on
+    // pathological inputs like `https://x.com/y` + '/'.repeat(1e6).
+    let end = trimmed.length;
+    while (end > 0 && trimmed.charCodeAt(end - 1) === 47 /* '/' */)
+        end--;
+    let cleaned = trimmed.slice(0, end);
+    // Strip trailing .git (case-insensitive)
+    if (cleaned.toLowerCase().endsWith('.git')) {
+        cleaned = cleaned.slice(0, -4);
+    }
+    // Last path segment, handling colons for SSH URLs and path traversal.
+    // Split on both / and : to consistently extract the last part.
+    const candidate = cleaned.split(/[/:]/).pop() || '';
+    if (!candidate)
+        return null;
+    const safe = sanitizeRepoName(candidate);
+    return safe === 'unknown' ? null : safe;
 };
 /**
  * Convenience wrapper: derive a registry-friendly name from the repo's

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.4",
+  "version": "1.6.5-rc.10",
   "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",