@mcoda/integrations 0.1.8 → 0.1.10

package/CHANGELOG.md

@@ -3,5 +3,8 @@
 ## Unreleased
 - Initial public packaging for @mcoda/integrations.
 
+## 0.1.9
+- Release v0.1.9.
+
 ## 0.1.8
 - Initial release.

package/README.md

@@ -7,7 +7,7 @@ External integrations for mcoda (docdex, telemetry, VCS, QA runners, update chec
 - Install: `npm i @mcoda/integrations`
 
 ## What it provides
-- DocdexClient for local or remote docdex queries.
+- DocdexClient for docdex daemon queries and CLI-backed ingestion.
 - TelemetryClient for token usage reporting.
 - VcsClient for Git operations.
 - SystemClient for update checks.
@@ -26,6 +26,8 @@ const docs = await client.search({ docType: "rfp", query: "payments" });
 ```
 
 ## Notes
+- Docdex state lives under `~/.docdex` (managed by the `docdex` CLI); mcoda does not create repo-local `.docdex`.
+- Chromium QA expects Docdex-installed Chromium (`docdex setup` or `MCODA_QA_CHROMIUM_PATH`).
 - Some integrations call external services; configure base URLs and tokens as needed.
 - Primarily used by the mcoda CLI; APIs may evolve.
 

package/dist/docdex/DocdexClient.d.ts

@@ -25,17 +25,28 @@ export interface RegisterDocumentInput {
 }
 export declare class DocdexClient {
     private options;
+    private resolvedBaseUrl?;
+    private repoId?;
+    private initializing;
+    private disabledReason?;
     constructor(options?: {
         workspaceRoot?: string;
-        storePath?: string;
         baseUrl?: string;
         authToken?: string;
+        repoId?: string;
     });
-    private getStorePath;
+    disable(reason?: string): void;
+    isAvailable(): boolean;
     private normalizePath;
-    private loadStore;
+    private resolveLocalDocPath;
+    private loadLocalDoc;
+    private resolveBaseUrl;
+    private buildMissingRepoMessage;
+    ensureRepoScope(): Promise<void>;
+    private ensureRepoInitialized;
     private fetchRemote;
-    private saveStore;
+    private buildLocalDoc;
+    private coerceSearchResults;
     fetchDocumentById(id: string): Promise<DocdexDocument>;
     findDocumentByPath(docPath: string, docType?: string): Promise<DocdexDocument | undefined>;
     search(filter: {
@@ -44,7 +55,11 @@ export declare class DocdexClient {
         query?: string;
         profile?: string;
     }): Promise<DocdexDocument[]>;
+    reindex(): Promise<void>;
     registerDocument(input: RegisterDocumentInput): Promise<DocdexDocument>;
     ensureRegisteredFromFile(docPath: string, docType: string, metadata?: Record<string, unknown>): Promise<DocdexDocument>;
+    private callMcp;
+    memorySave(text: string): Promise<void>;
+    savePreference(agentId: string, category: string, content: string): Promise<void>;
 }
 //# sourceMappingURL=DocdexClient.d.ts.map

package/dist/docdex/DocdexClient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DocdexClient.d.ts","sourceRoot":"","sources":["../../src/docdex/DocdexClient.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,aAAa,EAAE,CAAC;CAC5B;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAyCD,qBAAa,YAAY;IAErB,OAAO,CAAC,OAAO;gBAAP,OAAO,GAAE;QACf,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,SAAS,CAAC,EAAE,MAAM,CAAC;KACf;IAGR,OAAO,CAAC,YAAY;IAOpB,OAAO,CAAC,aAAa;YAYP,SAAS;YAaT,WAAW;YAYX,SAAS;IAOjB,iBAAiB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IAoBtD,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC;IAU1F,MAAM,CAAC,MAAM,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IA0BtH,gBAAgB,CAAC,KAAK,EAAE,qBAAqB,GAAG,OAAO,CAAC,cAAc,CAAC;IA6DvE,wBAAwB,CAC5B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC,OAAO,CAAC,cAAc,CAAC;CAO3B"}
+{"version":3,"file":"DocdexClient.d.ts","sourceRoot":"","sources":["../../src/docdex/DocdexClient.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,aAAa,EAAE,CAAC;CAC5B;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAkDD,qBAAa,YAAY;IAOrB,OAAO,CAAC,OAAO;IANjB,OAAO,CAAC,eAAe,CAAC,CAAS;IACjC,OAAO,CAAC,MAAM,CAAC,CAAS;IACxB,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,cAAc,CAAC,CAAS;gBAGtB,OAAO,GAAE;QACf,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,MAAM,CAAC,EAAE,MAAM,CAAC;KACZ;IAKR,OAAO,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;IAI9B,WAAW,IAAI,OAAO;IAItB,OAAO,CAAC,aAAa;IAYrB,OAAO,CAAC,mBAAmB;YASb,YAAY;YAYZ,cAAc;IAY5B,OAAO,CAAC,uBAAuB;IAKzB,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;YAWxB,qBAAqB;YA0BrB,WAAW;IAwCzB,OAAO,CAAC,aAAa;IAgBrB,OAAO,CAAC,mBAAmB;IAmDrB,iBAAiB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IA4BtD,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC;IAkB1F,MAAM,CAAC,MAAM,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IAkBtH,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAcxB,gBAAgB,CAAC,KAAK,EAAE,qBAAqB,GAAG,OAAO,CAAC,cAAc,CAAC;IA0BvE,wBAAwB,CAC5B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC,OAAO,CAAC,cAAc,CAAC;YAqBZ,OAAO;IAyBf,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQvC,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAQxF"}

package/dist/docdex/DocdexClient.js

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import path from "node:path";
 import { promises as fs } from "node:fs";
+import { resolveDocdexBaseUrl, runDocdex } from "./DocdexRuntime.js";
 const nowIso = () => new Date().toISOString();
 const segmentize = (docId, content) => {
     const lines = content.split(/\r?\n/);
@@ -33,15 +34,36 @@ const segmentize = (docId, content) => {
     flush();
     return segments;
 };
+const inferDocType = (docPath, fallback = "DOC") => {
+    if (!docPath)
+        return fallback;
+    const name = path.basename(docPath).toLowerCase();
+    if (name.includes("openapi") || name.includes("swagger"))
+        return "OPENAPI";
+    if (name.includes("sds"))
+        return "SDS";
+    if (name.includes("pdr"))
+        return "PDR";
+    if (name.includes("rfp"))
+        return "RFP";
+    return fallback;
+};
+const normalizeBaseUrl = (value) => {
+    if (!value)
+        return value;
+    return value.endsWith("/") ? value.slice(0, -1) : value;
+};
 export class DocdexClient {
     constructor(options = {}) {
         this.options = options;
+        this.initializing = false;
+        this.repoId = options.repoId;
+    }
+    disable(reason) {
+        this.disabledReason = reason?.trim() || "docdex unavailable";
     }
-    getStorePath() {
-        const base = this.options.storePath
-            ? path.resolve(this.options.storePath)
-            : path.join(this.options.workspaceRoot ?? process.cwd(), ".mcoda", "docdex", "documents.json");
-        return base;
+    isAvailable() {
+        return !this.disabledReason;
     }
     normalizePath(inputPath) {
         if (!inputPath)
@@ -55,162 +77,366 @@ export class DocdexClient {
         }
         return absolute;
     }
-    async loadStore() {
-        const storePath = this.getStorePath();
+    resolveLocalDocPath(docPath) {
+        if (!this.options.workspaceRoot)
+            return undefined;
+        const root = path.resolve(this.options.workspaceRoot);
+        const absolute = path.resolve(path.isAbsolute(docPath) ? docPath : path.join(root, docPath));
+        if (!absolute.startsWith(root))
+            return undefined;
+        const relative = path.relative(root, absolute);
+        return { absolute, relative: relative || undefined };
+    }
+    async loadLocalDoc(docPath, docType) {
+        const resolved = this.resolveLocalDocPath(docPath);
+        if (!resolved)
+            return undefined;
         try {
-            const raw = await fs.readFile(storePath, "utf8");
-            const parsed = JSON.parse(raw);
-            parsed.documents = parsed.documents ?? [];
-            parsed.segments = parsed.segments ?? [];
-            return parsed;
+            const content = await fs.readFile(resolved.absolute, "utf8");
+            const inferred = docType || inferDocType(resolved.relative ?? docPath);
+            return this.buildLocalDoc(inferred, resolved.relative ?? docPath, content);
         }
         catch {
-            return { updatedAt: nowIso(), documents: [], segments: [] };
+            return undefined;
+        }
+    }
+    async resolveBaseUrl() {
+        if (this.disabledReason)
+            return undefined;
+        if (this.options.baseUrl !== undefined) {
+            const trimmed = this.options.baseUrl.trim();
+            return trimmed ? normalizeBaseUrl(trimmed) : undefined;
+        }
+        if (this.resolvedBaseUrl !== undefined)
+            return this.resolvedBaseUrl;
+        const resolved = await resolveDocdexBaseUrl({ cwd: this.options.workspaceRoot });
+        this.resolvedBaseUrl = resolved ? normalizeBaseUrl(resolved) : undefined;
+        return this.resolvedBaseUrl;
+    }
+    buildMissingRepoMessage() {
+        const root = this.options.workspaceRoot ? path.resolve(this.options.workspaceRoot) : "unknown workspace";
+        return `Docdex repo scope missing for ${root}. Ensure docdexd is running and initialized for this repo, or set MCODA_DOCDEX_URL and MCODA_DOCDEX_REPO_ID.`;
+    }
+    async ensureRepoScope() {
+        const baseUrl = await this.resolveBaseUrl();
+        if (!baseUrl)
+            return;
+        if (!this.repoId) {
+            await this.ensureRepoInitialized(baseUrl, true);
+        }
+        if (!this.repoId) {
+            throw new Error(this.buildMissingRepoMessage());
+        }
+    }
+    async ensureRepoInitialized(baseUrl, force = false) {
+        if ((this.repoId && !force) || this.initializing)
+            return;
+        if (!this.options.workspaceRoot)
+            return;
+        this.initializing = true;
+        try {
+            const rootUri = `file://${path.resolve(this.options.workspaceRoot)}`;
+            const response = await fetch(`${baseUrl}/v1/initialize`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ rootUri }),
+            });
+            if (!response.ok)
+                return;
+            const payload = (await response.json().catch(() => undefined));
+            const repoId = payload?.repoId ??
+                payload?.repo_id ??
+                payload?.repo ??
+                payload?.id;
+            if (repoId)
+                this.repoId = String(repoId);
+        }
+        catch {
+            // ignore initialize errors; assume single-repo daemon
+        }
+        finally {
+            this.initializing = false;
         }
     }
     async fetchRemote(pathname, init) {
-        if (!this.options.baseUrl)
-            throw new Error("Docdex baseUrl not configured");
-        const url = new URL(pathname, this.options.baseUrl);
-        const headers = { "Content-Type": "application/json" };
-        if (this.options.authToken)
-            headers.authorization = `Bearer ${this.options.authToken}`;
-        const response = await fetch(url, { ...init, headers: { ...headers, ...init?.headers } });
+        if (this.disabledReason) {
+            throw new Error(`Docdex unavailable: ${this.disabledReason}`);
+        }
+        const baseUrl = await this.resolveBaseUrl();
+        if (!baseUrl) {
+            throw new Error("Docdex baseUrl not configured. Run docdex setup or set MCODA_DOCDEX_URL.");
+        }
+        await this.ensureRepoScope();
+        const url = new URL(pathname, baseUrl);
+        if (this.repoId && !url.searchParams.has("repo_id")) {
+            url.searchParams.set("repo_id", this.repoId);
+        }
+        if (this.options.workspaceRoot && !url.searchParams.has("repo_root")) {
+            url.searchParams.set("repo_root", path.resolve(this.options.workspaceRoot));
+        }
+        const buildHeaders = () => {
+            const headers = { "Content-Type": "application/json" };
+            if (this.options.authToken)
+                headers.authorization = `Bearer ${this.options.authToken}`;
+            if (this.repoId)
+                headers["x-docdex-repo-id"] = this.repoId;
+            if (this.options.workspaceRoot)
+                headers["x-docdex-repo-root"] = path.resolve(this.options.workspaceRoot);
+            return { ...headers, ...init?.headers };
+        };
+        const response = await fetch(url, { ...init, headers: buildHeaders() });
         if (!response.ok) {
-            throw new Error(`Docdex request failed (${response.status}): ${await response.text()}`);
+            const message = await response.text();
+            if (message.includes("missing_repo")) {
+                await this.ensureRepoInitialized(baseUrl, true);
+                if (this.repoId) {
+                    const retry = await fetch(url, { ...init, headers: buildHeaders() });
+                    if (retry.ok)
+                        return retry;
+                    const retryMessage = await retry.text();
+                    throw new Error(`Docdex request failed (${retry.status}): ${retryMessage}`);
+                }
+            }
+            throw new Error(`Docdex request failed (${response.status}): ${message}`);
         }
-        return (await response.json());
+        return response;
     }
-    async saveStore(store) {
-        const storePath = this.getStorePath();
-        await fs.mkdir(path.dirname(storePath), { recursive: true });
-        const payload = { ...store, updatedAt: nowIso() };
-        await fs.writeFile(storePath, JSON.stringify(payload, null, 2), "utf8");
+    buildLocalDoc(docType, docPath, content, metadata) {
+        const now = nowIso();
+        const id = `local-${randomUUID()}`;
+        return {
+            id,
+            docType,
+            path: docPath,
+            title: docPath ? path.basename(docPath) : undefined,
+            content,
+            metadata,
+            createdAt: now,
+            updatedAt: now,
+            segments: segmentize(id, content),
+        };
+    }
+    coerceSearchResults(raw, fallbackDocType) {
+        const items = Array.isArray(raw)
+            ? raw
+            : Array.isArray(raw?.results)
+                ? raw.results
+                : Array.isArray(raw?.hits)
+                    ? raw.hits
+                    : [];
+        const now = nowIso();
+        return items
+            .map((item, idx) => {
+            if (!item || typeof item !== "object")
+                return undefined;
+            const id = (item.doc_id ?? item.docId ?? item.id ?? `doc-${idx + 1}`);
+            const pathValue = (item.path ?? item.file ?? item.rel_path ?? item.file_path);
+            const title = (item.title ?? item.name ?? item.file_name);
+            const docType = (item.doc_type ?? item.docType ?? item.type ?? inferDocType(pathValue, fallbackDocType ?? "DOC"));
+            const snippet = (item.snippet ?? item.summary ?? item.excerpt);
+            const content = (item.content ?? snippet);
+            const segments = Array.isArray(item.segments)
+                ? item.segments.map((seg, segIdx) => ({
+                    id: seg.id ?? `${id}-seg-${segIdx + 1}`,
+                    docId: id,
+                    index: segIdx,
+                    content: seg.content ?? seg.text ?? "",
+                    heading: seg.heading ?? seg.title ?? undefined,
+                }))
+                : snippet
+                    ? [
+                        {
+                            id: `${id}-seg-1`,
+                            docId: id,
+                            index: 0,
+                            content: snippet,
+                            heading: undefined,
+                        },
+                    ]
+                    : undefined;
+            return {
+                id,
+                docType,
+                path: pathValue,
+                title,
+                content,
+                createdAt: item.created_at ?? item.createdAt ?? now,
+                updatedAt: item.updated_at ?? item.updatedAt ?? now,
+                segments,
+            };
+        })
+            .filter(Boolean);
     }
     async fetchDocumentById(id) {
-        if (this.options.baseUrl) {
+        const response = await this.fetchRemote(`/snippet/${encodeURIComponent(id)}?text_only=true`);
+        const contentType = response.headers.get("content-type") ?? "";
+        const body = await response.text();
+        let content = body;
+        if (contentType.includes("application/json")) {
             try {
-                const doc = await this.fetchRemote(`/documents/${id}`);
-                return doc;
+                const parsed = JSON.parse(body);
+                content =
+                    parsed.text ??
+                        parsed.content ??
+                        parsed.snippet ??
+                        body;
             }
-            catch (error) {
-                // fall through to local if remote fails
-                // eslint-disable-next-line no-console
-                console.warn(`Docdex remote fetch failed, falling back to local: ${error.message}`);
+            catch {
+                content = body;
             }
         }
-        const store = await this.loadStore();
-        const doc = store.documents.find((d) => d.id === id);
-        if (!doc) {
-            throw new Error(`Docdex document not found: ${id}`);
-        }
-        const segments = store.segments.filter((s) => s.docId === id);
-        return { ...doc, segments };
+        const now = nowIso();
+        return {
+            id,
+            docType: "DOC",
+            content,
+            createdAt: now,
+            updatedAt: now,
+            segments: content ? segmentize(id, content) : undefined,
+        };
     }
     async findDocumentByPath(docPath, docType) {
         const normalized = this.normalizePath(docPath);
-        const store = await this.loadStore();
-        const doc = store.documents.find((d) => d.path === normalized && (!docType || d.docType.toLowerCase() === docType.toLowerCase()));
-        if (!doc)
-            return undefined;
-        return { ...doc, segments: store.segments.filter((s) => s.docId === doc.id) };
+        const query = normalized ?? docPath;
+        let docs = [];
+        try {
+            docs = await this.search({ query, docType });
+        }
+        catch (error) {
+            const local = await this.loadLocalDoc(docPath, docType);
+            if (local)
+                return local;
+            throw error;
+        }
+        if (!docs.length) {
+            return await this.loadLocalDoc(docPath, docType);
+        }
+        if (!normalized)
+            return docs[0];
+        return docs.find((doc) => doc.path === normalized) ?? docs[0];
     }
     async search(filter) {
-        if (this.options.baseUrl) {
-            try {
-                const params = new URLSearchParams();
-                if (filter.docType)
-                    params.set("doc_type", filter.docType);
-                if (filter.projectKey)
-                    params.set("project_key", filter.projectKey);
-                if (filter.query)
-                    params.set("q", filter.query);
-                if (filter.profile)
-                    params.set("profile", filter.profile);
-                const path = `/documents?${params.toString()}`;
-                const docs = await this.fetchRemote(path);
-                return docs;
-            }
-            catch (error) {
-                // eslint-disable-next-line no-console
-                console.warn(`Docdex remote search failed, falling back to local: ${error.message}`);
-            }
+        const params = new URLSearchParams();
+        const queryParts = [filter.query, filter.docType, filter.projectKey].filter(Boolean);
+        const query = queryParts.join(" ").trim();
+        if (query)
+            params.set("q", query);
+        if (filter.profile)
+            params.set("profile", filter.profile);
+        if (filter.docType)
+            params.set("doc_type", filter.docType);
+        if (filter.projectKey)
+            params.set("project_key", filter.projectKey);
+        params.set("limit", "8");
+        const baseUrl = await this.resolveBaseUrl();
+        if (!baseUrl) {
+            return [];
         }
-        const store = await this.loadStore();
-        return store.documents
-            .filter((doc) => {
-            if (filter.docType && doc.docType.toLowerCase() !== filter.docType.toLowerCase())
-                return false;
-            if (filter.projectKey && doc.metadata && doc.metadata.projectKey !== filter.projectKey)
-                return false;
-            return true;
-        })
-            .map((doc) => ({ ...doc, segments: store.segments.filter((s) => s.docId === doc.id) }));
+        const response = await this.fetchRemote(`/search?${params.toString()}`);
+        const payload = (await response.json());
+        return this.coerceSearchResults(payload, filter.docType);
+    }
+    async reindex() {
+        const repoRoot = this.options.workspaceRoot ?? process.cwd();
+        const baseUrl = await this.resolveBaseUrl();
+        await runDocdex(["index", "--repo", repoRoot], {
+            cwd: repoRoot,
+            env: baseUrl
+                ? {
+                    DOCDEX_URL: baseUrl,
+                    MCODA_DOCDEX_URL: baseUrl,
+                }
+                : undefined,
+        });
     }
     async registerDocument(input) {
-        if (this.options.baseUrl) {
-            try {
-                const registered = await this.fetchRemote(`/documents`, {
-                    method: "POST",
-                    body: JSON.stringify({
-                        doc_type: input.docType,
-                        path: input.path,
-                        title: input.title,
-                        content: input.content,
-                        metadata: input.metadata,
-                    }),
-                });
-                return registered;
-            }
-            catch (error) {
-                // eslint-disable-next-line no-console
-                console.warn(`Docdex remote register failed, falling back to local: ${error.message}`);
-            }
+        const baseUrl = await this.resolveBaseUrl();
+        if (!baseUrl) {
+            const normalized = input.path ? this.normalizePath(input.path) ?? input.path : undefined;
+            return this.buildLocalDoc(input.docType, normalized, input.content, input.metadata);
         }
-        const store = await this.loadStore();
-        const normalizedPath = this.normalizePath(input.path);
-        const existingByPath = normalizedPath
-            ? store.documents.find((d) => d.path === normalizedPath &&
-                d.docType.toLowerCase() === input.docType.toLowerCase() &&
-                (input.metadata?.projectKey ? d.metadata?.projectKey === input.metadata.projectKey : true))
-            : undefined;
-        const now = nowIso();
-        if (existingByPath) {
-            const updated = {
-                ...existingByPath,
-                content: input.content ?? existingByPath.content,
-                metadata: { ...(existingByPath.metadata ?? {}), ...(input.metadata ?? {}) },
-                title: input.title ?? existingByPath.title,
-                updatedAt: now,
-            };
-            const segments = segmentize(updated.id, input.content);
-            store.documents[store.documents.findIndex((d) => d.id === existingByPath.id)] = updated;
-            store.segments = store.segments.filter((s) => s.docId !== updated.id).concat(segments);
-            await this.saveStore(store);
-            return { ...updated, segments };
+        if (!input.path) {
+            throw new Error("Docdex register requires a file path to ingest.");
         }
-        const doc = {
-            id: randomUUID(),
-            docType: input.docType,
-            path: normalizedPath,
-            content: input.content,
-            metadata: input.metadata,
-            title: input.title,
-            createdAt: now,
-            updatedAt: now,
-        };
-        const segments = segmentize(doc.id, input.content);
-        store.documents.push(doc);
-        store.segments.push(...segments);
-        await this.saveStore(store);
-        return { ...doc, segments };
+        await this.ensureRepoInitialized(baseUrl);
+        const resolvedPath = path.isAbsolute(input.path)
+            ? input.path
+            : path.join(this.options.workspaceRoot ?? process.cwd(), input.path);
+        const repoRoot = this.options.workspaceRoot ?? process.cwd();
+        await runDocdex(["ingest", "--repo", repoRoot, "--file", resolvedPath], {
+            cwd: repoRoot,
+            env: {
+                DOCDEX_URL: baseUrl,
+                MCODA_DOCDEX_URL: baseUrl,
+            },
+        });
+        const registered = await this.findDocumentByPath(resolvedPath, input.docType).catch(() => undefined);
+        if (registered)
+            return registered;
+        return this.buildLocalDoc(input.docType, resolvedPath, input.content, input.metadata);
     }
     async ensureRegisteredFromFile(docPath, docType, metadata) {
         const normalizedPath = this.normalizePath(docPath) ?? docPath;
-        const existing = await this.findDocumentByPath(normalizedPath, docType);
-        if (existing)
-            return existing;
+        try {
+            const existing = await this.findDocumentByPath(normalizedPath, docType);
+            if (existing)
+                return existing;
+        }
+        catch {
+            // ignore docdex lookup failures; fall back to local
+        }
         const content = await fs.readFile(docPath, "utf8");
-        return this.registerDocument({ docType, path: docPath, content, metadata });
+        const inferredType = docType || inferDocType(docPath);
+        const baseUrl = await this.resolveBaseUrl();
+        if (!baseUrl) {
+            return this.buildLocalDoc(inferredType, normalizedPath, content, metadata);
+        }
+        try {
+            return await this.registerDocument({ docType: inferredType, path: docPath, content, metadata });
+        }
+        catch {
+            return this.buildLocalDoc(inferredType, normalizedPath, content, metadata);
+        }
+    }
+    async callMcp(toolName, args) {
+        const payload = {
+            jsonrpc: "2.0",
+            id: randomUUID(),
+            method: "tools/call",
+            params: {
+                name: toolName,
+                arguments: args,
+            },
+        };
+        const response = await this.fetchRemote("/v1/mcp", {
+            method: "POST",
+            body: JSON.stringify(payload),
+        });
+        const raw = (await response.json());
+        if (raw.error) {
+            throw new Error(raw.error.message ?? "Docdex MCP call failed");
+        }
+        const result = raw.result;
+        if (result && typeof result === "object" && result.structuredContent !== undefined) {
+            return result.structuredContent;
+        }
+        return result;
+    }
+    async memorySave(text) {
+        if (!text.trim())
+            return;
+        await this.callMcp("docdex_memory_save", {
+            project_root: this.options.workspaceRoot,
+            text,
+        });
+    }
+    async savePreference(agentId, category, content) {
+        if (!agentId.trim() || !category.trim() || !content.trim())
+            return;
+        await this.callMcp("docdex_save_preference", {
+            agent_id: agentId,
+            category,
+            content,
+        });
     }
 }