@phuetz/code-buddy 1.3.1 → 1.3.2

package/dist/index.js

@@ -508,6 +508,23 @@ async function saveCommandLineSettings(apiKey, baseURL) {
         cli.warn(`⚠️ Could not save settings to file: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
 }
+/**
+ * A saved/default model is only usable if it matches the detected provider's
+ * backend: a `grok-*` slug 404s on the ChatGPT/Codex backend, and a `gpt-5.*`
+ * slug 404s on xAI. We only enforce this for the two providers with a known
+ * hard incompatibility (grok ↔ chatgpt); other providers are left untouched so
+ * local/OpenAI/Anthropic model names pass through as before.
+ */
+function isModelCompatibleWithProvider(model, provider) {
+    if (!provider)
+        return true;
+    const looksGrok = /grok/i.test(model);
+    if (provider === 'grok')
+        return looksGrok;
+    if (provider === 'chatgpt')
+        return /^(gpt-|o[1-9]|codex)/i.test(model) && !looksGrok;
+    return true;
+}
 // Load model from detected provider or user settings
 async function loadModel() {
     await ensureEnvLoaded();
@@ -517,15 +534,15 @@ async function loadModel() {
     const detected = await getDetectedProvider();
     // 2. Project/user settings override auto-detection — UNLESS the saved model is
     //    incompatible with the detected provider. A `gpt-5.5` left in settings.json
-    //    would 404 against xAI after `buddy login xai`; prefer the Grok default then.
+    //    would 404 against xAI after `buddy login xai`; symmetrically, a stale
+    //    `grok-code-fast-1` default 404s against the ChatGPT/Codex backend (which
+    //    then falls back to another unsupported slug and crashes). In either
+    //    mismatch, prefer the detected provider's own default model.
     try {
         const getSettingsManager = await lazyImport.settingsManager();
         const settingsModel = getSettingsManager().getCurrentModel();
-        if (settingsModel) {
-            const grokProvider = detected?.provider === 'grok';
-            if (!grokProvider || /grok/i.test(settingsModel)) {
-                return settingsModel;
-            }
+        if (settingsModel && isModelCompatibleWithProvider(settingsModel, detected?.provider)) {
+            return settingsModel;
         }
     }
     catch (_err) {
@@ -827,7 +844,7 @@ async function processPromptHeadless(prompt, apiKey, baseURL, model, maxToolRoun
     const previousHeadless = process.env.CODEBUDDY_HEADLESS;
     // Headless defaults MCP OFF (startup cost / determinism), but respect an
     // explicit opt-in so `CODEBUDDY_DISABLE_MCP=false buddy -p …` can use MCP
-    // servers (e.g. the Code Explorer / gitnexus bridge, or the benchmark's
+    // servers (e.g. the Code Explorer / code-explorer bridge, or the benchmark's
     // "with graph" condition). Mirrors the opt-in pattern in goal-cli.ts.
     process.env.CODEBUDDY_DISABLE_MCP = process.env.CODEBUDDY_DISABLE_MCP ?? 'true';
     process.env.CODEBUDDY_HEADLESS = 'true';
@@ -839,7 +856,7 @@ async function processPromptHeadless(prompt, apiKey, baseURL, model, maxToolRoun
         await applyActiveLlmFailover(agent);
         await agent.systemPromptReady;
         // When MCP is opted in for this headless run, wait for the servers to finish
-        // connecting so their tools (e.g. the Code Explorer / gitnexus bridge) are
+        // connecting so their tools (e.g. the Code Explorer / code-explorer bridge) are
         // registered before the first turn — otherwise the one-shot turn races init
         // and the agent never sees the MCP tools.
         if (process.env.CODEBUDDY_DISABLE_MCP !== 'true') {
@@ -2461,9 +2478,9 @@ addLazyCommandGroup(program, 'fleet', 'Inspect Fleet routing and dispatch policy
     const { registerFleetCommands } = await import('./commands/cli/fleet-commands.js');
     registerFleetCommands(program);
 });
-addLazyCommandGroup(program, 'gitnexus', 'Interact with GitNexus for code understanding and session syncing', async () => {
-    const { registerGitNexusCommands } = await import('./commands/cli/gitnexus-commands.js');
-    registerGitNexusCommands(program);
+addLazyCommandGroup(program, 'code-explorer', 'Interact with CodeExplorer for code understanding and session syncing', async () => {
+    const { registerCodeExplorerCommands } = await import('./commands/cli/code-explorer-commands.js');
+    registerCodeExplorerCommands(program);
 });
 addLazyCommandGroup(program, 'hermes', 'Inspect the native Hermes-inspired Code Buddy agent profile', async () => {
     const { registerHermesCommands } = await import('./commands/cli/hermes-commands.js');

package/dist/kanban/colab-kanban-adapter.d.ts

@@ -0,0 +1,31 @@
+import { FleetColabStore } from '../fleet/colab-store.js';
+import type { CreateKanbanCardInput, KanbanCard, KanbanStoreOptions, ListKanbanCardsFilter } from './kanban-store.js';
+export declare class ColabKanbanAdapter {
+    private readonly store;
+    private readonly createId;
+    constructor(options?: KanbanStoreOptions);
+    /** The shared board file — now colab-tasks.json, not kanban-board.json. */
+    get path(): string;
+    createCard(input: CreateKanbanCardInput): Promise<KanbanCard>;
+    listCards(filter?: ListKanbanCardsFilter): Promise<KanbanCard[]>;
+    showCard(id: string): Promise<KanbanCard>;
+    completeCard(id: string, comment?: string, author?: string): Promise<KanbanCard>;
+    blockCard(id: string, reason: string, author?: string): Promise<KanbanCard>;
+    unblockCard(id: string, comment?: string, author?: string): Promise<KanbanCard>;
+    commentCard(id: string, text: string, author?: string): Promise<KanbanCard>;
+    heartbeatCard(id: string, message?: string, author?: string): Promise<KanbanCard>;
+    linkCard(id: string, target: string, label?: string): Promise<KanbanCard>;
+    private getOrThrow;
+    private buildCardId;
+}
+/**
+ * Migrate cards from a legacy `kanban-board.json` (read as {@link KanbanCard}s)
+ * into the unified fleet board. Idempotent: a card whose id already exists is
+ * skipped, as are archived cards (colab has no archived state). Comments and
+ * free-form links are carried over; ephemeral heartbeats are not. Returns the
+ * imported / skipped ids so a CLI can report the migration.
+ */
+export declare function importKanbanCards(cards: KanbanCard[], store: FleetColabStore): {
+    imported: string[];
+    skipped: string[];
+};

package/dist/kanban/colab-kanban-adapter.js

@@ -0,0 +1,232 @@
+/**
+ * ColabKanbanAdapter — the unification seam (Hermes/OpenClaw parity).
+ *
+ * Exposes the subset of the {@link KanbanStore} API that the `kanban_*` tools
+ * use, but backed by {@link FleetColabStore} so the agent's kanban tools and the
+ * autonomous daemon drive ONE shared board (`.codebuddy/colab-tasks.json`)
+ * instead of two disconnected files. A card created with `kanban_create` is now
+ * claimable by the daemon; a task the daemon completes shows up in `kanban_list`.
+ *
+ * The output keeps the {@link KanbanCard} shape (so the tool contract is stable),
+ * with a faithful status/priority mapping. Crucially `urgent ↔ critical`, so a
+ * card marked `urgent` becomes a `critical` colab task — which
+ * {@link FleetColabStore.isAutoClaimable} refuses to auto-claim. That is the
+ * intended safety carry-over: urgent work needs human eyes, it is not silently
+ * grabbed by the daemon.
+ *
+ * Free-form `kanban_link` references (PRs/commits/files) are kept as free-form
+ * links — they are NOT folded into the `dependsOn` DAG (which stays a distinct,
+ * task-id-only concept surfaced via `buddy autonomy tasks link`).
+ *
+ * The richer multi-board surface (board registry, assign, archive, unlink, stats)
+ * stays on {@link KanbanStore} / the `hermes kanban` CLI — those are not exposed
+ * as the 9 `kanban_*` tools, so they are intentionally out of this adapter.
+ */
+import * as path from 'path';
+import { FleetColabStore, } from '../fleet/colab-store.js';
+const STATUS_TO_KANBAN = {
+    open: 'todo',
+    in_progress: 'in_progress',
+    completed: 'done',
+    blocked: 'blocked',
+};
+const STATUS_TO_COLAB = {
+    todo: 'open',
+    in_progress: 'in_progress',
+    blocked: 'blocked',
+    done: 'completed',
+    archived: 'open', // archived has no colab equivalent; treat as open (archive lives on KanbanStore)
+};
+const PRIORITY_TO_KANBAN = {
+    critical: 'urgent',
+    high: 'high',
+    medium: 'medium',
+    low: 'low',
+};
+const PRIORITY_TO_COLAB = {
+    urgent: 'critical',
+    high: 'high',
+    medium: 'medium',
+    low: 'low',
+};
+export class ColabKanbanAdapter {
+    store;
+    createId;
+    constructor(options = {}) {
+        const rootDir = options.rootDir ?? process.cwd();
+        const config = { dir: path.join(rootDir, '.codebuddy') };
+        if (options.now) {
+            const toDate = options.now;
+            config.now = () => toDate().getTime();
+        }
+        this.createId = options.createId;
+        if (options.createId) {
+            const make = options.createId;
+            config.generateId = (prefix) => `${prefix}-${make()}`;
+        }
+        this.store = new FleetColabStore(config);
+    }
+    /** The shared board file — now colab-tasks.json, not kanban-board.json. */
+    get path() {
+        return path.join(this.store.getDir(), 'colab-tasks.json');
+    }
+    async createCard(input) {
+        const title = input.title.trim();
+        if (!title)
+            throw new Error('title is required');
+        const task = this.store.addTask({
+            title,
+            ...(input.id?.trim() ? { id: input.id.trim() } : { id: this.buildCardId(title) }),
+            ...(input.description?.trim() ? { description: input.description.trim() } : {}),
+            ...(input.status ? { status: STATUS_TO_COLAB[input.status] } : {}),
+            ...(input.priority ? { priority: PRIORITY_TO_COLAB[input.priority] } : {}),
+            ...(input.assignee?.trim() ? { assignee: input.assignee.trim() } : {}),
+            ...(input.tags && input.tags.length > 0 ? { tags: normalizeTags(input.tags) } : {}),
+        });
+        return toKanbanCard(task);
+    }
+    async listCards(filter = {}) {
+        const includeDone = filter.includeDone !== false;
+        const includeArchived = filter.includeArchived === true || filter.status === 'archived';
+        return this.store
+            .listTasks()
+            .map(toKanbanCard)
+            .filter((card) => {
+            if (!includeDone && card.status === 'done')
+                return false;
+            if (!includeArchived && card.status === 'archived')
+                return false;
+            if (filter.status && card.status !== filter.status)
+                return false;
+            if (filter.priority && card.priority !== filter.priority)
+                return false;
+            if (filter.assignee && card.assignee !== filter.assignee)
+                return false;
+            if (filter.tag && !card.tags.includes(filter.tag))
+                return false;
+            return true;
+        })
+            .sort(compareCards);
+    }
+    async showCard(id) {
+        return toKanbanCard(this.getOrThrow(id));
+    }
+    async completeCard(id, comment, author) {
+        this.getOrThrow(id);
+        this.store.completeTask(id, { summary: comment?.trim() || 'Completed', ...(author ? { agentId: author } : {}) });
+        if (comment?.trim())
+            this.store.addComment(id, comment, author);
+        return toKanbanCard(this.getOrThrow(id));
+    }
+    async blockCard(id, reason, author) {
+        const trimmed = reason.trim();
+        if (!trimmed)
+            throw new Error('reason is required');
+        this.store.blockTask(id, trimmed);
+        this.store.addComment(id, `Blocked: ${trimmed}`, author);
+        return toKanbanCard(this.getOrThrow(id));
+    }
+    async unblockCard(id, comment, author) {
+        return toKanbanCard(this.store.unblockTask(id, comment, author));
+    }
+    async commentCard(id, text, author) {
+        return toKanbanCard(this.store.addComment(id, text, author));
+    }
+    async heartbeatCard(id, message, author) {
+        return toKanbanCard(this.store.recordHeartbeat(id, message, author, author));
+    }
+    async linkCard(id, target, label) {
+        return toKanbanCard(this.store.addLink(id, target, label));
+    }
+    getOrThrow(id) {
+        const task = this.store.getTask(id.trim());
+        if (!task)
+            throw new Error(`kanban card not found: ${id}`);
+        return task;
+    }
+    buildCardId(title) {
+        const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 48) || 'card';
+        const raw = this.createId ? this.createId() : `${process.pid}${process.hrtime.bigint()}`;
+        const suffix = raw.replace(/[^a-zA-Z0-9]/g, '').slice(0, 8) || 'card';
+        return `kb-${slug}-${suffix}`;
+    }
+}
+/**
+ * Migrate cards from a legacy `kanban-board.json` (read as {@link KanbanCard}s)
+ * into the unified fleet board. Idempotent: a card whose id already exists is
+ * skipped, as are archived cards (colab has no archived state). Comments and
+ * free-form links are carried over; ephemeral heartbeats are not. Returns the
+ * imported / skipped ids so a CLI can report the migration.
+ */
+export function importKanbanCards(cards, store) {
+    const imported = [];
+    const skipped = [];
+    const existing = new Set(store.listTasks().map((t) => t.id));
+    for (const card of cards) {
+        if (card.status === 'archived' || existing.has(card.id)) {
+            skipped.push(card.id);
+            continue;
+        }
+        store.addTask({
+            id: card.id,
+            title: card.title,
+            status: STATUS_TO_COLAB[card.status],
+            priority: PRIORITY_TO_COLAB[card.priority],
+            ...(card.description ? { description: card.description } : {}),
+            ...(card.tags.length > 0 ? { tags: card.tags } : {}),
+            ...(card.assignee ? { assignee: card.assignee } : {}),
+        });
+        for (const c of card.comments)
+            store.addComment(card.id, c.text, c.author);
+        for (const l of card.links)
+            store.addLink(card.id, l.target, l.label);
+        imported.push(card.id);
+    }
+    return { imported, skipped };
+}
+function toKanbanCard(task) {
+    const createdAt = task.createdAt ?? task.claimedAt ?? new Date(0).toISOString();
+    const updatedAt = task.completedAt ?? task.lastHeartbeatAt ?? task.claimedAt ?? task.createdAt ?? createdAt;
+    return {
+        id: task.id,
+        title: task.title,
+        status: STATUS_TO_KANBAN[task.status],
+        priority: PRIORITY_TO_KANBAN[task.priority],
+        tags: normalizeTags(task.tags ?? []),
+        links: (task.links ?? []).map((l) => ({
+            id: l.id,
+            target: l.target,
+            createdAt: l.createdAt,
+            ...(l.label ? { label: l.label } : {}),
+        })),
+        comments: (task.comments ?? []).map((c) => ({
+            id: c.id,
+            text: c.text,
+            createdAt: c.createdAt,
+            ...(c.author ? { author: c.author } : {}),
+        })),
+        heartbeats: (task.heartbeats ?? []).map((h) => ({
+            id: h.id,
+            createdAt: h.createdAt,
+            ...(h.message ? { message: h.message } : {}),
+            ...(h.author ? { author: h.author } : {}),
+        })),
+        createdAt,
+        updatedAt,
+        ...(task.description ? { description: task.description } : {}),
+        ...(task.assignee ? { assignee: task.assignee } : {}),
+        ...(task.blockedReason ? { blockedReason: task.blockedReason } : {}),
+        ...(task.completedAt ? { completedAt: task.completedAt } : {}),
+    };
+}
+function normalizeTags(tags) {
+    return [...new Set(tags.map((t) => t.trim()).filter(Boolean))].sort((a, b) => a.localeCompare(b));
+}
+function compareCards(a, b) {
+    const statusOrder = { blocked: 0, in_progress: 1, todo: 2, done: 3, archived: 4 };
+    const priorityOrder = { urgent: 0, high: 1, medium: 2, low: 3 };
+    return (statusOrder[a.status] - statusOrder[b.status] ||
+        priorityOrder[a.priority] - priorityOrder[b.priority] ||
+        a.createdAt.localeCompare(b.createdAt));
+}
+//# sourceMappingURL=colab-kanban-adapter.js.map

package/dist/knowledge/community-detector.d.ts

@@ -1,5 +1,5 @@
 /**
- * Community Detection — GitNexus Knowledge Graph
+ * Community Detection — CodeExplorer Knowledge Graph
  *
  * Simplified label propagation algorithm for detecting architectural
  * modules/clusters in the code graph. Each node starts with its own

package/dist/knowledge/community-detector.js

@@ -1,5 +1,5 @@
 /**
- * Community Detection — GitNexus Knowledge Graph
+ * Community Detection — CodeExplorer Knowledge Graph
  *
  * Simplified label propagation algorithm for detecting architectural
  * modules/clusters in the code graph. Each node starts with its own

package/dist/knowledge/process-detector.d.ts

@@ -1,5 +1,5 @@
 /**
- * Process Detection — GitNexus Knowledge Graph
+ * Process Detection — CodeExplorer Knowledge Graph
  *
  * Detects execution flows by BFS from entry points in the code graph.
  * Entry points are functions with no internal callers (or matching

package/dist/knowledge/process-detector.js

@@ -1,5 +1,5 @@
 /**
- * Process Detection — GitNexus Knowledge Graph
+ * Process Detection — CodeExplorer Knowledge Graph
  *
  * Detects execution flows by BFS from entry points in the code graph.
  * Entry points are functions with no internal callers (or matching

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;