pi-gitnexus-fork 0.7.0

package/dist/repo-resolver.js

@@ -0,0 +1,123 @@
+import { exec } from 'child_process';
+import { basename } from 'path';
+import { findGitNexusRoot } from './gitnexus';
+/**
+ * RepoResolver — maps a host cwd to a server-side repo path.
+ *
+ * Strategy:
+ *  1. Fetch registry from GET <serverUrl>/api/repos
+ *  2. Match by git remote URL (most reliable)
+ *  3. Match by basename of cwd vs basename of server path
+ *  4. Fallback: return findGitNexusRoot(cwd)
+ *
+ * Uses instance-level cache so separate resolver instances don't share state.
+ */
+export class RepoResolver {
+    serverUrl;
+    registry = [];
+    registryFetched = false;
+    resolutionCache = new Map();
+    constructor(config) {
+        this.serverUrl = config.serverUrl.replace(/\/+$/, '');
+    }
+    /**
+     * Fetch the repo registry from the server.
+     * Only fetches once per instance; subsequent calls return cached data.
+     */
+    async fetchRegistry() {
+        if (this.registryFetched)
+            return this.registry;
+        try {
+            const res = await fetch(`${this.serverUrl}/api/repos`, {
+                method: 'GET',
+                headers: { Accept: 'application/json' },
+                signal: AbortSignal.timeout(10_000),
+            });
+            if (!res.ok) {
+                this.registry = [];
+                this.registryFetched = true;
+                return this.registry;
+            }
+            const data = (await res.json());
+            this.registry = Array.isArray(data) ? data : [];
+            this.registryFetched = true;
+            return this.registry;
+        }
+        catch {
+            this.registry = [];
+            this.registryFetched = true;
+            return this.registry;
+        }
+    }
+    /** Clear cached registry and resolution cache. Re-fetches on next resolveRepo. */
+    async refreshRegistry() {
+        this.registry = [];
+        this.registryFetched = false;
+        this.resolutionCache.clear();
+        await this.fetchRegistry();
+    }
+    /** Return the currently cached registry entries. */
+    getRegistry() {
+        return this.registry;
+    }
+    /**
+     * Resolve a host cwd to a server-side repo path (string).
+     * Uses instance-level resolution cache.
+     */
+    async resolveRepo(cwd) {
+        if (this.resolutionCache.has(cwd)) {
+            return this.resolutionCache.get(cwd);
+        }
+        // Ensure registry is loaded
+        await this.fetchRegistry();
+        const result = await this.doResolve(cwd);
+        this.resolutionCache.set(cwd, result);
+        return result;
+    }
+    async doResolve(cwd) {
+        const hostBasename = basename(cwd);
+        // Try to get git remote URL from host cwd
+        const hostRemoteUrl = await this.getGitRemoteUrl(cwd);
+        // Strategy 1: match by git remote URL
+        if (hostRemoteUrl) {
+            const match = this.registry.find((r) => r.remoteUrl && normalizeGitUrl(r.remoteUrl) === normalizeGitUrl(hostRemoteUrl));
+            if (match)
+                return match.path;
+        }
+        // Strategy 2: match by basename
+        const basenameMatch = this.registry.find((r) => basename(r.path) === hostBasename || r.name === hostBasename);
+        if (basenameMatch)
+            return basenameMatch.path;
+        // Strategy 3: fallback — findGitNexusRoot
+        return findGitNexusRoot(cwd);
+    }
+    getGitRemoteUrl(cwd) {
+        return new Promise((resolve_) => {
+            exec('git remote -v', { cwd, timeout: 5000 }, (err, stdout) => {
+                if (err) {
+                    resolve_(null);
+                    return;
+                }
+                // Parse "origin\t<url> (fetch)" format
+                const match = stdout?.match(/\S+\s+(\S+)\s+\(fetch\)/);
+                resolve_(match ? match[1] : null);
+            });
+        });
+    }
+}
+/**
+ * Normalize a git remote URL for comparison.
+ * Strips trailing .git, protocol prefixes, and user@host: prefixes.
+ */
+export function normalizeGitUrl(url) {
+    let normalized = url.trim();
+    if (normalized.endsWith('.git'))
+        normalized = normalized.slice(0, -4);
+    if (normalized.includes(':') && !normalized.startsWith('http')) {
+        normalized = normalized.split(':').pop() ?? normalized;
+    }
+    normalized = normalized.replace(/^https?:\/\//, '');
+    normalized = normalized.replace(/^[^@]+@/, '');
+    normalized = normalized.replace(/\\/g, '/');
+    return normalized;
+}

package/dist/tools.d.ts

@@ -0,0 +1,6 @@
+import type { ExtensionAPI } from '@mariozechner/pi-coding-agent';
+/**
+ * Register all GitNexus tools with pi.
+ * Called once from index.ts — this is the only way tools.ts accesses pi.
+ */
+export declare function registerTools(pi: ExtensionAPI): void;

package/dist/tools.js

@@ -0,0 +1,230 @@
+import { StringEnum } from '@mariozechner/pi-ai';
+import { isAbsolute } from 'path';
+import { Type } from 'typebox';
+import { expandUserPath, findGitNexusIndex, findGitNexusRoot, normalizePathArg, safeResolvePath, toRepoRelativePath, validateRepoRelativePath } from './gitnexus';
+import { mcpClient } from './mcp-client';
+function text(msg) {
+    return { content: [{ type: 'text', text: msg }], details: undefined };
+}
+const NO_INDEX = 'No GitNexus index found. Run: /gitnexus analyze';
+function normalizeRepoOverride(repo) {
+    if (!repo?.trim())
+        return undefined;
+    return looksLikeRepoPath(repo) ? expandUserPath(repo) : repo;
+}
+function buildRepoArgs(ctx, params) {
+    const normalizedRepo = typeof params.repo === 'string' ? normalizeRepoOverride(params.repo) : undefined;
+    if (normalizedRepo) {
+        return { ...params, repo: normalizedRepo };
+    }
+    const repoRoot = findGitNexusRoot(ctx.cwd);
+    return repoRoot ? { ...params, repo: repoRoot } : params;
+}
+function hasRepoOverride(params) {
+    return typeof params.repo === 'string' && params.repo.trim().length > 0;
+}
+function looksLikeRepoPath(repo) {
+    if (!repo)
+        return false;
+    const expanded = expandUserPath(repo);
+    return isAbsolute(expanded) || expanded.startsWith('./') || expanded.startsWith('../');
+}
+function shouldAllowQuery(ctx, params) {
+    return hasRepoOverride(params) || findGitNexusIndex(ctx.cwd);
+}
+function resolveFilePath(ctx, filePath, repo) {
+    const normalizedPath = normalizePathArg(filePath);
+    if (looksLikeRepoPath(repo)) {
+        return toRepoRelativePath(normalizedPath, expandUserPath(repo));
+    }
+    if (repo?.trim()) {
+        return validateRepoRelativePath(normalizedPath);
+    }
+    const repoRoot = findGitNexusRoot(ctx.cwd);
+    if (repoRoot) {
+        return toRepoRelativePath(normalizedPath, repoRoot);
+    }
+    if (isAbsolute(normalizedPath)) {
+        return safeResolvePath(normalizedPath, ctx.cwd);
+    }
+    return validateRepoRelativePath(normalizedPath);
+}
+function normalizeContextArgs(ctx, params) {
+    const filePath = params.file_path ?? params.file;
+    const args = {
+        ...(params.name ? { name: params.name } : {}),
+        ...(params.uid ? { uid: params.uid } : {}),
+        ...(params.include_content !== undefined ? { include_content: params.include_content } : {}),
+    };
+    if (filePath) {
+        const safe = resolveFilePath(ctx, filePath, params.repo);
+        if (!safe)
+            return null;
+        args.file_path = safe;
+    }
+    return buildRepoArgs(ctx, params.repo ? { ...args, repo: params.repo } : args);
+}
+function normalizeImpactArgs(ctx, params) {
+    return buildRepoArgs(ctx, {
+        target: params.target,
+        ...(params.direction ? { direction: params.direction } : {}),
+        ...((params.maxDepth ?? params.depth) !== undefined ? { maxDepth: params.maxDepth ?? params.depth } : {}),
+        ...((params.includeTests ?? params.include_tests) !== undefined
+            ? { includeTests: params.includeTests ?? params.include_tests }
+            : {}),
+        ...(params.relationTypes ? { relationTypes: params.relationTypes } : {}),
+        ...(params.minConfidence !== undefined ? { minConfidence: params.minConfidence } : {}),
+        ...(params.repo ? { repo: params.repo } : {}),
+    });
+}
+/**
+ * Register all GitNexus tools with pi.
+ * Called once from index.ts — this is the only way tools.ts accesses pi.
+ */
+export function registerTools(pi) {
+    pi.registerTool({
+        name: 'gitnexus_list_repos',
+        label: 'GitNexus List Repos',
+        description: 'List all repositories indexed by GitNexus. Use first when multiple repos may be indexed.',
+        parameters: Type.Object({}),
+        execute: async (_id, _params, _signal, _onUpdate, ctx) => {
+            const out = await mcpClient.callTool('list_repos', {}, ctx.cwd);
+            return text(out || 'No indexed repositories found.');
+        },
+    });
+    pi.registerTool({
+        name: 'gitnexus_query',
+        label: 'GitNexus Query',
+        description: 'Search the knowledge graph for execution flows related to a concept or error.',
+        parameters: Type.Object({
+            query: Type.String({ minLength: 1, maxLength: 200, pattern: '^[^-]' }),
+            task_context: Type.Optional(Type.String({ minLength: 1, maxLength: 500 })),
+            goal: Type.Optional(Type.String({ minLength: 1, maxLength: 500 })),
+            limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 100, default: 5 })),
+            max_symbols: Type.Optional(Type.Integer({ minimum: 1, maximum: 100, default: 10 })),
+            include_content: Type.Optional(Type.Boolean()),
+            repo: Type.Optional(Type.String({ minLength: 1, maxLength: 500 })),
+        }),
+        execute: async (_id, params, _signal, _onUpdate, ctx) => {
+            if (!shouldAllowQuery(ctx, params))
+                return text(NO_INDEX);
+            const out = await mcpClient.callTool('query', buildRepoArgs(ctx, params), ctx.cwd);
+            return text(out || 'No results.');
+        },
+    });
+    pi.registerTool({
+        name: 'gitnexus_context',
+        label: 'GitNexus Context',
+        description: '360-degree view of a code symbol: callers, callees, processes it participates in.',
+        parameters: Type.Object({
+            name: Type.Optional(Type.String({ minLength: 1, maxLength: 200, pattern: '^[^-]' })),
+            uid: Type.Optional(Type.String({ minLength: 1, maxLength: 200 })),
+            file: Type.Optional(Type.String({ minLength: 1, maxLength: 500 })),
+            file_path: Type.Optional(Type.String({ minLength: 1, maxLength: 500 })),
+            include_content: Type.Optional(Type.Boolean()),
+            repo: Type.Optional(Type.String({ minLength: 1, maxLength: 500 })),
+        }),
+        execute: async (_id, params, _signal, _onUpdate, ctx) => {
+            if (!shouldAllowQuery(ctx, params))
+                return text(NO_INDEX);
+            const typedParams = params;
+            if (!typedParams.name && !typedParams.uid)
+                return text('Provide either name or uid.');
+            const args = normalizeContextArgs(ctx, typedParams);
+            if (!args)
+                throw new Error('Invalid file path.');
+            const out = await mcpClient.callTool('context', args, ctx.cwd);
+            return text(out || 'No results.');
+        },
+    });
+    pi.registerTool({
+        name: 'gitnexus_impact',
+        label: 'GitNexus Impact',
+        description: 'Blast radius analysis: what breaks at each depth if you change a symbol.',
+        parameters: Type.Object({
+            target: Type.String({ minLength: 1, maxLength: 200, pattern: '^[^-]' }),
+            direction: StringEnum(['upstream', 'downstream']),
+            depth: Type.Optional(Type.Integer({ minimum: 1, maximum: 10, default: 3 })),
+            maxDepth: Type.Optional(Type.Integer({ minimum: 1, maximum: 10 })),
+            include_tests: Type.Optional(Type.Boolean()),
+            includeTests: Type.Optional(Type.Boolean()),
+            relationTypes: Type.Optional(Type.Array(Type.String({ minLength: 1, maxLength: 50 }), { maxItems: 20 })),
+            minConfidence: Type.Optional(Type.Number({ minimum: 0, maximum: 1 })),
+            repo: Type.Optional(Type.String({ minLength: 1, maxLength: 500 })),
+        }),
+        execute: async (_id, params, _signal, _onUpdate, ctx) => {
+            if (!shouldAllowQuery(ctx, params))
+                return text(NO_INDEX);
+            const out = await mcpClient.callTool('impact', normalizeImpactArgs(ctx, params), ctx.cwd);
+            return text(out || 'No results.');
+        },
+    });
+    pi.registerTool({
+        name: 'gitnexus_detect_changes',
+        label: 'GitNexus Detect Changes',
+        description: 'Analyze git changes and map them to affected execution flows.',
+        parameters: Type.Object({
+            scope: Type.Optional(StringEnum(['unstaged', 'staged', 'all', 'compare'])),
+            base_ref: Type.Optional(Type.String({ minLength: 1, maxLength: 200 })),
+            repo: Type.Optional(Type.String({ minLength: 1, maxLength: 500 })),
+        }),
+        execute: async (_id, params, _signal, _onUpdate, ctx) => {
+            if (!shouldAllowQuery(ctx, params))
+                return text(NO_INDEX);
+            const out = await mcpClient.callTool('detect_changes', buildRepoArgs(ctx, params), ctx.cwd);
+            return text(out || 'No affected flows detected.');
+        },
+    });
+    pi.registerTool({
+        name: 'gitnexus_rename',
+        label: 'GitNexus Rename',
+        description: 'Multi-file coordinated rename using the knowledge graph plus text search. Use dry_run first.',
+        parameters: Type.Object({
+            symbol_name: Type.Optional(Type.String({ minLength: 1, maxLength: 200, pattern: '^[^-]' })),
+            symbol_uid: Type.Optional(Type.String({ minLength: 1, maxLength: 200 })),
+            new_name: Type.String({ minLength: 1, maxLength: 200, pattern: '^[^-]' }),
+            file_path: Type.Optional(Type.String({ minLength: 1, maxLength: 500 })),
+            dry_run: Type.Optional(Type.Boolean()),
+            repo: Type.Optional(Type.String({ minLength: 1, maxLength: 500 })),
+        }),
+        execute: async (_id, params, _signal, _onUpdate, ctx) => {
+            if (!shouldAllowQuery(ctx, params))
+                return text(NO_INDEX);
+            const typedParams = params;
+            if (!typedParams.symbol_name && !typedParams.symbol_uid) {
+                return text('Provide either symbol_name or symbol_uid.');
+            }
+            let filePath;
+            if (typedParams.file_path) {
+                const safe = resolveFilePath(ctx, typedParams.file_path, typedParams.repo);
+                if (!safe)
+                    throw new Error('Invalid file path.');
+                filePath = safe;
+            }
+            const out = await mcpClient.callTool('rename', buildRepoArgs(ctx, {
+                ...(typedParams.symbol_name ? { symbol_name: typedParams.symbol_name } : {}),
+                ...(typedParams.symbol_uid ? { symbol_uid: typedParams.symbol_uid } : {}),
+                new_name: typedParams.new_name,
+                ...(filePath ? { file_path: filePath } : {}),
+                ...(typedParams.dry_run !== undefined ? { dry_run: typedParams.dry_run } : {}),
+                ...(typedParams.repo ? { repo: typedParams.repo } : {}),
+            }), ctx.cwd);
+            return text(out || 'No rename preview generated.');
+        },
+    });
+    pi.registerTool({
+        name: 'gitnexus_cypher',
+        label: 'GitNexus Cypher',
+        description: 'Execute a raw Cypher query against the code knowledge graph.',
+        parameters: Type.Object({
+            query: Type.String({ minLength: 1, maxLength: 10_000, pattern: '^[^-]' }),
+            repo: Type.Optional(Type.String({ minLength: 1, maxLength: 500 })),
+        }),
+        execute: async (_id, params, _signal, _onUpdate, ctx) => {
+            if (!shouldAllowQuery(ctx, params))
+                return text(NO_INDEX);
+            const out = await mcpClient.callTool('cypher', buildRepoArgs(ctx, params), ctx.cwd);
+            return text(out || 'No results.');
+        },
+    });
+}

package/dist/ui/main-menu.d.ts

@@ -0,0 +1,33 @@
+/**
+ * main-menu.ts — Interactive main menu for /gitnexus.
+ *
+ * Shows status in the title, with Analyze, Settings, and Help actions.
+ */
+import type { GitNexusConfig } from '../gitnexus.js';
+export type MenuUI = {
+    select(title: string, options: string[]): Promise<string | undefined>;
+    notify(message: string, type: 'info' | 'warning' | 'error'): void;
+    custom<T>(factory: (tui: any, theme: any, keybindings: any, done: (result: T) => void) => any, options?: {
+        overlay?: boolean;
+        overlayOptions?: any;
+    }): Promise<T>;
+};
+export interface MenuContext {
+    ui: MenuUI;
+    cwd: string;
+    cfg: GitNexusConfig;
+    state: {
+        augmentEnabled: boolean;
+    };
+    binaryAvailable: boolean;
+    gitnexusCmd: string[];
+    spawnEnv: NodeJS.ProcessEnv;
+    getHookFires: () => number;
+    getAugmentHits: () => number;
+    findGitNexusIndex: (cwd: string) => boolean;
+    clearIndexCache: () => void;
+    setGitnexusCmd: (cmd: string[]) => void;
+    setAugmentTimeout: (seconds: number) => void;
+    syncState: () => void;
+}
+export declare function openMainMenu(mctx: MenuContext): Promise<void>;

package/dist/ui/main-menu.js

@@ -0,0 +1,102 @@
+/**
+ * main-menu.ts — Interactive main menu for /gitnexus.
+ *
+ * Shows status in the title, with Analyze, Settings, and Help actions.
+ */
+import spawn from 'cross-spawn';
+import { openSettingsMenu } from './settings-menu.js';
+// ── Status ──────────────────────────────────────────────────────────────────
+async function getStatusLine(mctx) {
+    if (!mctx.binaryAvailable)
+        return 'gitnexus not installed';
+    if (!mctx.findGitNexusIndex(mctx.cwd))
+        return 'No index — run /gitnexus analyze';
+    const out = await new Promise((resolve_) => {
+        let stdout = '';
+        const [bin, ...baseArgs] = mctx.gitnexusCmd;
+        const proc = spawn(bin, [...baseArgs, 'status'], {
+            cwd: mctx.cwd,
+            stdio: ['ignore', 'pipe', 'ignore'],
+            env: mctx.spawnEnv,
+        });
+        proc.stdout.on('data', (chunk) => { stdout += chunk.toString(); });
+        proc.on('close', () => resolve_(stdout.trim()));
+        proc.on('error', () => resolve_(''));
+    });
+    const augmentLine = mctx.state.augmentEnabled
+        ? `Auto-augment: on (${mctx.getHookFires()} intercepted, ${mctx.getAugmentHits()} enriched)`
+        : 'Auto-augment: off';
+    return (out ? out + '\n' : '') + augmentLine;
+}
+// ── Analyze ─────────────────────────────────────────────────────────────────
+async function runAnalyze(mctx) {
+    if (!mctx.binaryAvailable) {
+        mctx.ui.notify('gitnexus is not installed. Install: npm i -g gitnexus', 'warning');
+        return;
+    }
+    mctx.state.augmentEnabled = false;
+    mctx.syncState();
+    mctx.ui.notify('GitNexus: analyzing codebase, this may take a while…', 'info');
+    const exitCode = await new Promise((resolve_) => {
+        const [bin, ...baseArgs] = mctx.gitnexusCmd;
+        const proc = spawn(bin, [...baseArgs, 'analyze'], {
+            cwd: mctx.cwd,
+            stdio: 'ignore',
+            env: mctx.spawnEnv,
+        });
+        proc.on('close', resolve_);
+        proc.on('error', () => resolve_(null));
+    });
+    if (exitCode === 0) {
+        mctx.clearIndexCache();
+        mctx.state.augmentEnabled = true;
+        mctx.syncState();
+        mctx.ui.notify('GitNexus: analysis complete. Knowledge graph ready.', 'info');
+    }
+    else {
+        mctx.state.augmentEnabled = true;
+        mctx.syncState();
+        mctx.ui.notify('GitNexus: analysis failed. Check the terminal for details.', 'error');
+    }
+}
+// ── Help ────────────────────────────────────────────────────────────────────
+function showHelp(mctx) {
+    mctx.ui.notify('Subcommands:\n' +
+        '  /gitnexus status      — show index & augmentation stats\n' +
+        '  /gitnexus analyze     — build/rebuild the knowledge graph\n' +
+        '  /gitnexus on|off      — toggle auto-augment\n' +
+        '  /gitnexus <pattern>   — manual graph lookup\n' +
+        '  /gitnexus query <q>   — search execution flows\n' +
+        '  /gitnexus context <n> — callers/callees of a symbol\n' +
+        '  /gitnexus impact <n>  — blast radius of a change', 'info');
+}
+// ── Main menu ───────────────────────────────────────────────────────────────
+export async function openMainMenu(mctx) {
+    const mainMenu = async () => {
+        const statusLine = await getStatusLine(mctx);
+        const title = `GitNexus\n${statusLine}`;
+        const choices = [
+            'Analyze',
+            'Settings',
+            'Help',
+        ];
+        const choice = await mctx.ui.select(title, choices);
+        if (!choice)
+            return;
+        if (choice === 'Analyze') {
+            await runAnalyze(mctx);
+            return mainMenu();
+        }
+        if (choice === 'Settings') {
+            await openSettingsMenu(mctx.ui, mctx.cfg, mctx.state, async () => {
+                mctx.syncState();
+            });
+            return mainMenu();
+        }
+        if (choice === 'Help') {
+            showHelp(mctx);
+            return mainMenu();
+        }
+    };
+    await mainMenu();
+}

package/dist/ui/settings-menu.d.ts

@@ -0,0 +1,16 @@
+/**
+ * settings-menu.ts — Interactive settings panel for /gitnexus settings.
+ *
+ * Uses ui.custom() + SettingsList for native TUI rendering with keyboard
+ * navigation, live toggle, and per-row descriptions.
+ */
+import { type GitNexusConfig } from "../gitnexus.js";
+export type SettingsUI = {
+    custom<T>(factory: (tui: any, theme: any, keybindings: any, done: (result: T) => void) => any, options?: {
+        overlay?: boolean;
+        overlayOptions?: any;
+    }): Promise<T>;
+};
+export declare function openSettingsMenu(ui: SettingsUI, cfg: GitNexusConfig, state: {
+    augmentEnabled: boolean;
+}, onBack: () => Promise<void>): Promise<void>;

package/dist/ui/settings-menu.js

@@ -0,0 +1,95 @@
+/**
+ * settings-menu.ts — Interactive settings panel for /gitnexus settings.
+ *
+ * Uses ui.custom() + SettingsList for native TUI rendering with keyboard
+ * navigation, live toggle, and per-row descriptions.
+ */
+import { getSettingsListTheme } from "@mariozechner/pi-coding-agent";
+import { Container, SettingsList, Spacer, Text } from "@mariozechner/pi-tui";
+import { saveConfig } from "../gitnexus.js";
+// ── Settings panel ──────────────────────────────────────────────────────────
+export async function openSettingsMenu(ui, cfg, state, onBack) {
+    await ui.custom((_tui, theme, _kb, done) => {
+        const items = [
+            {
+                id: "autoAugment",
+                label: "Auto-augment",
+                description: "When ON: search results (grep, find, read, bash) are automatically " +
+                    "enriched with knowledge graph context. When OFF: graph context is " +
+                    "only available via explicit /gitnexus commands and tools.",
+                currentValue: state.augmentEnabled ? "on" : "off",
+                values: ["on", "off"],
+            },
+            {
+                id: "augmentTimeout",
+                label: "Augment timeout",
+                description: "Maximum time (in seconds) to wait for a graph augmentation response. " +
+                    "Increase for large repos with slow I/O, decrease for snappier responses. " +
+                    "Default: 8s.",
+                currentValue: String(cfg.augmentTimeout ?? 8),
+                values: ["4", "6", "8", "10", "15", "20"],
+            },
+            {
+                id: "maxAugmentsPerResult",
+                label: "Max augments per result",
+                description: "Maximum number of patterns to augment in parallel per search result. " +
+                    "Higher values provide more context but use more tokens. Default: 3.",
+                currentValue: String(cfg.maxAugmentsPerResult ?? 3),
+                values: ["1", "2", "3", "5"],
+            },
+            {
+                id: "maxSecondaryPatterns",
+                label: "Max secondary patterns",
+                description: "Maximum number of secondary file-based patterns extracted from grep/bash " +
+                    "output. These provide additional context from files mentioned in results. " +
+                    "Default: 2.",
+                currentValue: String(cfg.maxSecondaryPatterns ?? 2),
+                values: ["0", "1", "2", "3", "5"],
+            },
+            {
+                id: "cmd",
+                label: "GitNexus command",
+                description: "The shell command used to invoke gitnexus. " +
+                    "Change if gitnexus is installed in a non-standard location or you want " +
+                    "to use npx. Default: gitnexus.",
+                currentValue: cfg.cmd ?? "gitnexus",
+                values: ["gitnexus", "npx gitnexus@latest", "npx -y gitnexus@latest"],
+            },
+        ];
+        const list = new SettingsList(items, Math.min(items.length + 2, 15), getSettingsListTheme(), 
+        /* onChange */ (id, newValue) => {
+            if (id === "autoAugment") {
+                state.augmentEnabled = newValue === "on";
+                cfg.autoAugment = newValue === "on";
+                saveConfig(cfg);
+            }
+            if (id === "augmentTimeout") {
+                cfg.augmentTimeout = parseInt(newValue, 10);
+                saveConfig(cfg);
+            }
+            if (id === "maxAugmentsPerResult") {
+                cfg.maxAugmentsPerResult = parseInt(newValue, 10);
+                saveConfig(cfg);
+            }
+            if (id === "maxSecondaryPatterns") {
+                cfg.maxSecondaryPatterns = parseInt(newValue, 10);
+                saveConfig(cfg);
+            }
+            if (id === "cmd") {
+                cfg.cmd = newValue;
+                saveConfig(cfg);
+            }
+        }, 
+        /* onCancel */ () => done(undefined));
+        const container = new Container();
+        container.addChild(new Text(theme.bold(theme.fg("accent", "⚙  GitNexus Settings")), 0, 0));
+        container.addChild(new Spacer(1));
+        container.addChild(list);
+        return {
+            render: (w) => container.render(w),
+            invalidate: () => container.invalidate(),
+            handleInput: (data) => list.handleInput?.(data),
+        };
+    });
+    return onBack();
+}