@kyleparrott/where-was-i 0.1.0

package/dist/src/core/database.js

@@ -0,0 +1,432 @@
+import fs from "node:fs";
+import path from "node:path";
+import DatabaseConstructor from "better-sqlite3";
+import * as sqliteVec from "sqlite-vec";
+const SCHEMA_VERSION = 1;
+export class SessionSearchDb {
+    db;
+    constructor(dbPath) {
+        fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+        this.db = new DatabaseConstructor(dbPath);
+        sqliteVec.load(this.db);
+        this.db.pragma("journal_mode = WAL");
+        this.db.pragma("foreign_keys = ON");
+        this.migrate();
+    }
+    close() {
+        this.db.close();
+    }
+    getSource(pathValue) {
+        return this.db
+            .prepare("SELECT path, source, size, mtime_ms AS mtimeMs FROM sources WHERE path = ?")
+            .get(pathValue) ?? null;
+    }
+    sourceHasMessages(sourcePath) {
+        const row = this.db.prepare("SELECT 1 FROM messages WHERE source_path = ? LIMIT 1").get(sourcePath);
+        return Boolean(row);
+    }
+    upsertParsedSession(parsed, source) {
+        const insert = this.db.transaction(() => {
+            this.deleteSource(source.path);
+            this.db
+                .prepare(`INSERT INTO sources (path, source, size, mtime_ms, indexed_at)
+           VALUES (@path, @source, @size, @mtimeMs, @indexedAt)`)
+                .run({ ...source, indexedAt: new Date().toISOString() });
+            this.db
+                .prepare(`INSERT INTO sessions
+            (id, conversation_id, source, source_path, title, cwd, started_at, updated_at, message_count, turn_count)
+           VALUES
+            (@id, @conversationId, @source, @sourcePath, @title, @cwd, @startedAt, @updatedAt, @messageCount, @turnCount)
+           ON CONFLICT(id) DO UPDATE SET
+            conversation_id = excluded.conversation_id,
+            source = excluded.source,
+            source_path = excluded.source_path,
+            title = excluded.title,
+            cwd = excluded.cwd,
+            started_at = excluded.started_at,
+            updated_at = excluded.updated_at,
+            message_count = excluded.message_count,
+            turn_count = excluded.turn_count`)
+                .run(parsed.session);
+            const turnStmt = this.db.prepare(`INSERT OR REPLACE INTO turns
+          (id, session_id, source, source_path, ordinal, started_at, updated_at, message_count)
+         VALUES
+          (@id, @sessionId, @source, @sourcePath, @ordinal, @startedAt, @updatedAt, @messageCount)`);
+            for (const turn of parsed.turns) {
+                turnStmt.run(turn);
+            }
+            const messageStmt = this.db.prepare(`INSERT OR REPLACE INTO messages
+          (id, session_id, conversation_id, turn_id, source, source_path, ordinal, role, kind, timestamp, text, line_start, line_end, metadata_json)
+         VALUES
+          (@id, @sessionId, @conversationId, @turnId, @source, @sourcePath, @ordinal, @role, @kind, @timestamp, @text, @lineStart, @lineEnd, @metadataJson)`);
+            for (const message of parsed.messages) {
+                messageStmt.run({
+                    ...message,
+                    metadataJson: JSON.stringify(message.metadata)
+                });
+            }
+            const chunkStmt = this.db.prepare(`INSERT OR REPLACE INTO chunks
+          (id, message_id, session_id, conversation_id, turn_id, source, source_path, ordinal, chunk_index, role, kind, timestamp, text, line_start, line_end, metadata_json)
+         VALUES
+          (@id, @messageId, @sessionId, @conversationId, @turnId, @source, @sourcePath, @ordinal, @chunkIndex, @role, @kind, @timestamp, @text, @lineStart, @lineEnd, @metadataJson)`);
+            const deleteFtsStmt = this.db.prepare("DELETE FROM chunks_fts WHERE chunk_id = ?");
+            const ftsStmt = this.db.prepare(`INSERT INTO chunks_fts (chunk_id, session_id, role, text)
+         VALUES (@id, @sessionId, @role, @text)`);
+            for (const chunk of parsed.chunks) {
+                chunkStmt.run({
+                    ...chunk,
+                    metadataJson: JSON.stringify(chunk.metadata)
+                });
+                deleteFtsStmt.run(chunk.id);
+                ftsStmt.run(chunk);
+            }
+        });
+        insert();
+    }
+    deleteSource(sourcePath) {
+        this.deleteVectorsForSource(sourcePath);
+        this.db.prepare("DELETE FROM chunks_fts WHERE chunk_id IN (SELECT id FROM chunks WHERE source_path = ?)").run(sourcePath);
+        this.db.prepare("DELETE FROM chunks WHERE source_path = ?").run(sourcePath);
+        this.db.prepare("DELETE FROM messages WHERE source_path = ?").run(sourcePath);
+        this.db.prepare("DELETE FROM turns WHERE source_path = ?").run(sourcePath);
+        this.db.prepare("DELETE FROM sessions WHERE source_path = ?").run(sourcePath);
+        this.db.prepare("DELETE FROM sources WHERE path = ?").run(sourcePath);
+    }
+    listSessionChunks(sessionId, limit = 200) {
+        const rows = this.db
+            .prepare(`SELECT
+          id,
+          message_id AS messageId,
+          session_id AS sessionId,
+          conversation_id AS conversationId,
+          turn_id AS turnId,
+          source,
+          source_path AS sourcePath,
+          ordinal,
+          chunk_index AS chunkIndex,
+          role,
+          kind,
+          timestamp,
+          text,
+          line_start AS lineStart,
+          line_end AS lineEnd,
+          metadata_json AS metadataJson
+        FROM chunks
+        WHERE session_id = ?
+        ORDER BY ordinal ASC
+        LIMIT ?`)
+            .all(sessionId, limit);
+        return rows.map((row) => {
+            const { metadataJson, ...rest } = row;
+            return {
+                ...rest,
+                metadata: JSON.parse(metadataJson)
+            };
+        });
+    }
+    listSessionMessages(sessionId, limit = 200, offset = 0) {
+        const rows = this.db
+            .prepare(`SELECT
+          id,
+          session_id AS sessionId,
+          conversation_id AS conversationId,
+          turn_id AS turnId,
+          source,
+          source_path AS sourcePath,
+          ordinal,
+          role,
+          kind,
+          timestamp,
+          text,
+          line_start AS lineStart,
+          line_end AS lineEnd,
+          metadata_json AS metadataJson
+        FROM messages
+        WHERE session_id = ?
+        ORDER BY ordinal ASC
+        LIMIT ?
+        OFFSET ?`)
+            .all(sessionId, limit, Math.max(offset, 0));
+        return rows.map((row) => ({
+            ...row,
+            metadata: JSON.parse(row.metadataJson)
+        }));
+    }
+    listRecentSessions(limit = 25, offset = 0) {
+        const rows = this.db
+            .prepare(`SELECT
+          s.id,
+          s.conversation_id AS conversationId,
+          s.source,
+          s.source_path AS sourcePath,
+          s.title,
+          s.cwd,
+          s.started_at AS startedAt,
+          s.updated_at AS updatedAt,
+          s.message_count AS messageCount,
+          s.turn_count AS turnCount,
+          (
+            SELECT m.text
+            FROM messages m
+            WHERE m.session_id = s.id
+              AND m.role = 'user'
+              AND m.text NOT LIKE '# AGENTS.md instructions%'
+              AND m.text NOT LIKE '<INSTRUCTIONS>%'
+            ORDER BY m.ordinal ASC
+            LIMIT 1
+          ) AS firstUserText
+        FROM sessions s
+        ORDER BY COALESCE(s.updated_at, s.started_at, '') DESC, s.id DESC
+        LIMIT ?
+        OFFSET ?`)
+            .all(Math.min(Math.max(limit, 1), 100), Math.max(offset, 0));
+        return rows;
+    }
+    getMessage(messageId) {
+        const row = this.db
+            .prepare(`SELECT
+          id,
+          session_id AS sessionId,
+          conversation_id AS conversationId,
+          turn_id AS turnId,
+          source,
+          source_path AS sourcePath,
+          ordinal,
+          role,
+          kind,
+          timestamp,
+          text,
+          line_start AS lineStart,
+          line_end AS lineEnd,
+          metadata_json AS metadataJson
+        FROM messages
+        WHERE id = ?`)
+            .get(messageId);
+        return row ? messageFromRow(row) : null;
+    }
+    listMessagesAround(messageId, before = 2, after = 2) {
+        const target = this.getMessage(messageId);
+        if (!target) {
+            return { target: null, before: [], after: [] };
+        }
+        const beforeRows = this.messageRows(`session_id = ? AND ordinal < ? ORDER BY ordinal DESC LIMIT ?`, target.sessionId, target.ordinal, Math.max(before, 0)).reverse();
+        const afterRows = this.messageRows(`session_id = ? AND ordinal > ? ORDER BY ordinal ASC LIMIT ?`, target.sessionId, target.ordinal, Math.max(after, 0));
+        return { target, before: beforeRows, after: afterRows };
+    }
+    listTurnMessages(turnId, limit = 50) {
+        return this.messageRows(`turn_id = ? ORDER BY ordinal ASC LIMIT ?`, turnId, limit);
+    }
+    stats() {
+        const row = this.db
+            .prepare(`SELECT
+          (SELECT COUNT(*) FROM sources) AS sourceFiles,
+          (SELECT COUNT(*) FROM sessions) AS sessions,
+          (SELECT COUNT(*) FROM turns) AS turns,
+          (SELECT COUNT(*) FROM messages) AS messages,
+          (SELECT COUNT(*) FROM chunks) AS chunks,
+          (SELECT CASE WHEN EXISTS (SELECT 1 FROM sqlite_master WHERE name = 'vector_chunks_metadata')
+            THEN (SELECT COUNT(*) FROM vector_chunks_metadata)
+            ELSE 0
+          END) AS vectors,
+          (SELECT CASE WHEN EXISTS (SELECT 1 FROM sqlite_master WHERE name = 'embedding_providers')
+            THEN (SELECT COUNT(*) FROM embedding_providers)
+            ELSE 0
+          END) AS embeddingProviders,
+          (SELECT COALESCE(MAX(CAST(value AS INTEGER)), 0) FROM schema_metadata WHERE key = 'schema_version') AS schemaVersion,
+          (SELECT MAX(indexed_at) FROM sources) AS lastIndexedAt`)
+            .get();
+        return row;
+    }
+    migrate() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS schema_metadata (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS sources (
+        path TEXT PRIMARY KEY,
+        source TEXT NOT NULL,
+        size INTEGER NOT NULL,
+        mtime_ms INTEGER NOT NULL,
+        indexed_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS sessions (
+        id TEXT PRIMARY KEY,
+        conversation_id TEXT NOT NULL,
+        source TEXT NOT NULL,
+        source_path TEXT NOT NULL,
+        title TEXT,
+        cwd TEXT,
+        started_at TEXT,
+        updated_at TEXT,
+        message_count INTEGER NOT NULL,
+        turn_count INTEGER NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS turns (
+        id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        source TEXT NOT NULL,
+        source_path TEXT NOT NULL,
+        ordinal INTEGER NOT NULL,
+        started_at TEXT,
+        updated_at TEXT,
+        message_count INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_turns_session_ordinal
+        ON turns(session_id, ordinal);
+
+      CREATE TABLE IF NOT EXISTS messages (
+        id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        conversation_id TEXT NOT NULL,
+        turn_id TEXT NOT NULL,
+        source TEXT NOT NULL,
+        source_path TEXT NOT NULL,
+        ordinal INTEGER NOT NULL,
+        role TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        timestamp TEXT,
+        text TEXT NOT NULL,
+        line_start INTEGER NOT NULL,
+        line_end INTEGER NOT NULL,
+        metadata_json TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_messages_session_ordinal
+        ON messages(session_id, ordinal);
+
+      CREATE INDEX IF NOT EXISTS idx_messages_turn_ordinal
+        ON messages(turn_id, ordinal);
+
+      CREATE TABLE IF NOT EXISTS chunks (
+        id TEXT PRIMARY KEY,
+        message_id TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        conversation_id TEXT NOT NULL,
+        turn_id TEXT NOT NULL,
+        source TEXT NOT NULL,
+        source_path TEXT NOT NULL,
+        ordinal INTEGER NOT NULL,
+        chunk_index INTEGER NOT NULL,
+        role TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        timestamp TEXT,
+        text TEXT NOT NULL,
+        line_start INTEGER NOT NULL,
+        line_end INTEGER NOT NULL,
+        metadata_json TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_chunks_session_ordinal
+        ON chunks(session_id, ordinal);
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(
+        chunk_id UNINDEXED,
+        session_id UNINDEXED,
+        role UNINDEXED,
+        text,
+        tokenize = 'unicode61'
+      );
+
+      CREATE TABLE IF NOT EXISTS embedding_providers (
+        id TEXT PRIMARY KEY,
+        base_url TEXT NOT NULL,
+        model TEXT NOT NULL,
+        dimensions INTEGER NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS vector_chunks_metadata (
+        vector_rowid INTEGER PRIMARY KEY AUTOINCREMENT,
+        chunk_id TEXT UNIQUE NOT NULL,
+        message_id TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        provider_id TEXT NOT NULL,
+        model TEXT NOT NULL,
+        dimensions INTEGER NOT NULL,
+        indexed_at TEXT NOT NULL,
+        source_fingerprint TEXT NOT NULL
+      );
+    `);
+        this.setSchemaVersion(SCHEMA_VERSION);
+        this.ensureColumn("sessions", "conversation_id", "TEXT");
+        this.ensureColumn("sessions", "turn_count", "INTEGER");
+        this.ensureColumn("chunks", "message_id", "TEXT");
+        this.ensureColumn("chunks", "conversation_id", "TEXT");
+        this.ensureColumn("chunks", "turn_id", "TEXT");
+        this.ensureColumn("chunks", "chunk_index", "INTEGER");
+        this.ensureColumn("chunks", "line_start", "INTEGER");
+        this.ensureColumn("chunks", "line_end", "INTEGER");
+    }
+    ensureColumn(table, column, sqlType) {
+        const columns = this.db.prepare(`PRAGMA table_info(${table})`).all();
+        if (columns.some((existing) => existing.name === column)) {
+            return;
+        }
+        this.db.prepare(`ALTER TABLE ${table} ADD COLUMN ${column} ${sqlType}`).run();
+    }
+    setSchemaVersion(version) {
+        this.db
+            .prepare(`INSERT INTO schema_metadata (key, value, updated_at)
+         VALUES ('schema_version', @version, @updatedAt)
+         ON CONFLICT(key) DO UPDATE SET
+          value = excluded.value,
+          updated_at = excluded.updated_at`)
+            .run({ version: String(version), updatedAt: new Date().toISOString() });
+    }
+    deleteVectorsForSource(sourcePath) {
+        if (!this.tableExists("vector_chunks") || !this.tableExists("vector_chunks_metadata")) {
+            return;
+        }
+        const rows = this.db
+            .prepare(`SELECT v.vector_rowid AS vectorRowid
+         FROM vector_chunks_metadata v
+         JOIN chunks c ON c.id = v.chunk_id
+         WHERE c.source_path = ?`)
+            .all(sourcePath);
+        const deleteVector = this.db.prepare("DELETE FROM vector_chunks WHERE rowid = ?");
+        const deleteMetadata = this.db.prepare("DELETE FROM vector_chunks_metadata WHERE vector_rowid = ?");
+        for (const row of rows) {
+            deleteVector.run(BigInt(row.vectorRowid));
+            deleteMetadata.run(row.vectorRowid);
+        }
+    }
+    tableExists(table) {
+        const row = this.db.prepare("SELECT 1 FROM sqlite_master WHERE name = ?").get(table);
+        return Boolean(row);
+    }
+    messageRows(whereSql, ...params) {
+        const rows = this.db
+            .prepare(`SELECT
+          id,
+          session_id AS sessionId,
+          conversation_id AS conversationId,
+          turn_id AS turnId,
+          source,
+          source_path AS sourcePath,
+          ordinal,
+          role,
+          kind,
+          timestamp,
+          text,
+          line_start AS lineStart,
+          line_end AS lineEnd,
+          metadata_json AS metadataJson
+        FROM messages
+        WHERE ${whereSql}`)
+            .all(...params);
+        return rows.map(messageFromRow);
+    }
+}
+function messageFromRow(row) {
+    const { metadataJson, ...rest } = row;
+    return {
+        ...rest,
+        metadata: JSON.parse(metadataJson)
+    };
+}

package/dist/src/core/doctor.js

@@ -0,0 +1,113 @@
+import fs from "node:fs";
+import path from "node:path";
+import { EMBEDDING_PROVIDER_UNCONFIGURED_MESSAGE, OpenAICompatibleEmbeddingProvider, isEmbeddingProviderConfigured } from "./embeddings.js";
+import { defaultCodexHome, defaultIndexPath, expandHome } from "./paths.js";
+import { indexStats } from "./search.js";
+import { semanticFreshness } from "./semantic.js";
+export async function runDoctor(options = {}) {
+    const dbPath = expandHome(options.dbPath ?? defaultIndexPath());
+    const codexHome = expandHome(options.codexHome ?? defaultCodexHome());
+    const sessionsDir = path.join(codexHome, "sessions");
+    const archivedSessionsDir = path.join(codexHome, "archived_sessions");
+    const provider = new OpenAICompatibleEmbeddingProvider(options.embedding);
+    const semanticConfigured = isEmbeddingProviderConfigured(provider.config);
+    const recommendations = [];
+    const paths = {
+        dbPath,
+        dbExists: fs.existsSync(dbPath),
+        codexHome,
+        codexHomeExists: fs.existsSync(codexHome),
+        sessionsDir,
+        sessionsDirExists: fs.existsSync(sessionsDir),
+        archivedSessionsDir,
+        archivedSessionsDirExists: fs.existsSync(archivedSessionsDir)
+    };
+    const index = indexStats(dbPath);
+    if (!paths.codexHomeExists) {
+        recommendations.push(`Codex home does not exist: ${codexHome}`);
+    }
+    if (!paths.sessionsDirExists) {
+        recommendations.push(`Codex sessions directory does not exist: ${sessionsDir}`);
+    }
+    if (index.sourceFiles === 0 || index.messages === 0) {
+        recommendations.push("Run `wwi index` to build the lexical message index.");
+    }
+    const embedding = semanticConfigured ? await probeEmbedding(provider) : skippedEmbedding(provider);
+    if (semanticConfigured && !embedding.available) {
+        recommendations.push(`Embedding provider unavailable: ${embedding.error}`);
+    }
+    const semantic = await semanticFreshness({
+        dbPath,
+        embedding: options.embedding,
+        dimensions: embedding.dimensions,
+        probeProvider: false
+    });
+    if (semanticConfigured && semantic.missingChunks !== null && semantic.missingChunks > 0) {
+        recommendations.push(semantic.recommendation ?? "Run `wwi index --semantic` to refresh semantic vectors.");
+    }
+    return {
+        ok: recommendations.length === 0,
+        paths,
+        index,
+        embedding,
+        semantic,
+        recommendations
+    };
+}
+async function probeEmbedding(provider) {
+    if (!isEmbeddingProviderConfigured(provider.config)) {
+        return unconfiguredEmbedding(provider, true);
+    }
+    try {
+        const [models, dimensions] = await Promise.all([provider.listModels(), provider.probeDimensions()]);
+        return {
+            available: true,
+            checked: true,
+            providerId: provider.config.id,
+            baseUrl: provider.config.baseUrl,
+            model: provider.config.model,
+            dimensions,
+            models,
+            error: null
+        };
+    }
+    catch (error) {
+        return {
+            available: false,
+            checked: true,
+            providerId: provider.config.id,
+            baseUrl: provider.config.baseUrl || null,
+            model: provider.config.model || null,
+            dimensions: null,
+            models: [],
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+function skippedEmbedding(provider) {
+    if (!isEmbeddingProviderConfigured(provider.config)) {
+        return unconfiguredEmbedding(provider, false);
+    }
+    return {
+        checked: false,
+        available: false,
+        providerId: provider.config.id,
+        baseUrl: provider.config.baseUrl,
+        model: provider.config.model,
+        dimensions: null,
+        models: [],
+        error: "Semantic search is disabled; embedding provider was not checked."
+    };
+}
+function unconfiguredEmbedding(provider, checked) {
+    return {
+        checked,
+        available: false,
+        providerId: provider.config.id,
+        baseUrl: provider.config.baseUrl || null,
+        model: provider.config.model || null,
+        dimensions: null,
+        models: [],
+        error: EMBEDDING_PROVIDER_UNCONFIGURED_MESSAGE
+    };
+}

package/dist/src/core/embeddings.js

@@ -0,0 +1,118 @@
+export const DEFAULT_EMBEDDING_TIMEOUT_MS = 30_000;
+export const EMBEDDING_PROVIDER_UNCONFIGURED_MESSAGE = "Semantic search is not configured. Set WHERE_WAS_I_EMBEDDING_BASE_URL and WHERE_WAS_I_EMBEDDING_MODEL in ~/.where-was-i/config.json or environment variables.";
+export class EmbeddingProviderUnavailableError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "EmbeddingProviderUnavailableError";
+    }
+}
+export class OpenAICompatibleEmbeddingProvider {
+    config;
+    constructor(config = {}) {
+        this.config = {
+            id: config.id ?? config.model ?? "unconfigured",
+            baseUrl: config.baseUrl ? trimTrailingSlash(config.baseUrl) : "",
+            model: config.model ?? "",
+            apiKey: config.apiKey,
+            timeoutMs: config.timeoutMs ?? DEFAULT_EMBEDDING_TIMEOUT_MS
+        };
+    }
+    async listModels() {
+        this.assertBaseUrlConfigured();
+        const response = (await this.request("/models"));
+        return (response.data ?? []).map((model) => model.id).filter((id) => typeof id === "string");
+    }
+    async embedDocuments(texts) {
+        this.assertConfigured();
+        if (texts.length === 0) {
+            return { model: this.config.model, dimensions: 0, embeddings: [] };
+        }
+        const response = (await this.request("/embeddings", {
+            method: "POST",
+            body: JSON.stringify({
+                model: this.config.model,
+                input: texts
+            })
+        }));
+        const embeddings = (response.data ?? [])
+            .slice()
+            .sort((left, right) => (left.index ?? 0) - (right.index ?? 0))
+            .map((item) => item.embedding)
+            .filter((embedding) => Array.isArray(embedding));
+        if (embeddings.length !== texts.length) {
+            throw new EmbeddingProviderUnavailableError(`Embedding provider returned ${embeddings.length} embeddings for ${texts.length} inputs.`);
+        }
+        const dimensions = embeddings[0]?.length ?? 0;
+        if (dimensions === 0 || embeddings.some((embedding) => embedding.length !== dimensions)) {
+            throw new EmbeddingProviderUnavailableError("Embedding provider returned empty or inconsistent dimensions.");
+        }
+        return {
+            model: response.model ?? this.config.model,
+            dimensions,
+            embeddings
+        };
+    }
+    async embedQuery(text) {
+        return (await this.embedDocuments([text])).embeddings[0] ?? [];
+    }
+    async probeDimensions() {
+        return (await this.embedDocuments(["where was i dimension probe"])).dimensions;
+    }
+    assertConfigured() {
+        this.assertBaseUrlConfigured();
+        if (!this.config.model) {
+            throw new EmbeddingProviderUnavailableError(EMBEDDING_PROVIDER_UNCONFIGURED_MESSAGE);
+        }
+    }
+    assertBaseUrlConfigured() {
+        if (!this.config.baseUrl) {
+            throw new EmbeddingProviderUnavailableError(EMBEDDING_PROVIDER_UNCONFIGURED_MESSAGE);
+        }
+    }
+    async request(path, init = {}) {
+        const headers = new Headers(init.headers);
+        headers.set("content-type", "application/json");
+        if (this.config.apiKey) {
+            headers.set("authorization", `Bearer ${this.config.apiKey}`);
+        }
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.config.timeoutMs);
+        let response;
+        try {
+            response = await fetch(`${this.config.baseUrl}${path}`, {
+                ...init,
+                headers,
+                signal: controller.signal
+            });
+        }
+        catch (error) {
+            const isTimeout = error instanceof Error && error.name === "AbortError";
+            throw new EmbeddingProviderUnavailableError(isTimeout
+                ? `Embedding provider request timed out after ${this.config.timeoutMs}ms at ${this.config.baseUrl}.`
+                : `Embedding provider is unavailable at ${this.config.baseUrl}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+        const text = await response.text();
+        const body = text.length > 0 ? parseJson(text) : null;
+        if (!response.ok) {
+            throw new EmbeddingProviderUnavailableError(`Embedding provider request failed: ${response.status} ${response.statusText} ${typeof body === "string" ? body : JSON.stringify(body)}`);
+        }
+        return body;
+    }
+}
+function trimTrailingSlash(input) {
+    return input.replace(/\/+$/, "");
+}
+export function isEmbeddingProviderConfigured(config) {
+    return Boolean(config.baseUrl && config.model);
+}
+function parseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}