opencode-agora 0.4.2 → 0.4.3

package/dist/search/catalog-index.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Offline BM25 inverted-index for the Agora marketplace catalog.
+ *
+ * ## Why BM25?
+ * BM25 (Best Match 25) is a probabilistic term-frequency / inverse-document-frequency
+ * ranking function that handles two key issues with naive TF-IDF:
+ *   1. Term-frequency saturation — a token appearing 100× in a doc is not 100× as
+ *      relevant as one appearing once; BM25 saturates via (tf / (tf + k1*(1-b+b*dl/avgdl))).
+ *   2. Document-length normalization — long documents naturally accumulate more term
+ *      hits; the `b` parameter (0–1) penalizes them proportionally.
+ *
+ * ## Field weighting via token repetition
+ * Rather than maintaining separate per-field inverted lists (which complicates the
+ * index structure), we inflate the term-frequency bag at index time:
+ *   - name token contributes ×3 to TF  (most signal: users search by name)
+ *   - tags token contributes ×2         (curated semantic labels)
+ *   - id token contributes ×2           (IDs are precise matches)
+ *   - description/author/category ×1    (background context)
+ *
+ * This is equivalent to weighted field merging and requires zero extra complexity in
+ * the scoring loop.
+ *
+ * ## Fully offline, zero dependencies
+ * Matches Wave 1 "no external accounts / no network" constraint. The index is
+ * rebuilt in-memory from the item list; it never persists to disk and needs no
+ * embedding model or API key.
+ */
+export interface IndexableItem {
+    id: string;
+    name: string;
+    description: string;
+    author: string;
+    category: string;
+    tags: string[];
+}
+/** Per-document posting entry stored in the inverted list. */
+interface Posting {
+    id: string;
+    tf: number;
+}
+export interface CatalogIndex {
+    /** postings[term] = array of {id, tf} for every doc containing that term */
+    postings: Map<string, Posting[]>;
+    /** df[term] = number of distinct documents containing that term */
+    df: Map<string, number>;
+    /** docLen[id] = sum of all weighted TF values for that document */
+    docLen: Map<string, number>;
+    /** average document length across all indexed documents */
+    avgDocLen: number;
+    /** total number of indexed documents */
+    N: number;
+}
+/**
+ * Combined English stopwords + intent/filler words.
+ * Intent words are stripped so that queries like
+ * "find a tool that talks to postgres" reduce to their content terms.
+ */
+export declare const STOPWORDS: Set<string>;
+/**
+ * Tokenize text for indexing or querying:
+ *   - lowercase
+ *   - split on non-alphanumeric runs
+ *   - drop tokens shorter than 2 characters
+ *   - drop STOPWORDS
+ *
+ * Deterministic: identical input always yields identical output.
+ */
+export declare function tokenize(text: string): string[];
+/**
+ * Developer-term synonym map. Applied ONLY during query tokenization, not at
+ * index time, so documents are indexed verbatim (no spurious term inflation).
+ *
+ * When a query token matches a key, its synonyms are added as additional query
+ * terms (deduped). This allows short aliases ("db", "k8s") to match their full
+ * forms in document text.
+ */
+export declare const SYNONYMS: Record<string, string[]>;
+/**
+ * Tokenize a query string and expand synonyms.
+ * Returns a deduplicated array of tokens (original + synonym expansions).
+ */
+export declare function tokenizeQuery(text: string): string[];
+/**
+ * Build a BM25 inverted index from a list of indexable items.
+ *
+ * Field weighting is achieved by repeating tokens in the TF bag:
+ *   name ×3, tags ×2, id ×2, description ×1, author ×1, category ×1
+ */
+export declare function buildIndex(items: IndexableItem[]): CatalogIndex;
+/**
+ * Search the index with BM25 scoring.
+ *
+ * @param index   - built by buildIndex()
+ * @param query   - raw query string (will be tokenized + synonym-expanded)
+ * @param opts    - BM25 hyperparameters (defaults: k1=1.5, b=0.75)
+ * @returns       - scored results sorted by score descending; empty array if
+ *                  query is blank or no documents match
+ */
+export declare function searchIndex(index: CatalogIndex, query: string, opts?: {
+    k1?: number;
+    b?: number;
+}): {
+    id: string;
+    score: number;
+}[];
+export {};
+//# sourceMappingURL=catalog-index.d.ts.map

package/dist/search/catalog-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog-index.d.ts","sourceRoot":"","sources":["../../src/search/catalog-index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED,8DAA8D;AAC9D,UAAU,OAAO;IACf,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,YAAY;IAC3B,4EAA4E;IAC5E,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC;IACjC,mEAAmE;IACnE,EAAE,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxB,mEAAmE;IACnE,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5B,2DAA2D;IAC3D,SAAS,EAAE,MAAM,CAAC;IAClB,wCAAwC;IACxC,CAAC,EAAE,MAAM,CAAC;CACX;AAID;;;;GAIG;AACH,eAAO,MAAM,SAAS,EAAE,GAAG,CAAC,MAAM,CAiFhC,CAAC;AAIH;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAK/C;AAID;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAsB7C,CAAC;AAEF;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAYpD;AAID;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,aAAa,EAAE,GAAG,YAAY,CAqD/D;AAID;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,YAAY,EACnB,KAAK,EAAE,MAAM,EACb,IAAI,CAAC,EAAE;IAAE,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GACjC;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAAE,CAoCjC"}

package/dist/search/catalog-index.js

@@ -0,0 +1,276 @@
+/**
+ * Offline BM25 inverted-index for the Agora marketplace catalog.
+ *
+ * ## Why BM25?
+ * BM25 (Best Match 25) is a probabilistic term-frequency / inverse-document-frequency
+ * ranking function that handles two key issues with naive TF-IDF:
+ *   1. Term-frequency saturation — a token appearing 100× in a doc is not 100× as
+ *      relevant as one appearing once; BM25 saturates via (tf / (tf + k1*(1-b+b*dl/avgdl))).
+ *   2. Document-length normalization — long documents naturally accumulate more term
+ *      hits; the `b` parameter (0–1) penalizes them proportionally.
+ *
+ * ## Field weighting via token repetition
+ * Rather than maintaining separate per-field inverted lists (which complicates the
+ * index structure), we inflate the term-frequency bag at index time:
+ *   - name token contributes ×3 to TF  (most signal: users search by name)
+ *   - tags token contributes ×2         (curated semantic labels)
+ *   - id token contributes ×2           (IDs are precise matches)
+ *   - description/author/category ×1    (background context)
+ *
+ * This is equivalent to weighted field merging and requires zero extra complexity in
+ * the scoring loop.
+ *
+ * ## Fully offline, zero dependencies
+ * Matches Wave 1 "no external accounts / no network" constraint. The index is
+ * rebuilt in-memory from the item list; it never persists to disk and needs no
+ * embedding model or API key.
+ */
+// ── Stopwords ─────────────────────────────────────────────────────────────────
+/**
+ * Combined English stopwords + intent/filler words.
+ * Intent words are stripped so that queries like
+ * "find a tool that talks to postgres" reduce to their content terms.
+ */
+export const STOPWORDS = new Set([
+    // English function words
+    'the',
+    'a',
+    'an',
+    'to',
+    'of',
+    'for',
+    'and',
+    'or',
+    'with',
+    'that',
+    'this',
+    'my',
+    'i',
+    'in',
+    'on',
+    'is',
+    'are',
+    'it',
+    'by',
+    'at',
+    'as',
+    'be',
+    'was',
+    'has',
+    'have',
+    'not',
+    'its',
+    'from',
+    'into',
+    'than',
+    'but',
+    'about',
+    // Intent / filler words common in natural-language queries
+    'find',
+    'search',
+    'show',
+    'get',
+    'need',
+    'want',
+    'looking',
+    'something',
+    'anything',
+    'tool',
+    'tools',
+    'thing',
+    'things',
+    'does',
+    'do',
+    'help',
+    'please',
+    'can',
+    'give',
+    'use',
+    'using',
+    'used',
+    'like',
+    'also',
+    'which',
+    'how',
+    'what',
+    'where',
+    'when',
+    'why',
+    'who',
+    'some',
+    'any',
+    'all',
+    'talks',
+    'talk',
+    'connect',
+    'connects',
+    'access',
+    'accesses',
+    'let',
+    'lets',
+    'work',
+    'works',
+    'support',
+    'supports'
+]);
+// ── Tokenizer ─────────────────────────────────────────────────────────────────
+/**
+ * Tokenize text for indexing or querying:
+ *   - lowercase
+ *   - split on non-alphanumeric runs
+ *   - drop tokens shorter than 2 characters
+ *   - drop STOPWORDS
+ *
+ * Deterministic: identical input always yields identical output.
+ */
+export function tokenize(text) {
+    return text
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((t) => t.length >= 2 && !STOPWORDS.has(t));
+}
+// ── Synonyms (query-side expansion only) ─────────────────────────────────────
+/**
+ * Developer-term synonym map. Applied ONLY during query tokenization, not at
+ * index time, so documents are indexed verbatim (no spurious term inflation).
+ *
+ * When a query token matches a key, its synonyms are added as additional query
+ * terms (deduped). This allows short aliases ("db", "k8s") to match their full
+ * forms in document text.
+ */
+export const SYNONYMS = {
+    db: ['database'],
+    k8s: ['kubernetes'],
+    k8: ['kubernetes'],
+    postgres: ['postgresql', 'database'],
+    pg: ['postgresql', 'database'],
+    js: ['javascript'],
+    ts: ['typescript'],
+    ai: ['llm'],
+    auth: ['authentication'],
+    vcs: ['git'],
+    ml: ['machine', 'learning'],
+    api: ['integration'],
+    cli: ['command'],
+    ui: ['interface'],
+    gh: ['github'],
+    gl: ['gitlab'],
+    aws: ['amazon'],
+    gcp: ['google'],
+    kv: ['cache'],
+    nosql: ['database'],
+    sql: ['database']
+};
+/**
+ * Tokenize a query string and expand synonyms.
+ * Returns a deduplicated array of tokens (original + synonym expansions).
+ */
+export function tokenizeQuery(text) {
+    const base = tokenize(text);
+    const expanded = new Set(base);
+    for (const token of base) {
+        const syns = SYNONYMS[token];
+        if (syns) {
+            for (const syn of syns) {
+                expanded.add(syn);
+            }
+        }
+    }
+    return Array.from(expanded);
+}
+// ── Index builder ─────────────────────────────────────────────────────────────
+/**
+ * Build a BM25 inverted index from a list of indexable items.
+ *
+ * Field weighting is achieved by repeating tokens in the TF bag:
+ *   name ×3, tags ×2, id ×2, description ×1, author ×1, category ×1
+ */
+export function buildIndex(items) {
+    const postings = new Map();
+    const df = new Map();
+    const docLen = new Map();
+    let totalLen = 0;
+    for (const item of items) {
+        // Build weighted TF bag for this document
+        const tfBag = new Map();
+        function addTokens(text, weight) {
+            for (const token of tokenize(text)) {
+                tfBag.set(token, (tfBag.get(token) ?? 0) + weight);
+            }
+        }
+        addTokens(item.name, 3);
+        for (const tag of item.tags) {
+            addTokens(tag, 2);
+        }
+        addTokens(item.id, 2);
+        addTokens(item.description, 1);
+        addTokens(item.author, 1);
+        addTokens(item.category, 1);
+        // Document length = sum of weighted TFs
+        let dl = 0;
+        for (const tf of tfBag.values()) {
+            dl += tf;
+        }
+        docLen.set(item.id, dl);
+        totalLen += dl;
+        // Update postings and DF
+        for (const [term, tf] of tfBag.entries()) {
+            // DF: count this document once per term
+            df.set(term, (df.get(term) ?? 0) + 1);
+            // Postings list
+            let list = postings.get(term);
+            if (!list) {
+                list = [];
+                postings.set(term, list);
+            }
+            list.push({ id: item.id, tf });
+        }
+    }
+    const N = items.length;
+    const avgDocLen = N > 0 ? totalLen / N : 1;
+    return { postings, df, docLen, avgDocLen, N };
+}
+// ── BM25 scorer ───────────────────────────────────────────────────────────────
+/**
+ * Search the index with BM25 scoring.
+ *
+ * @param index   - built by buildIndex()
+ * @param query   - raw query string (will be tokenized + synonym-expanded)
+ * @param opts    - BM25 hyperparameters (defaults: k1=1.5, b=0.75)
+ * @returns       - scored results sorted by score descending; empty array if
+ *                  query is blank or no documents match
+ */
+export function searchIndex(index, query, opts) {
+    if (!query || !query.trim())
+        return [];
+    const k1 = opts?.k1 ?? 1.5;
+    const b = opts?.b ?? 0.75;
+    const { postings, df, docLen, avgDocLen, N } = index;
+    const queryTokens = tokenizeQuery(query);
+    if (queryTokens.length === 0)
+        return [];
+    // Accumulate scores per document
+    const scores = new Map();
+    for (const term of queryTokens) {
+        const list = postings.get(term);
+        if (!list)
+            continue;
+        const termDf = df.get(term) ?? 0;
+        // IDF with smoothing (Robertson-Sparck Jones):
+        //   idf = log((N - df + 0.5) / (df + 0.5) + 1)
+        const idf = Math.log((N - termDf + 0.5) / (termDf + 0.5) + 1);
+        for (const { id, tf } of list) {
+            const dl = docLen.get(id) ?? avgDocLen;
+            const norm = tf / (tf + k1 * (1 - b + b * (dl / avgDocLen)));
+            const contribution = idf * norm;
+            scores.set(id, (scores.get(id) ?? 0) + contribution);
+        }
+    }
+    if (scores.size === 0)
+        return [];
+    return Array.from(scores.entries())
+        .filter(([, score]) => score > 0)
+        .map(([id, score]) => ({ id, score }))
+        .sort((a, b) => b.score - a.score);
+}
+//# sourceMappingURL=catalog-index.js.map

package/dist/search/catalog-index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog-index.js","sourceRoot":"","sources":["../../src/search/catalog-index.ts"],"names":[],"mappings":"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"}

package/dist/stack/adapters/claude-code.d.ts

@@ -0,0 +1,3 @@
+import type { ToolAdapter } from '../types.js';
+export declare const claudeCodeAdapter: ToolAdapter;
+//# sourceMappingURL=claude-code.d.ts.map

package/dist/stack/adapters/claude-code.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-code.d.ts","sourceRoot":"","sources":["../../../src/stack/adapters/claude-code.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAKV,WAAW,EAEZ,MAAM,aAAa,CAAC;AA4IrB,eAAO,MAAM,iBAAiB,EAAE,WA+K/B,CAAC"}

package/dist/stack/adapters/claude-code.js

@@ -0,0 +1,282 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { atomicWriteFile } from '../../atomic-write.js';
+function resolveHome(opts) {
+    return opts.home ?? homedir();
+}
+function resolveCwd(opts) {
+    return opts.cwd ?? process.cwd();
+}
+const REMOTE_TYPES = new Set(['sse', 'http', 'streamable-http']);
+const LOCAL_TYPES = new Set(['stdio']);
+/** Fix 2: robust transport detection */
+function isRemoteEntry(entry) {
+    const t = typeof entry['type'] === 'string' ? entry['type'] : undefined;
+    const tr = typeof entry['transport'] === 'string' ? entry['transport'] : undefined;
+    const hasUrl = 'url' in entry;
+    const hasCommand = 'command' in entry;
+    if (t && REMOTE_TYPES.has(t))
+        return true;
+    if (tr && REMOTE_TYPES.has(tr))
+        return true;
+    if (t && LOCAL_TYPES.has(t))
+        return false;
+    if (tr && LOCAL_TYPES.has(tr))
+        return false;
+    if (hasCommand)
+        return false;
+    return hasUrl;
+}
+function parseEntry(name, entry, tool, scope, configPath) {
+    if (isRemoteEntry(entry)) {
+        return {
+            name,
+            tool,
+            scope,
+            configPath,
+            transport: 'remote',
+            url: typeof entry['url'] === 'string' ? entry['url'] : undefined,
+            enabled: true,
+            raw: entry
+        };
+    }
+    const cmd = typeof entry['command'] === 'string' ? entry['command'] : '';
+    const args = Array.isArray(entry['args']) ? entry['args'] : [];
+    const env = typeof entry['env'] === 'object' && entry['env'] !== null
+        ? entry['env']
+        : undefined;
+    const argv = [cmd, ...args];
+    return {
+        name,
+        tool,
+        scope,
+        configPath,
+        transport: 'local',
+        command: argv,
+        env,
+        enabled: true,
+        raw: entry
+    };
+}
+function readMcpServers(obj) {
+    if (typeof obj !== 'object' || obj === null)
+        return null;
+    const map = obj;
+    const result = [];
+    for (const [k, v] of Object.entries(map)) {
+        if (typeof v === 'object' && v !== null) {
+            result.push([k, v]);
+        }
+    }
+    return result;
+}
+function parseJson(path) {
+    try {
+        const content = readFileSync(path, 'utf8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Fix 1: Merge a DesiredServer into an existing entry, preserving unknown keys.
+ * Returns null when the server should not be written (disabled).
+ */
+function mergeEntry(ds, existing) {
+    // claude-code has no enabled field — skip disabled servers
+    if (ds.enabled === false)
+        return null;
+    const base = existing !== undefined ? { ...existing } : {};
+    if (ds.url) {
+        // REMOTE: set url; preserve existing sse/http type if present; remove local keys
+        base['url'] = ds.url;
+        delete base['command'];
+        delete base['args'];
+        delete base['env'];
+        const t = typeof base['type'] === 'string' ? base['type'] : undefined;
+        if (t && LOCAL_TYPES.has(t))
+            delete base['type'];
+        const tr = typeof base['transport'] === 'string' ? base['transport'] : undefined;
+        if (tr && LOCAL_TYPES.has(tr))
+            delete base['transport'];
+    }
+    else {
+        // LOCAL: set command/args/env; remove remote keys
+        const [cmd, ...args] = ds.command ?? [];
+        base['command'] = cmd ?? '';
+        if (args.length > 0) {
+            base['args'] = args;
+        }
+        else {
+            delete base['args'];
+        }
+        if (ds.env && Object.keys(ds.env).length > 0) {
+            base['env'] = ds.env;
+        }
+        else {
+            delete base['env'];
+        }
+        delete base['url'];
+        const t = typeof base['type'] === 'string' ? base['type'] : undefined;
+        if (t && REMOTE_TYPES.has(t))
+            delete base['type'];
+        const tr = typeof base['transport'] === 'string' ? base['transport'] : undefined;
+        if (tr && REMOTE_TYPES.has(tr))
+            delete base['transport'];
+    }
+    return base;
+}
+function entriesEqual(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+export const claudeCodeAdapter = {
+    id: 'claude-code',
+    displayName: 'Claude Code',
+    locations(opts) {
+        const cwd = resolveCwd(opts);
+        const home = resolveHome(opts);
+        return [
+            { path: join(cwd, '.mcp.json'), scope: 'project' },
+            { path: join(home, '.claude.json'), scope: 'user' }
+        ];
+    },
+    writeLocation(opts, scope) {
+        const cwd = resolveCwd(opts);
+        const home = resolveHome(opts);
+        if (scope === 'project') {
+            return { path: join(cwd, '.mcp.json'), scope: 'project' };
+        }
+        return { path: join(home, '.claude.json'), scope: 'user' };
+    },
+    writeServers(location, desired, opts) {
+        const filePath = location.path;
+        // Read existing file
+        let doc = {};
+        if (existsSync(filePath)) {
+            const raw = readFileSync(filePath, 'utf8');
+            let parsed;
+            try {
+                parsed = JSON.parse(raw);
+            }
+            catch (e) {
+                throw new Error(`claude-code config at ${filePath} is not valid JSON — refusing to overwrite: ${e instanceof Error ? e.message : String(e)}`, { cause: e });
+            }
+            if (typeof parsed === 'object' && parsed !== null) {
+                doc = parsed;
+            }
+        }
+        // Preserve all sibling keys; only mutate mcpServers
+        const result = { ...doc };
+        const existingMcp = typeof doc['mcpServers'] === 'object' && doc['mcpServers'] !== null
+            ? { ...doc['mcpServers'] }
+            : {};
+        const added = [];
+        const updated = [];
+        const removed = [];
+        const skippedDisabled = [];
+        const desiredMap = new Map(desired.map((d) => [d.name, d]));
+        const newMcp = opts.prune ? {} : { ...existingMcp };
+        for (const ds of desired) {
+            const existingEntry = typeof existingMcp[ds.name] === 'object' && existingMcp[ds.name] !== null
+                ? existingMcp[ds.name]
+                : undefined;
+            const mergedEntry = mergeEntry(ds, existingEntry);
+            if (mergedEntry === null) {
+                // disabled — skip writing
+                skippedDisabled.push(ds.name);
+                if (opts.prune && existingEntry !== undefined) {
+                    delete newMcp[ds.name];
+                }
+                continue;
+            }
+            if (existingEntry === undefined) {
+                added.push(ds.name);
+            }
+            else {
+                if (!entriesEqual(existingEntry, mergedEntry)) {
+                    updated.push(ds.name);
+                }
+            }
+            newMcp[ds.name] = mergedEntry;
+        }
+        if (opts.prune) {
+            for (const name of Object.keys(existingMcp)) {
+                if (!desiredMap.has(name) && !skippedDisabled.includes(name)) {
+                    removed.push(name);
+                }
+            }
+        }
+        result['mcpServers'] = newMcp;
+        atomicWriteFile(filePath, JSON.stringify(result, null, 2) + '\n', 0o644);
+        return { added, updated, removed };
+    },
+    readServers(opts) {
+        const cwd = resolveCwd(opts);
+        const home = resolveHome(opts);
+        const servers = [];
+        // --- Project file: <cwd>/.mcp.json ---
+        const projectPath = join(cwd, '.mcp.json');
+        if (existsSync(projectPath)) {
+            const parsed = parseJson(projectPath);
+            if (parsed !== null) {
+                const doc = parsed;
+                const entries = readMcpServers(doc['mcpServers']);
+                if (entries) {
+                    for (const [name, entry] of entries) {
+                        servers.push(parseEntry(name, entry, 'claude-code', 'project', projectPath));
+                    }
+                }
+            }
+        }
+        // --- User file: ~/.claude.json ---
+        const userPath = join(home, '.claude.json');
+        if (existsSync(userPath)) {
+            const parsed = parseJson(userPath);
+            if (parsed !== null) {
+                const doc = parsed;
+                // Top-level mcpServers (scope: user)
+                const topEntries = readMcpServers(doc['mcpServers']);
+                if (topEntries) {
+                    for (const [name, entry] of topEntries) {
+                        servers.push(parseEntry(name, entry, 'claude-code', 'user', userPath));
+                    }
+                }
+                // projects[<absCwd>].mcpServers (scope: project)
+                const projects = doc['projects'];
+                if (typeof projects === 'object' && projects !== null) {
+                    const projectsMap = projects;
+                    const cwdEntry = projectsMap[cwd];
+                    if (typeof cwdEntry === 'object' && cwdEntry !== null) {
+                        const projectDoc = cwdEntry;
+                        const projEntries = readMcpServers(projectDoc['mcpServers']);
+                        if (projEntries) {
+                            for (const [name, entry] of projEntries) {
+                                // Dedupe: skip if same name+command already added from top-level
+                                const isDupe = servers.some((s) => {
+                                    if (s.configPath !== userPath)
+                                        return false;
+                                    if (s.name !== name)
+                                        return false;
+                                    const newArgv = !isRemoteEntry(entry)
+                                        ? [
+                                            typeof entry['command'] === 'string' ? entry['command'] : '',
+                                            ...(Array.isArray(entry['args']) ? entry['args'] : [])
+                                        ]
+                                        : undefined;
+                                    return JSON.stringify(s.command) === JSON.stringify(newArgv);
+                                });
+                                if (!isDupe) {
+                                    servers.push(parseEntry(name, entry, 'claude-code', 'project', userPath));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return servers;
+    }
+};
+//# sourceMappingURL=claude-code.js.map