gitnexus 1.6.5-rc.20 → 1.6.5-rc.22

package/dist/cli/setup.js

@@ -308,6 +308,12 @@ async function installClaudeCodeHooks(result) {
         catch {
             // Script not found in source — skip
         }
+        try {
+            await fs.copyFile(path.join(pluginHooksPath, 'hook-lock.cjs'), path.join(destHooksDir, 'hook-lock.cjs'));
+        }
+        catch {
+            // Helper not found in source — skip
+        }
         const hookPath = path.join(destHooksDir, 'gitnexus-hook.cjs').replace(/\\/g, '/');
         // Escape backslashes FIRST, then quotes (CodeQL js/incomplete-sanitization).
         // The previous shape `replace(/"/g, '\\"')` alone would let `path\with"quote`

package/dist/core/wiki/generator.js

@@ -14,6 +14,7 @@ import path from 'path';
 import { execSync, execFileSync } from 'child_process';
 import { initWikiDb, closeWikiDb, touchWikiDb, getFilesWithExports, getAllFiles, getIntraModuleCallEdges, getInterModuleCallEdges, getProcessesForFiles, getAllProcesses, getInterModuleEdgesForOverview, } from './graph-queries.js';
 import { generateHTMLViewer } from './html-viewer.js';
+import { sanitizeMermaidMarkdown } from './mermaid-sanitizer.js';
 import { callLLM, estimateTokens, } from './llm-client.js';
 import { callCursorLLM, resolveCursorConfig } from './cursor-client.js';
 import { GROUPING_SYSTEM_PROMPT, GROUPING_USER_PROMPT, MODULE_SYSTEM_PROMPT, MODULE_USER_PROMPT, PARENT_SYSTEM_PROMPT, PARENT_USER_PROMPT, OVERVIEW_SYSTEM_PROMPT, OVERVIEW_USER_PROMPT, fillTemplate, formatFileListForGrouping, formatDirectoryTree, formatCallEdges, formatProcesses, } from './prompts.js';
@@ -445,7 +446,7 @@ export class WikiGenerator {
         });
         const response = await this.invokeLLM(prompt, MODULE_SYSTEM_PROMPT, this.streamOpts(node.name));
         // Write page with front matter
-        const pageContent = `# ${node.name}\n\n${response.content}`;
+        const pageContent = sanitizeMermaidMarkdown(`# ${node.name}\n\n${response.content}`);
         await fs.writeFile(path.join(this.wikiDir, `${node.slug}.md`), pageContent, 'utf-8');
     }
     /**
@@ -480,7 +481,7 @@ export class WikiGenerator {
             CROSS_PROCESSES: formatProcesses(processes),
         });
         const response = await this.invokeLLM(prompt, PARENT_SYSTEM_PROMPT, this.streamOpts(node.name));
-        const pageContent = `# ${node.name}\n\n${response.content}`;
+        const pageContent = sanitizeMermaidMarkdown(`# ${node.name}\n\n${response.content}`);
         await fs.writeFile(path.join(this.wikiDir, `${node.slug}.md`), pageContent, 'utf-8');
     }
     // ─── Phase 3: Generate Overview ─────────────────────────────────────
@@ -516,7 +517,7 @@ export class WikiGenerator {
             TOP_PROCESSES: formatProcesses(topProcesses),
         });
         const response = await this.invokeLLM(prompt, OVERVIEW_SYSTEM_PROMPT, this.streamOpts('Generating overview', 88));
-        const pageContent = `# ${path.basename(this.repoPath)} — Wiki\n\n${response.content}`;
+        const pageContent = sanitizeMermaidMarkdown(`# ${path.basename(this.repoPath)} — Wiki\n\n${response.content}`);
         await fs.writeFile(path.join(this.wikiDir, 'overview.md'), pageContent, 'utf-8');
     }
     // ─── Incremental Updates ────────────────────────────────────────────

package/dist/core/wiki/html-viewer.js

@@ -6,6 +6,7 @@
  */
 import fs from 'fs/promises';
 import path from 'path';
+import { sanitizeMermaidMarkdown } from './mermaid-sanitizer.js';
 /**
  * Generate the wiki HTML viewer (index.html) from existing markdown pages.
  */
@@ -33,7 +34,7 @@ export async function generateHTMLViewer(wikiDir, projectName) {
     const dirEntries = await fs.readdir(wikiDir);
     for (const f of dirEntries.filter((f) => f.endsWith('.md'))) {
         const content = await fs.readFile(path.join(wikiDir, f), 'utf-8');
-        pages[f.replace(/\.md$/, '')] = content;
+        pages[f.replace(/\.md$/, '')] = sanitizeMermaidMarkdown(content);
     }
     const html = buildHTML(projectName, moduleTree, pages, meta);
     const outputPath = path.join(wikiDir, 'index.html');

package/dist/core/wiki/mermaid-sanitizer.d.ts

@@ -0,0 +1,2 @@
+export declare function sanitizeMermaidMarkdown(markdown: string): string;
+export declare function sanitizeMermaidDiagram(diagram: string): string;

package/dist/core/wiki/mermaid-sanitizer.js

@@ -0,0 +1,100 @@
+const MERMAID_FENCE_RE = /```mermaid\s*\n([\s\S]*?)```/g;
+const NODE_LABEL_RE = /(\[[^\]\n]*(?:\\n)[^\]\n]*\]|\{[^}\n]*(?:\\n)[^}\n]*\}|\([^)\n]*(?:\\n)[^)\n]*\))/g;
+const EDGE_LABEL_RE = /\|([^|\n]+)\|/g;
+const UNSAFE_EDGE_LABEL_RE = /[()[\]{}<>]/;
+const UNSAFE_NODE_ID_RE = /[^A-Za-z0-9_-]/;
+const NODE_ID_RE = /^[A-Za-z0-9_.:/()-]+$/;
+const LINE_PREFIX_RE = /^(\s*(?:(?:[-A-Za-z0-9_]+)\s*:\s*)?)(.*)$/;
+const EDGE_RE = /(\s*(?:[ox])?(?:--+|==+|\.\.+)(?:[>|ox])?\|[^|\n]*\|(?:[>|ox])?|\s*(?:[ox])?(?:--+|==+|\.\.+)(?:[>|ox])?|\s*<--+>?\s*)/g;
+export function sanitizeMermaidMarkdown(markdown) {
+    return markdown.replace(MERMAID_FENCE_RE, (_match, diagram) => {
+        return '```mermaid\n' + sanitizeMermaidDiagram(diagram) + '```';
+    });
+}
+export function sanitizeMermaidDiagram(diagram) {
+    const aliases = new Map();
+    let nextAlias = 1;
+    const aliasFor = (id) => {
+        const existing = aliases.get(id);
+        if (existing)
+            return existing;
+        const base = id.replace(/[^A-Za-z0-9_-]/g, '_').replace(/^_+|_+$/g, '') || 'node';
+        let alias = base;
+        while ([...aliases.values()].includes(alias)) {
+            nextAlias += 1;
+            alias = `${base}_${nextAlias}`;
+        }
+        aliases.set(id, alias);
+        return alias;
+    };
+    return diagram
+        .split('\n')
+        .map((line) => sanitizeMermaidLine(line, aliasFor))
+        .join('\n');
+}
+function sanitizeMermaidLine(line, aliasFor) {
+    let sanitized = replaceLiteralLineBreaksInLabels(line);
+    sanitized = quoteUnsafeEdgeLabels(sanitized);
+    const prefixMatch = sanitized.match(LINE_PREFIX_RE);
+    if (!prefixMatch)
+        return sanitized;
+    const prefix = prefixMatch[1];
+    const body = prefixMatch[2];
+    if (isDirectiveLine(body))
+        return sanitized;
+    const parts = body.split(EDGE_RE);
+    if (parts.length === 1)
+        return sanitized;
+    for (let i = 0; i < parts.length; i += 2) {
+        parts[i] = sanitizeNodeReference(parts[i], aliasFor);
+    }
+    return prefix + parts.join('');
+}
+function replaceLiteralLineBreaksInLabels(line) {
+    return line.replace(NODE_LABEL_RE, (label) => label.replace(/\\n/g, '<br/>'));
+}
+function quoteUnsafeEdgeLabels(line) {
+    return line.replace(EDGE_LABEL_RE, (match, label) => {
+        const trimmed = label.trim();
+        if (!UNSAFE_EDGE_LABEL_RE.test(trimmed))
+            return match;
+        if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+            (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+            return match;
+        }
+        return `|"${escapeMermaidLabel(trimmed)}"|`;
+    });
+}
+function sanitizeNodeReference(segment, aliasFor) {
+    const match = segment.match(/^(\s*)([A-Za-z0-9_.:/()-]+)(.*?)(\s*)$/);
+    if (!match)
+        return segment;
+    const [, leading, id, suffix, trailing] = match;
+    if (!NODE_ID_RE.test(id) || !UNSAFE_NODE_ID_RE.test(id))
+        return segment;
+    const hasInlineLabel = suffix.trim().startsWith('[') || suffix.trim().startsWith('(') || suffix.trim().startsWith('{');
+    if (hasInlineLabel)
+        return `${leading}${aliasFor(id)}${suffix}${trailing}`;
+    return `${leading}${aliasFor(id)}["${escapeMermaidLabel(id)}"]${suffix}${trailing}`;
+}
+function escapeMermaidLabel(label) {
+    return label.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+function isDirectiveLine(line) {
+    const trimmed = line.trim();
+    return (trimmed === '' ||
+        trimmed.startsWith('%%') ||
+        trimmed.startsWith('graph ') ||
+        trimmed.startsWith('flowchart ') ||
+        trimmed.startsWith('sequenceDiagram') ||
+        trimmed.startsWith('classDiagram') ||
+        trimmed.startsWith('stateDiagram') ||
+        trimmed.startsWith('erDiagram') ||
+        trimmed.startsWith('journey') ||
+        trimmed.startsWith('gantt') ||
+        trimmed.startsWith('pie ') ||
+        trimmed.startsWith('mindmap') ||
+        trimmed.startsWith('timeline') ||
+        trimmed.startsWith('subgraph ') ||
+        trimmed === 'end');
+}

package/hooks/claude/gitnexus-hook.cjs

@@ -14,6 +14,7 @@
 const fs = require('fs');
 const path = require('path');
 const { spawnSync } = require('child_process');
+const { acquireHookSlot } = require('./hook-lock.cjs');
 
 /**
  * Read JSON input from stdin synchronously.
@@ -207,7 +208,8 @@ function runGitNexusCli(cliPath, args, cwd, timeout) {
 function handlePreToolUse(input) {
   const cwd = input.cwd || process.cwd();
   if (!path.isAbsolute(cwd)) return;
-  if (!findGitNexusDir(cwd)) return;
+  const gitNexusDir = findGitNexusDir(cwd);
+  if (!gitNexusDir) return;
 
   const toolName = input.tool_name || '';
   const toolInput = input.tool_input || {};
@@ -217,6 +219,9 @@ function handlePreToolUse(input) {
   const pattern = extractPattern(toolName, toolInput);
   if (!pattern || pattern.length < 3) return;
 
+  const release = acquireHookSlot(gitNexusDir);
+  if (!release) return;
+
   const cliPath = resolveCliPath();
   let result = '';
   try {
@@ -226,6 +231,8 @@ function handlePreToolUse(input) {
     }
   } catch {
     /* graceful failure */
+  } finally {
+    release();
   }
 
   if (result && result.trim()) {

package/hooks/claude/hook-lock.cjs

@@ -0,0 +1,119 @@
+const fs = require('fs');
+const path = require('path');
+
+const HOOK_LOCK_SUBDIR = '.hook-locks';
+const HOOK_LOCK_MAX_INFLIGHT = 3;
+const HOOK_LOCK_STALE_MS = 30000;
+
+function acquireHookSlot(gitNexusDir) {
+  const lockDir = path.join(gitNexusDir, HOOK_LOCK_SUBDIR);
+  try {
+    fs.mkdirSync(lockDir, { recursive: true });
+  } catch {
+    // Cannot create lock dir (read-only fs, cross-user perm denial, out of
+    // inodes, etc.) — fail closed by returning null. Caller skips augment.
+    // Fail-open here would let N concurrent hooks all proceed unguarded and
+    // reintroduce the #1486 fan-out the guard exists to prevent.
+    return null;
+  }
+
+  const myPidStr = String(process.pid);
+
+  for (let slot = 0; slot < HOOK_LOCK_MAX_INFLIGHT; slot++) {
+    const slotPath = path.join(lockDir, `slot-${slot}.lock`);
+    for (let attempt = 0; attempt < 2; attempt++) {
+      try {
+        fs.writeFileSync(slotPath, myPidStr, { flag: 'wx' });
+        let released = false;
+        const release = () => {
+          if (released) return;
+          released = true;
+          try {
+            // Only unlink if we still own the slot. If we appeared stale and
+            // another hook took over, the file now belongs to it — leave alone.
+            const content = fs.readFileSync(slotPath, 'utf-8').trim();
+            if (content === myPidStr) fs.unlinkSync(slotPath);
+          } catch {
+            /* already removed or unreadable */
+          }
+        };
+        process.on('exit', release);
+        return release;
+      } catch {
+        // Slot exists. Decide whether to take it over.
+        // Open once and inspect mtime + content via the same fd so there's
+        // no TOCTOU between the metadata check and the content read
+        // (codeql js/file-system-race).
+        let fd;
+        try {
+          fd = fs.openSync(slotPath, 'r');
+        } catch {
+          continue; // Vanished between EEXIST and open — retry this slot.
+        }
+        let isLive = false;
+        let mtimeMs = Date.now();
+        try {
+          mtimeMs = fs.fstatSync(fd).mtimeMs;
+          const buf = Buffer.alloc(32);
+          const n = fs.readSync(fd, buf, 0, 32, 0);
+          const ownerStr = buf.slice(0, n).toString('utf-8').trim();
+          if (ownerStr === '') {
+            // Owner created the file but hasn't written its PID yet. The
+            // wx open+write window is microseconds; give it the benefit
+            // of the doubt and treat as live.
+            isLive = true;
+          } else {
+            const owner = Number.parseInt(ownerStr, 10);
+            if (Number.isFinite(owner) && owner > 0) {
+              try {
+                process.kill(owner, 0);
+                isLive = true;
+              } catch (e) {
+                // ESRCH = process gone → treat as dead. EPERM = process exists
+                // but owned by another user (cross-user lock dir) → still alive,
+                // keep the slot. Anything else: be conservative, assume alive.
+                if (e && e.code === 'ESRCH') {
+                  isLive = false;
+                } else {
+                  isLive = true;
+                }
+              }
+            }
+          }
+        } catch {
+          /* unreadable — treat as dead */
+        } finally {
+          try {
+            fs.closeSync(fd);
+          } catch {
+            /* already closed */
+          }
+        }
+        // For slots younger than HOOK_LOCK_STALE_MS, PID-liveness wins —
+        // a slow-but-alive hook is never wrongly evicted. For older slots,
+        // age is the final arbiter as a defense against PID reuse on long-
+        // abandoned slots. 30s >> the 7s augment timeout, so a healthy run
+        // never crosses this threshold.
+        if (isLive && Date.now() - mtimeMs > HOOK_LOCK_STALE_MS) {
+          isLive = false;
+        }
+        if (isLive) break; // Try the next slot.
+        try {
+          fs.unlinkSync(slotPath);
+        } catch {
+          /* another hook beat us to it — retry will hit EEXIST */
+        }
+        // Loop and retry this slot.
+      }
+    }
+  }
+
+  return null;
+}
+
+module.exports = {
+  HOOK_LOCK_SUBDIR,
+  HOOK_LOCK_MAX_INFLIGHT,
+  HOOK_LOCK_STALE_MS,
+  acquireHookSlot,
+};

package/package.json

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