gitnexus 1.5.2 → 1.6.0

package/dist/cli/wiki.js

@@ -197,47 +197,23 @@ export const wikiCommand = async (inputPath, options) => {
                 llmConfig = { ...llmConfig, provider: 'cursor', model, apiKey: '', baseUrl: '' };
             }
             else if (choice === '3') {
-                // Azure OpenAI guided setup
-                console.log('\n  Azure OpenAI setup.');
-                console.log('  You need: your resource name, deployment name, and API key from the Azure portal.\n');
-                const resourceName = (await prompt('  Azure resource name (e.g. my-openai-resource): ')).trim();
-                if (!resourceName) {
-                    console.log('\n  No resource name provided. Aborting.\n');
+                // Azure OpenAI guided setup — minimal prompts
+                console.log('\n  Azure OpenAI setup.\n');
+                const endpoint = (await prompt('  Endpoint URL (e.g. https://my-resource.openai.azure.com): '))
+                    .trim()
+                    .replace(/\/+$/, '');
+                if (!endpoint) {
+                    console.log('\n  No endpoint provided. Aborting.\n');
                     process.exitCode = 1;
                     return;
                 }
-                const deploymentName = (await prompt('  Deployment name (the name you gave your model deployment): ')).trim();
+                const deploymentName = (await prompt('  Deployment name: ')).trim();
                 if (!deploymentName) {
                     console.log('\n  No deployment name provided. Aborting.\n');
                     process.exitCode = 1;
                     return;
                 }
-                // Offer v1 or legacy URL
-                console.log('\n  API format:');
-                console.log('  [1] v1 API — recommended (no api-version needed)');
-                console.log('  [2] Legacy — uses api-version query param\n');
-                const apiFormat = await prompt('  Select format (1/2, default: 1): ');
-                let azureApiVersion;
-                let azureBaseUrl;
-                if (apiFormat === '2') {
-                    const versionInput = await prompt('  api-version (default: 2024-10-21): ');
-                    azureApiVersion = versionInput || '2024-10-21';
-                    azureBaseUrl = `https://${resourceName}.openai.azure.com/openai/deployments/${deploymentName}`;
-                }
-                else {
-                    azureBaseUrl = `https://${resourceName}.openai.azure.com/openai/v1`;
-                    azureApiVersion = undefined;
-                }
-                defaultModel = deploymentName;
-                // Ask if this is a reasoning model deployment
-                const reasoningAnswer = await prompt('  Is this a reasoning model (o1, o3, o4-mini)? (y/N): ');
-                const isReasoningModelDeployment = ['y', 'yes'].includes(reasoningAnswer.toLowerCase());
-                if (isReasoningModelDeployment) {
-                    console.log('  Note: temperature and max_tokens will be omitted for this deployment (Azure reasoning model requirement).\n');
-                }
-                const modelInput = await prompt(`  Model / deployment name (default: ${defaultModel}): `);
-                const model = modelInput || defaultModel;
-                // API key
+                // API key — use env var if available
                 const envKey = process.env.GITNEXUS_API_KEY || process.env.OPENAI_API_KEY || '';
                 let azureKey;
                 if (envKey) {
@@ -258,26 +234,21 @@ export const wikiCommand = async (inputPath, options) => {
                     process.exitCode = 1;
                     return;
                 }
-                // Save Azure config including optional apiVersion and isReasoningModel
-                const azureConfig = {
+                // Always use v1 API format — no need for api-version
+                const azureBaseUrl = `${endpoint}/openai/v1`;
+                await saveCLIConfig({
                     apiKey: azureKey,
                     baseUrl: azureBaseUrl,
-                    model,
+                    model: deploymentName,
                     provider: 'azure',
-                    isReasoningModel: isReasoningModelDeployment,
-                };
-                if (azureApiVersion)
-                    azureConfig.apiVersion = azureApiVersion;
-                await saveCLIConfig(azureConfig);
+                });
                 console.log('  Config saved to ~/.gitnexus/config.json\n');
                 llmConfig = {
                     ...llmConfig,
                     apiKey: azureKey,
                     baseUrl: azureBaseUrl,
-                    model,
+                    model: deploymentName,
                     provider: 'azure',
-                    apiVersion: azureApiVersion,
-                    isReasoningModel: isReasoningModelDeployment,
                 };
             }
             else {

package/dist/config/ignore-service.js

@@ -351,11 +351,16 @@ export const createIgnoreFilter = async (repoPath, options) => {
             if (DEFAULT_IGNORE_LIST.has(p.name))
                 return true;
             // Check against .gitignore / .gitnexusignore patterns.
-            // Test both bare path and path with trailing slash to handle
-            // bare-name patterns (e.g. `local`) and dir-only patterns (e.g. `local/`).
+            // Since childrenIgnored is only called for directories, always test with
+            // a trailing slash. This ensures directory-only negation patterns (e.g.
+            // `!iOS/`) are applied correctly — without the slash, `ig.ignores('iOS')`
+            // treats the path as a file and misses the negation.
+            // Bare-name patterns (e.g. `local`) still match `local/` per gitignore spec:
+            // the `ignore` package normalizes `dir` and `dir/` to match directories.
+            // See: https://github.com/kaelzhang/node-ignore#2-filenames-and-dirnames
             if (ig) {
                 const rel = p.relative();
-                if (rel && (ig.ignores(rel) || ig.ignores(rel + '/')))
+                if (rel && ig.ignores(rel + '/'))
                     return true;
             }
             return false;

package/dist/core/augmentation/engine.js

@@ -82,7 +82,7 @@ export async function augment(pattern, cwd) {
         if (!repo)
             return '';
         // Lazy-load lbug adapter (skip unnecessary init)
-        const { initLbug, executeQuery, isLbugReady } = await import('../../mcp/core/lbug-adapter.js');
+        const { initLbug, executeQuery, isLbugReady } = await import('../lbug/pool-adapter.js');
         const { searchFTSFromLbug } = await import('../search/bm25-index.js');
         const repoId = repo.name.toLowerCase();
         // Init LadybugDB if not already

package/dist/core/git-staleness.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Git working tree vs index commit staleness (used by MCP resources, group status, etc.).
+ * Lives in core/ so application code does not depend on the MCP package layer.
+ */
+export interface StalenessInfo {
+    isStale: boolean;
+    commitsBehind: number;
+    hint?: string;
+}
+/**
+ * Check how many commits the index is behind HEAD (synchronous; uses git CLI).
+ */
+export declare function checkStaleness(repoPath: string, lastCommit: string): StalenessInfo;

package/dist/core/git-staleness.js

@@ -0,0 +1,29 @@
+/**
+ * Git working tree vs index commit staleness (used by MCP resources, group status, etc.).
+ * Lives in core/ so application code does not depend on the MCP package layer.
+ */
+import { execFileSync } from 'node:child_process';
+/**
+ * Check how many commits the index is behind HEAD (synchronous; uses git CLI).
+ */
+export function checkStaleness(repoPath, lastCommit) {
+    try {
+        const result = execFileSync('git', ['rev-list', '--count', `${lastCommit}..HEAD`], {
+            cwd: repoPath,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        const commitsBehind = parseInt(result, 10) || 0;
+        if (commitsBehind > 0) {
+            return {
+                isStale: true,
+                commitsBehind,
+                hint: `⚠️ Index is ${commitsBehind} commit${commitsBehind > 1 ? 's' : ''} behind HEAD. Run analyze tool to update.`,
+            };
+        }
+        return { isStale: false, commitsBehind: 0 };
+    }
+    catch {
+        return { isStale: false, commitsBehind: 0 };
+    }
+}

package/dist/core/group/bridge-db.d.ts

@@ -0,0 +1,82 @@
+import type { LbugValue } from '@ladybugdb/core';
+import type { BridgeHandle, BridgeMeta, StoredContract, CrossLink, RepoSnapshot } from './types.js';
+export declare function contractNodeId(repo: string, contractId: string, role: string, filePath: string): string;
+/**
+ * In-memory index of contract node IDs keyed three ways, mirroring the
+ * three-tier fallback lookup in {@link findContractNode}. Built once per
+ * `writeBridge` call after all contracts are successfully inserted, then
+ * consulted for every cross-link — which eliminates the former N+1 query
+ * pattern (up to `6 × cross-links` DB round-trips) and turns cross-link
+ * resolution into constant-time per link.
+ *
+ * Keys are deliberately flat strings (not tuples) so `Map<string, ...>`
+ * works; the separator `\0` can't occur in any legal repo path / file
+ * path / symbol identifier, which makes the encoding injection-safe.
+ */
+export interface ContractLookupIndex {
+    /** tier 1: `repo + role + symbolUid` → contract node id */
+    byUid: Map<string, string>;
+    /** tier 2: `repo + role + filePath + symbolName` → contract node id */
+    byRef: Map<string, string>;
+    /** tier 3: `repo + role + filePath` → list of contract node ids in that file */
+    byFile: Map<string, string[]>;
+}
+export declare function createContractLookupIndex(): ContractLookupIndex;
+/**
+ * Add a successfully-inserted contract to the lookup index. Must be called
+ * AFTER the DB insert succeeds (not before) so failed inserts don't poison
+ * the index and cause cross-links to point at non-existent rows.
+ */
+export declare function indexContract(index: ContractLookupIndex, contract: StoredContract, nodeId: string): void;
+/**
+ * Resolve a cross-link endpoint (consumer or provider reference) to an
+ * already-inserted contract node id. Returns `null` if no match — the
+ * caller is expected to count that as a dropped link in `WriteBridgeReport`.
+ *
+ * The resolution order matches the pre-cache DB-query behavior:
+ *   1. exact `symbolUid` match in the same `(repo, role)` scope
+ *   2. exact `(filePath, symbolName)` match
+ *   3. if exactly one contract lives in the file → that one (fallback for
+ *      legacy graph-assisted extractors that couldn't resolve a symbol name)
+ *
+ * This is a pure function — no I/O, no DB — so it's trivial to unit-test
+ * in isolation (which was the reviewer's main clean-code concern on the
+ * original 35-line inner closure in `writeBridge`).
+ */
+export declare function findContractNode(index: ContractLookupIndex, repo: string, role: 'consumer' | 'provider', symbolUid: string, filePath: string, symbolName: string): string | null;
+export declare function openBridgeDb(dbPath: string): Promise<BridgeHandle>;
+export declare function ensureBridgeSchema(handle: BridgeHandle): Promise<void>;
+export declare function queryBridge<T>(handle: BridgeHandle, cypher: string, params?: Record<string, LbugValue>): Promise<T[]>;
+export declare function closeBridgeDb(handle: BridgeHandle): Promise<void>;
+export declare function retryRename(src: string, dst: string, attempts?: number): Promise<void>;
+export declare function writeBridgeMeta(groupDir: string, meta: BridgeMeta): Promise<void>;
+export declare function readBridgeMeta(groupDir: string): Promise<BridgeMeta>;
+export interface WriteBridgeInput {
+    contracts: StoredContract[];
+    crossLinks: CrossLink[];
+    repoSnapshots: Record<string, RepoSnapshot>;
+    missingRepos: string[];
+}
+/**
+ * Non-fatal issues encountered during writeBridge. Callers can log these to
+ * surface partial-success state without aborting the whole sync.
+ * `sampleErrors` is capped at MAX_SAMPLE_ERRORS per category to bound memory.
+ */
+export interface WriteBridgeReport {
+    contractsInserted: number;
+    contractsFailed: number;
+    snapshotsInserted: number;
+    snapshotsFailed: number;
+    linksInserted: number;
+    linksFailed: number;
+    /** Cross-links skipped because their from/to contract nodes weren't found. */
+    linksDroppedMissingNode: number;
+    sampleErrors: Array<{
+        kind: 'contract' | 'snapshot' | 'link';
+        id: string;
+        message: string;
+    }>;
+}
+export declare function writeBridge(groupDir: string, input: WriteBridgeInput): Promise<WriteBridgeReport>;
+export declare function openBridgeDbReadOnly(groupDir: string): Promise<BridgeHandle | null>;
+export declare function bridgeExists(groupDir: string): Promise<boolean>;