@phuetz/code-buddy 1.3.0 → 1.3.2

package/dist/plugins/{gitnexus/GitNexusMCPClient.d.ts → code-explorer/CodeExplorerMCPClient.d.ts}

@@ -1,13 +1,13 @@
 /**
- * GitNexus MCP Client
+ * CodeExplorer MCP Client
  *
- * Talks to a GitNexus MCP server to query the code graph.
+ * Talks to a CodeExplorer MCP server to query the code graph.
  * Currently operates in **stub mode** — all methods return empty/default
  * results so the rest of the codebase can integrate without requiring
- * a real GitNexus installation. The real MCP transport will be wired
- * in a follow-up once gitnexus is available.
+ * a real CodeExplorer installation. The real MCP transport will be wired
+ * in a follow-up once code-explorer is available.
  *
- * Tools exposed by GitNexus MCP:
+ * Tools exposed by CodeExplorer MCP:
  *   - query   — natural-language search over the code graph
  *   - context — symbol-level call/import graph + process membership
  *   - impact  — blast-radius analysis (upstream/downstream)
@@ -75,17 +75,17 @@ export interface GNProcess {
         stepIndex: number;
     }>;
 }
-export declare class GitNexusMCPClient {
+export declare class CodeExplorerMCPClient {
     private repoName;
     private connected;
     constructor(repoName: string);
     /**
-     * Connect to the GitNexus MCP server.
+     * Connect to the CodeExplorer MCP server.
      *
      * In the real implementation this will use `@modelcontextprotocol/sdk`
      * `StdioClientTransport` with:
      *   command: 'npx'
-     *   args: ['-y', 'gitnexus@latest', 'mcp']
+     *   args: ['-y', 'code-explorer@latest', 'mcp']
      *
      * For now this is a stub that marks the client as connected.
      */
@@ -114,7 +114,7 @@ export declare class GitNexusMCPClient {
      */
     impact(target: string, direction?: 'upstream' | 'downstream'): Promise<GNImpactResult>;
     /**
-     * Execute a raw Cypher query against the GitNexus graph database.
+     * Execute a raw Cypher query against the CodeExplorer graph database.
      */
     cypher(query: string): Promise<unknown[]>;
     /** Get all detected module clusters with cohesion scores. */

package/dist/plugins/{gitnexus/GitNexusMCPClient.js → code-explorer/CodeExplorerMCPClient.js}

@@ -1,13 +1,13 @@
 /**
- * GitNexus MCP Client
+ * CodeExplorer MCP Client
  *
- * Talks to a GitNexus MCP server to query the code graph.
+ * Talks to a CodeExplorer MCP server to query the code graph.
  * Currently operates in **stub mode** — all methods return empty/default
  * results so the rest of the codebase can integrate without requiring
- * a real GitNexus installation. The real MCP transport will be wired
- * in a follow-up once gitnexus is available.
+ * a real CodeExplorer installation. The real MCP transport will be wired
+ * in a follow-up once code-explorer is available.
  *
- * Tools exposed by GitNexus MCP:
+ * Tools exposed by CodeExplorer MCP:
  *   - query   — natural-language search over the code graph
  *   - context — symbol-level call/import graph + process membership
  *   - impact  — blast-radius analysis (upstream/downstream)
@@ -21,32 +21,32 @@
  */
 import { logger } from '../../utils/logger.js';
 // ── Client ──────────────────────────────────────────────────────────
-export class GitNexusMCPClient {
+export class CodeExplorerMCPClient {
     repoName;
     connected = false;
     constructor(repoName) {
         this.repoName = repoName;
     }
     /**
-     * Connect to the GitNexus MCP server.
+     * Connect to the CodeExplorer MCP server.
      *
      * In the real implementation this will use `@modelcontextprotocol/sdk`
      * `StdioClientTransport` with:
      *   command: 'npx'
-     *   args: ['-y', 'gitnexus@latest', 'mcp']
+     *   args: ['-y', 'code-explorer@latest', 'mcp']
      *
      * For now this is a stub that marks the client as connected.
      */
     async connect() {
         this.connected = true;
-        logger.debug('GitNexus MCP client connected (stub mode)', {
+        logger.debug('CodeExplorer MCP client connected (stub mode)', {
             repo: this.repoName,
         });
     }
     /** Disconnect from the MCP server. */
     async disconnect() {
         this.connected = false;
-        logger.debug('GitNexus MCP client disconnected', {
+        logger.debug('CodeExplorer MCP client disconnected', {
             repo: this.repoName,
         });
     }
@@ -65,7 +65,7 @@ export class GitNexusMCPClient {
      */
     async query(q) {
         this.assertConnected();
-        logger.debug('GitNexus query', { query: q, repo: this.repoName });
+        logger.debug('CodeExplorer query', { query: q, repo: this.repoName });
         // Stub: real impl calls callTool('query', { query: q, repo: this.repoName })
         return { processes: [], definitions: [] };
     }
@@ -75,7 +75,7 @@ export class GitNexusMCPClient {
      */
     async context(symbolName) {
         this.assertConnected();
-        logger.debug('GitNexus context', { symbol: symbolName, repo: this.repoName });
+        logger.debug('CodeExplorer context', { symbol: symbolName, repo: this.repoName });
         return {
             symbol: {
                 uid: symbolName,
@@ -96,7 +96,7 @@ export class GitNexusMCPClient {
      */
     async impact(target, direction = 'upstream') {
         this.assertConnected();
-        logger.debug('GitNexus impact', { target, direction, repo: this.repoName });
+        logger.debug('CodeExplorer impact', { target, direction, repo: this.repoName });
         return {
             target,
             affected: [],
@@ -105,11 +105,11 @@ export class GitNexusMCPClient {
         };
     }
     /**
-     * Execute a raw Cypher query against the GitNexus graph database.
+     * Execute a raw Cypher query against the CodeExplorer graph database.
      */
     async cypher(query) {
         this.assertConnected();
-        logger.debug('GitNexus cypher', { query, repo: this.repoName });
+        logger.debug('CodeExplorer cypher', { query, repo: this.repoName });
         return [];
     }
     // ── Resources ───────────────────────────────────────────────────
@@ -136,8 +136,8 @@ export class GitNexusMCPClient {
     // ── Internal ────────────────────────────────────────────────────
     assertConnected() {
         if (!this.connected) {
-            throw new Error('GitNexusMCPClient is not connected. Call connect() first.');
+            throw new Error('CodeExplorerMCPClient is not connected. Call connect() first.');
         }
     }
 }
-//# sourceMappingURL=GitNexusMCPClient.js.map
+//# sourceMappingURL=CodeExplorerMCPClient.js.map

package/dist/plugins/{gitnexus/GitNexusManager.d.ts → code-explorer/CodeExplorerManager.d.ts}

@@ -1,18 +1,18 @@
 /**
- * GitNexus Manager
+ * CodeExplorer Manager
  *
- * Handles GitNexus indexing, stats retrieval, and MCP server lifecycle.
- * GitNexus provides code graph analysis (symbols, relations, processes, clusters)
+ * Handles CodeExplorer indexing, stats retrieval, and MCP server lifecycle.
+ * CodeExplorer provides code graph analysis (symbols, relations, processes, clusters)
  * and exposes them via an MCP server for agent consumption.
  *
  * Usage:
- *   const mgr = getGitNexusManager('/path/to/repo');
+ *   const mgr = getCodeExplorerManager('/path/to/repo');
  *   if (mgr.isInstalled() && !mgr.isRepoIndexed()) {
  *     await mgr.analyze();
  *   }
  *   await mgr.startMCPServer();
  */
-export interface GitNexusStats {
+export interface CodeExplorerStats {
     symbols: number;
     relations: number;
     processes: number;
@@ -20,18 +20,18 @@ export interface GitNexusStats {
     indexed: boolean;
     stale: boolean;
 }
-export declare class GitNexusManager {
+export declare class CodeExplorerManager {
     private repoPath;
     private mcpProcess;
     constructor(repoPath?: string);
-    /** Check whether the `gitnexus` CLI is available via npx. */
+    /** Check whether the `code-explorer` CLI is available on PATH. */
     isInstalled(): boolean;
-    /** Check whether the repo has been indexed (`.gitnexus/` directory exists). */
+    /** Check whether the repo has been indexed (`.codeexplorer/` directory exists). */
     isRepoIndexed(): boolean;
     /**
-     * Run `npx gitnexus analyze` to index the repository.
+     * Run `code-explorer analyze` to index the repository.
      *
-     * @param options.force  - Re-index even if `.gitnexus/` already exists.
+     * @param options.force  - Re-index even if `.codeexplorer/` already exists.
      * @param options.withSkills - Also generate skill annotations.
      */
     analyze(options?: {
@@ -39,12 +39,12 @@ export declare class GitNexusManager {
         withSkills?: boolean;
     }): Promise<void>;
     /**
-     * Read stats from `.gitnexus/meta.json`.
+     * Read stats from `.codeexplorer/meta.json`.
      * Returns defaults if the index does not exist.
      */
-    getStats(): GitNexusStats;
+    getStats(): CodeExplorerStats;
     /**
-     * Start the GitNexus MCP server as a child process (stdio transport).
+     * Start the CodeExplorer MCP server as a child process (stdio transport).
      * Only one server is kept alive per manager instance.
      */
     startMCPServer(): Promise<void>;
@@ -58,9 +58,9 @@ export declare class GitNexusManager {
     dispose(): void;
 }
 /**
- * Get or create a singleton GitNexusManager for the given repo path.
+ * Get or create a singleton CodeExplorerManager for the given repo path.
  * Defaults to `process.cwd()` if no path is provided.
  */
-export declare function getGitNexusManager(repoPath?: string): GitNexusManager;
+export declare function getCodeExplorerManager(repoPath?: string): CodeExplorerManager;
 /** Clear the singleton cache (for testing). */
-export declare function clearGitNexusManagerCache(): void;
+export declare function clearCodeExplorerManagerCache(): void;

package/dist/plugins/{gitnexus/GitNexusManager.js → code-explorer/CodeExplorerManager.js}

@@ -1,12 +1,12 @@
 /**
- * GitNexus Manager
+ * CodeExplorer Manager
  *
- * Handles GitNexus indexing, stats retrieval, and MCP server lifecycle.
- * GitNexus provides code graph analysis (symbols, relations, processes, clusters)
+ * Handles CodeExplorer indexing, stats retrieval, and MCP server lifecycle.
+ * CodeExplorer provides code graph analysis (symbols, relations, processes, clusters)
  * and exposes them via an MCP server for agent consumption.
  *
  * Usage:
- *   const mgr = getGitNexusManager('/path/to/repo');
+ *   const mgr = getCodeExplorerManager('/path/to/repo');
  *   if (mgr.isInstalled() && !mgr.isRepoIndexed()) {
  *     await mgr.analyze();
  *   }
@@ -26,16 +26,16 @@ const DEFAULT_STATS = {
 };
 /** Singleton cache keyed by resolved repo path */
 const instances = new Map();
-export class GitNexusManager {
+export class CodeExplorerManager {
     repoPath;
     mcpProcess = null;
     constructor(repoPath = process.cwd()) {
         this.repoPath = path.resolve(repoPath);
     }
-    /** Check whether the `gitnexus` CLI is available via npx. */
+    /** Check whether the `code-explorer` CLI is available on PATH. */
     isInstalled() {
         try {
-            execSync('npx gitnexus --version', {
+            execSync('code-explorer --version', {
                 stdio: 'pipe',
                 timeout: 10_000,
                 cwd: this.repoPath,
@@ -46,25 +46,25 @@ export class GitNexusManager {
             return false;
         }
     }
-    /** Check whether the repo has been indexed (`.gitnexus/` directory exists). */
+    /** Check whether the repo has been indexed (`.codeexplorer/` directory exists). */
     isRepoIndexed() {
-        return fs.existsSync(path.join(this.repoPath, '.gitnexus'));
+        return fs.existsSync(path.join(this.repoPath, '.codeexplorer'));
     }
     /**
-     * Run `npx gitnexus analyze` to index the repository.
+     * Run `code-explorer analyze` to index the repository.
      *
-     * @param options.force  - Re-index even if `.gitnexus/` already exists.
+     * @param options.force  - Re-index even if `.codeexplorer/` already exists.
      * @param options.withSkills - Also generate skill annotations.
      */
     async analyze(options = {}) {
-        const args = ['gitnexus', 'analyze'];
+        const args = ['analyze'];
         if (options.force)
             args.push('--force');
         if (options.withSkills)
             args.push('--with-skills');
-        logger.info(`GitNexus: analyzing repo at ${this.repoPath}`, { args });
+        logger.info(`CodeExplorer: analyzing repo at ${this.repoPath}`, { args });
         return new Promise((resolve, reject) => {
-            const child = spawn('npx', args, {
+            const child = spawn('code-explorer', args, {
                 cwd: this.repoPath,
                 stdio: 'pipe',
                 shell: true,
@@ -73,22 +73,22 @@ export class GitNexusManager {
             child.stdout?.on('data', (chunk) => {
                 const line = chunk.toString().trim();
                 if (line)
-                    logger.debug(`GitNexus analyze: ${line}`);
+                    logger.debug(`CodeExplorer analyze: ${line}`);
             });
             child.stderr?.on('data', (chunk) => {
                 stderr += chunk.toString();
             });
             child.on('error', (err) => {
-                logger.error('GitNexus analyze failed to start', { error: err.message });
-                reject(new Error(`GitNexus analyze failed to start: ${err.message}`));
+                logger.error('CodeExplorer analyze failed to start', { error: err.message });
+                reject(new Error(`CodeExplorer analyze failed to start: ${err.message}`));
             });
             child.on('close', (code) => {
                 if (code === 0) {
-                    logger.info('GitNexus: analysis complete');
+                    logger.info('CodeExplorer: analysis complete');
                     resolve();
                 }
                 else {
-                    const msg = `GitNexus analyze exited with code ${code}: ${stderr.trim()}`;
+                    const msg = `CodeExplorer analyze exited with code ${code}: ${stderr.trim()}`;
                     logger.error(msg);
                     reject(new Error(msg));
                 }
@@ -96,11 +96,11 @@ export class GitNexusManager {
         });
     }
     /**
-     * Read stats from `.gitnexus/meta.json`.
+     * Read stats from `.codeexplorer/meta.json`.
      * Returns defaults if the index does not exist.
      */
     getStats() {
-        const metaPath = path.join(this.repoPath, '.gitnexus', 'meta.json');
+        const metaPath = path.join(this.repoPath, '.codeexplorer', 'meta.json');
         if (!fs.existsSync(metaPath)) {
             return { ...DEFAULT_STATS };
         }
@@ -117,43 +117,43 @@ export class GitNexusManager {
             };
         }
         catch (err) {
-            logger.warn('GitNexus: failed to read meta.json', {
+            logger.warn('CodeExplorer: failed to read meta.json', {
                 error: err instanceof Error ? err.message : String(err),
             });
             return { ...DEFAULT_STATS };
         }
     }
     /**
-     * Start the GitNexus MCP server as a child process (stdio transport).
+     * Start the CodeExplorer MCP server as a child process (stdio transport).
      * Only one server is kept alive per manager instance.
      */
     async startMCPServer() {
         if (this.mcpProcess) {
-            logger.debug('GitNexus MCP server already running');
+            logger.debug('CodeExplorer MCP server already running');
             return;
         }
-        logger.info('GitNexus: starting MCP server');
-        this.mcpProcess = spawn('npx', ['-y', 'gitnexus@latest', 'mcp'], {
+        logger.info('CodeExplorer: starting MCP server');
+        this.mcpProcess = spawn('code-explorer', ['mcp'], {
             cwd: this.repoPath,
             stdio: ['pipe', 'pipe', 'pipe'],
             shell: true,
         });
         this.mcpProcess.on('error', (err) => {
-            logger.error('GitNexus MCP server error', { error: err.message });
+            logger.error('CodeExplorer MCP server error', { error: err.message });
             this.mcpProcess = null;
         });
         this.mcpProcess.on('close', (code) => {
-            logger.debug(`GitNexus MCP server exited with code ${code}`);
+            logger.debug(`CodeExplorer MCP server exited with code ${code}`);
             this.mcpProcess = null;
         });
         // Give the server a moment to start
         await new Promise((resolve) => setTimeout(resolve, 200));
-        logger.info('GitNexus MCP server started');
+        logger.info('CodeExplorer MCP server started');
     }
     /** Stop the MCP server if running. */
     stopMCPServer() {
         if (this.mcpProcess) {
-            logger.debug('GitNexus: stopping MCP server');
+            logger.debug('CodeExplorer: stopping MCP server');
             this.mcpProcess.kill();
             this.mcpProcess = null;
         }
@@ -172,21 +172,21 @@ export class GitNexusManager {
     }
 }
 /**
- * Get or create a singleton GitNexusManager for the given repo path.
+ * Get or create a singleton CodeExplorerManager for the given repo path.
  * Defaults to `process.cwd()` if no path is provided.
  */
-export function getGitNexusManager(repoPath) {
+export function getCodeExplorerManager(repoPath) {
     const resolved = path.resolve(repoPath || process.cwd());
     let manager = instances.get(resolved);
     if (!manager) {
-        manager = new GitNexusManager(resolved);
+        manager = new CodeExplorerManager(resolved);
         instances.set(resolved, manager);
     }
     return manager;
 }
 /** Clear the singleton cache (for testing). */
-export function clearGitNexusManagerCache() {
+export function clearCodeExplorerManagerCache() {
     instances.forEach((mgr) => mgr.dispose());
     instances.clear();
 }
-//# sourceMappingURL=GitNexusManager.js.map
+//# sourceMappingURL=CodeExplorerManager.js.map

package/dist/plugins/code-explorer/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * CodeExplorer Plugin — Barrel Export
+ *
+ * Code graph analysis via CodeExplorer MCP server integration.
+ */
+export { CodeExplorerManager, getCodeExplorerManager, clearCodeExplorerManagerCache, } from './CodeExplorerManager.js';
+export { CodeExplorerMCPClient } from './CodeExplorerMCPClient.js';
+export type { GNQueryResult, GNContextResult, GNImpactResult, GNCluster, GNProcess, } from './CodeExplorerMCPClient.js';
+export type { CodeExplorerStats } from './CodeExplorerManager.js';

package/dist/plugins/code-explorer/index.js

@@ -0,0 +1,8 @@
+/**
+ * CodeExplorer Plugin — Barrel Export
+ *
+ * Code graph analysis via CodeExplorer MCP server integration.
+ */
+export { CodeExplorerManager, getCodeExplorerManager, clearCodeExplorerManagerCache, } from './CodeExplorerManager.js';
+export { CodeExplorerMCPClient } from './CodeExplorerMCPClient.js';
+//# sourceMappingURL=index.js.map

package/dist/providers/provider-catalog.js

@@ -126,7 +126,29 @@ export const RUNTIME_PROVIDER_CATALOG = [
         modelEnvKeys: ['MISTRAL_MODEL'],
         defaultBaseURL: 'https://api.mistral.ai/v1',
         defaultModel: 'mistral-large-latest',
-        models: ['mistral-large-latest', 'mistral-medium-latest', 'mistral-small-latest', 'codestral-latest'],
+        models: [
+            'mistral-large-latest',
+            'mistral-medium-latest',
+            'mistral-small-latest',
+            'codestral-latest',
+            'devstral-latest',
+            'magistral-medium-latest',
+            'ministral-8b-latest',
+        ],
+    },
+    {
+        id: 'deepseek',
+        label: 'DeepSeek',
+        authMode: 'api-key',
+        apiMode: 'openai-compatible',
+        runtimeSupport: 'direct',
+        priority: 72,
+        apiKeyEnvKeys: ['DEEPSEEK_API_KEY'],
+        baseUrlEnvKeys: ['DEEPSEEK_BASE_URL'],
+        modelEnvKeys: ['DEEPSEEK_MODEL'],
+        defaultBaseURL: 'https://api.deepseek.com/v1',
+        defaultModel: 'deepseek-chat',
+        models: ['deepseek-chat', 'deepseek-reasoner'],
     },
     {
         id: 'groq',

package/dist/services/prompt-builder.js

@@ -355,7 +355,7 @@ export class PromptBuilder {
                 }
                 catch { /* rules module optional */ }
             }
-            // Steer toward Code Explorer (gitnexus) when it is connected. Conditional:
+            // Steer toward Code Explorer (code-explorer) when it is connected. Conditional:
             // when Code Explorer is absent this injects nothing, so the built-in
             // code_graph/codebase_map behaviour is unchanged. Presence is session-
             // stable, so this stays in the cache-stable prefix.
@@ -364,17 +364,17 @@ export class PromptBuilder {
                 if (isCodeExplorerAvailable()) {
                     systemPrompt +=
                         `\n\n<code_explorer_priority>\n` +
-                            `Code Explorer (gitnexus) is connected. For ANY question about code relationships — ` +
+                            `Code Explorer (code-explorer) is connected. For ANY question about code relationships — ` +
                             `callers/callees, blast radius / impact ("what breaks if I change X"), dead code, cycles, ` +
-                            `coupling, complexity — PREFER its MCP tools (\`mcp__gitnexus__impact\`, ` +
-                            `\`mcp__gitnexus__context\`, \`mcp__gitnexus__query\`, \`mcp__gitnexus__find_cycles\`, …) ` +
-                            `over the built-in \`code_graph\` / \`codebase_map\`: the gitnexus graph is broader and more ` +
+                            `coupling, complexity — PREFER its MCP tools (\`mcp__code-explorer__impact\`, ` +
+                            `\`mcp__code-explorer__context\`, \`mcp__code-explorer__query\`, \`mcp__code-explorer__find_cycles\`, …) ` +
+                            `over the built-in \`code_graph\` / \`codebase_map\`: the code-explorer graph is broader and more ` +
                             `complete (whole-repo, 14 languages).\n` +
-                            `Usage: first call \`mcp__gitnexus__list_repos\` once to get the repo \`path\`/\`id\`, then call ` +
-                            `\`mcp__gitnexus__impact\` with the REQUIRED \`target\` = the symbol name (e.g. \`target: "executePlan"\`, ` +
-                            `optionally \`direction: "both"\`) and \`repo\` = that path; or \`mcp__gitnexus__context\` with \`name\` = ` +
+                            `Usage: first call \`mcp__code-explorer__list_repos\` once to get the repo \`path\`/\`id\`, then call ` +
+                            `\`mcp__code-explorer__impact\` with the REQUIRED \`target\` = the symbol name (e.g. \`target: "executePlan"\`, ` +
+                            `optionally \`direction: "both"\`) and \`repo\` = that path; or \`mcp__code-explorer__context\` with \`name\` = ` +
                             `the symbol. Always include \`target\`/\`name\` — never call these tools with empty arguments. ` +
-                            `Use the built-in \`code_graph\`/\`codebase_map\` only as a fallback if a gitnexus tool errors.\n` +
+                            `Use the built-in \`code_graph\`/\`codebase_map\` only as a fallback if a code-explorer tool errors.\n` +
                             `</code_explorer_priority>`;
                     logger.debug('Injected Code Explorer priority directive');
                 }

package/dist/skills/parser.js

@@ -57,7 +57,7 @@ function parseMetadata(yamlContent, sourcePath) {
         // Parse allowed-tools (Standard compatibility)
         let allowedTools = parsed['allowed-tools'];
         if (typeof allowedTools === 'string') {
-            // Native Engine uses comma separated values like: Bash(gitnexus *), Read, Grep, Glob
+            // Native Engine uses comma separated values like: Bash(code-explorer *), Read, Grep, Glob
             const toolsList = allowedTools.split(',').map(t => t.trim());
             const mappedTools = [];
             for (const t of toolsList) {

package/dist/tools/{gitnexus-tool.d.ts → code-explorer-tool.d.ts}

@@ -1,15 +1,15 @@
 /**
- * GitNexus Tool Client
+ * CodeExplorer Tool Client
  *
- * Consultative, read-only interface to GitNexus endpoints (/ask, /push-session, /world-model).
+ * Consultative, read-only interface to CodeExplorer endpoints (/ask, /push-session, /world-model).
  * Degrades gracefully by returning empty contexts/invariants and detailed notes on timeout/offline.
  */
-export interface GitNexusConfig {
+export interface CodeExplorerConfig {
     endpoint?: string;
     apiKey?: string;
     timeoutMs?: number;
 }
-export interface GitNexusContext {
+export interface CodeExplorerContext {
     likelyFiles: string[];
     dependentSymbols: string[];
     testsToWatch: string[];
@@ -19,21 +19,21 @@ export interface WorldModelInvariants {
     architecture: string[];
     invariants: string[];
 }
-export declare class GitNexusTool {
+export declare class CodeExplorerTool {
     private endpoint;
     private apiKey;
     private timeoutMs;
-    constructor(config?: GitNexusConfig);
+    constructor(config?: CodeExplorerConfig);
     /**
      * Helper to perform HTTP request with timeout and headers.
      */
     private request;
     /**
-     * Lecture seule : interroge GitNexus pour une tâche/texte. Dégrade proprement si indisponible.
+     * Lecture seule : interroge CodeExplorer pour une tâche/texte. Dégrade proprement si indisponible.
      */
-    ask(query: string): Promise<GitNexusContext>;
+    ask(query: string): Promise<CodeExplorerContext>;
     /**
-     * Pousse le résumé de session vers GitNexus (mémoire technique).
+     * Pousse le résumé de session vers CodeExplorer (mémoire technique).
      */
     pushSession(summary: string): Promise<{
         ok: boolean;