@larkup/cli 0.1.14

package/dist/index.js

@@ -0,0 +1,3060 @@
+#!/usr/bin/env node
+import {
+  __require
+} from "./chunk-3RG5ZIWI.js";
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/ui/prompts.ts
+import * as p from "@clack/prompts";
+
+// src/ui/logger.ts
+import chalk from "chalk";
+var log = {
+  /** Standard info message (default color) */
+  info: (msg) => process.stdout.write(msg + "\n"),
+  /** Success message (green) */
+  success: (msg) => process.stdout.write(chalk.green(`\u2713 ${msg}`) + "\n"),
+  /** Error message (red) and exit */
+  error: (msg) => {
+    process.stderr.write(chalk.red(`\u2717 ${msg}`) + "\n");
+    process.exit(1);
+  },
+  /** Warning message (yellow) */
+  warn: (msg) => process.stdout.write(chalk.yellow(`! ${msg}`) + "\n"),
+  /** Dimmed/secondary text */
+  dim: (msg) => process.stdout.write(chalk.dim(msg) + "\n"),
+  /** Emphasized text block */
+  bold: (msg) => process.stdout.write(chalk.bold(msg) + "\n"),
+  /** Inline formatting helpers */
+  fmt: {
+    dim: chalk.dim,
+    bold: chalk.bold,
+    green: chalk.green,
+    red: chalk.red,
+    cyan: chalk.cyan,
+    yellow: chalk.yellow
+  }
+};
+
+// src/ui/prompts.ts
+var prompts = {
+  intro: p.intro,
+  outro: p.outro,
+  text: async (opts) => {
+    const result = await p.text(opts);
+    if (p.isCancel(result)) {
+      log.error("Cancelled.");
+    }
+    return result;
+  },
+  select: async (opts) => {
+    const result = await p.select(opts);
+    if (p.isCancel(result)) {
+      log.error("Cancelled.");
+    }
+    return result;
+  },
+  confirm: async (opts) => {
+    const result = await p.confirm(opts);
+    if (p.isCancel(result)) {
+      log.error("Cancelled.");
+    }
+    return result;
+  },
+  spinner: p.spinner
+};
+
+// ../../packages/core/src/workspace.ts
+import { promises as fs } from "fs";
+import path from "path";
+import { randomUUID } from "crypto";
+import { AsyncLocalStorage } from "async_hooks";
+
+// ../../packages/core/src/types.ts
+var DEFAULT_CONFIG = {
+  projectName: "my-rag",
+  embeddingProvider: "openai",
+  embeddingApiKey: "",
+  embeddingModelId: "openai/text-embedding-3-small",
+  indexType: "hybrid",
+  chunking: {
+    chunkSize: 512,
+    chunkOverlap: 64,
+    strategy: "recursive"
+  },
+  vectorStore: "lancedb",
+  storeConfig: {
+    mode: "local",
+    dbPath: "./.larkup/lancedb"
+  },
+  topK: 5,
+  serperApiKey: "",
+  scraperProxyServer: "",
+  scraperProxyUsername: "",
+  scraperProxyPassword: "",
+  firecrawlApiKey: "",
+  updatedAt: (/* @__PURE__ */ new Date(0)).toISOString()
+};
+
+// ../../packages/core/src/workspace.ts
+var ROOT = path.join(process.cwd(), ".larkup");
+var SERVERS_DIR = path.join(ROOT, "servers");
+var WORKSPACE_PATH = path.join(ROOT, "workspace.json");
+var BASE_PORT = 8080;
+var EMPTY = { username: null, activeServerId: null, servers: [], mode: null };
+var als = new AsyncLocalStorage();
+function runWithServer(serverId, fn) {
+  return als.run({ serverId }, fn);
+}
+var writeChain = Promise.resolve();
+function serialize(fn) {
+  const run = writeChain.then(fn, fn);
+  writeChain = run.catch(() => {
+  });
+  return run;
+}
+function serverDir(id) {
+  return path.join(SERVERS_DIR, id);
+}
+function relServerPath(id, sub) {
+  return `./.larkup/servers/${id}/${sub}`;
+}
+async function exists(p5) {
+  try {
+    await fs.access(p5);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function moveIfExists(from, to) {
+  if (!await exists(from)) return;
+  await fs.mkdir(path.dirname(to), { recursive: true });
+  try {
+    await fs.rename(from, to);
+  } catch {
+    await fs.cp(from, to, { recursive: true });
+    await fs.rm(from, { recursive: true, force: true });
+  }
+}
+async function readRaw() {
+  try {
+    const raw = await fs.readFile(WORKSPACE_PATH, "utf8");
+    return { ...EMPTY, ...JSON.parse(raw) };
+  } catch {
+    return null;
+  }
+}
+async function writeRaw(ws) {
+  await fs.mkdir(ROOT, { recursive: true });
+  await fs.writeFile(WORKSPACE_PATH, JSON.stringify(ws, null, 2), "utf8");
+  return ws;
+}
+async function getWorkspace() {
+  const existing = await readRaw();
+  if (existing) return existing;
+  return serialize(migrateOrInit);
+}
+async function migrateOrInit() {
+  const again = await readRaw();
+  if (again) return again;
+  const hasLegacy = await exists(path.join(ROOT, "config.json"));
+  if (!hasLegacy) {
+    return writeRaw(EMPTY);
+  }
+  const id = randomUUID();
+  const dir = serverDir(id);
+  await fs.mkdir(dir, { recursive: true });
+  for (const f of [
+    "config.json",
+    "documents.json",
+    "jobs.json",
+    "index-run.json",
+    "server-local.json"
+  ]) {
+    await moveIfExists(path.join(ROOT, f), path.join(dir, f));
+  }
+  await moveIfExists(path.join(ROOT, "lancedb"), path.join(dir, "lancedb"));
+  await moveIfExists(
+    path.join(ROOT, "generated-server"),
+    path.join(dir, "generated-server")
+  );
+  let name = "Default server";
+  try {
+    const cfgPath = path.join(dir, "config.json");
+    const cfg = JSON.parse(await fs.readFile(cfgPath, "utf8"));
+    if (cfg.projectName) name = cfg.projectName;
+    if (cfg.vectorStore === "lancedb" && cfg.storeConfig?.mode !== "cloud") {
+      cfg.storeConfig = {
+        ...cfg.storeConfig,
+        dbPath: relServerPath(id, "lancedb")
+      };
+    }
+    await fs.writeFile(cfgPath, JSON.stringify(cfg, null, 2), "utf8");
+  } catch {
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const meta = {
+    id,
+    name,
+    port: BASE_PORT,
+    createdAt: now,
+    updatedAt: now
+  };
+  return writeRaw({ username: null, activeServerId: id, servers: [meta], mode: null });
+}
+async function getActiveServer() {
+  const ws = await getWorkspace();
+  const override = als.getStore()?.serverId;
+  const id = override ?? ws.activeServerId;
+  if (!id) return null;
+  return ws.servers.find((s) => s.id === id) ?? null;
+}
+async function getDataDir() {
+  const server = await getActiveServer();
+  if (!server) return null;
+  const dir = serverDir(server.id);
+  await fs.mkdir(dir, { recursive: true });
+  return dir;
+}
+async function requireDataDir() {
+  const dir = await getDataDir();
+  if (dir) return dir;
+  const { server } = await createServer("My RAG server");
+  return serverDir(server.id);
+}
+function nextPort(ws) {
+  const ports = ws.servers.map((s) => s.port);
+  return Math.max(BASE_PORT - 1, ...ports) + 1;
+}
+function defaultConfigFor(id, name) {
+  return {
+    ...DEFAULT_CONFIG,
+    projectName: name.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "my-rag",
+    storeConfig: { mode: "local", dbPath: relServerPath(id, "lancedb") },
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function createServer(name) {
+  return serialize(async () => {
+    const ws = await getWorkspace();
+    const id = randomUUID();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const meta = {
+      id,
+      name: name.trim() || "Untitled server",
+      port: nextPort(ws),
+      createdAt: now,
+      updatedAt: now
+    };
+    const dir = serverDir(id);
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(
+      path.join(dir, "config.json"),
+      JSON.stringify(defaultConfigFor(id, meta.name), null, 2),
+      "utf8"
+    );
+    const next = {
+      ...ws,
+      servers: [...ws.servers, meta],
+      activeServerId: id
+    };
+    await writeRaw(next);
+    return { workspace: next, server: meta };
+  });
+}
+function setActiveServer(id) {
+  return serialize(async () => {
+    const ws = await getWorkspace();
+    if (!ws.servers.some((s) => s.id === id)) return ws;
+    return writeRaw({ ...ws, activeServerId: id });
+  });
+}
+
+// src/commands/init.ts
+async function initCommand(name) {
+  const projectName = name ?? "my-rag";
+  const { server } = await createServer(projectName);
+  log.success(`Created server ${log.fmt.bold(server.name)}`);
+  log.dim(`  id   ${server.id}`);
+  log.dim(`  port ${server.port}  (the generated server listens here)`);
+  log.dim("  it is now the active server");
+}
+
+// src/commands/servers.ts
+async function listServersCommand() {
+  const ws = await getWorkspace();
+  if (ws.servers.length === 0) {
+    log.dim('No servers yet. Create one with: larkup init "my-rag"');
+    return;
+  }
+  log.bold("Servers");
+  for (const s of ws.servers) {
+    const active = s.id === ws.activeServerId;
+    const marker = active ? log.fmt.green("\u25CF") : log.fmt.dim("\u25CB");
+    log.info(`${marker} ${log.fmt.bold(s.name)} ${log.fmt.dim(`:${s.port}`)} ${log.fmt.dim(s.id)}`);
+  }
+}
+async function useServerCommand(target) {
+  const ws = await getWorkspace();
+  const next = ws.servers.find((s) => s.id === target) ?? ws.servers.find((s) => s.name === target);
+  if (!next) {
+    log.error(`No server matching "${target}".`);
+    return;
+  }
+  await setActiveServer(next.id);
+  log.success(`Active server is now ${log.fmt.bold(next.name)}`);
+}
+
+// ../../packages/core/src/config-store.ts
+import { promises as fs2 } from "fs";
+import path2 from "path";
+async function readConfig() {
+  const dir = await getDataDir();
+  if (!dir) return DEFAULT_CONFIG;
+  try {
+    const raw = await fs2.readFile(path2.join(dir, "config.json"), "utf8");
+    const parsed = JSON.parse(raw);
+    let migratedEmbeddings = parsed.customEmbeddings;
+    let migratedEmbeddingId = parsed.embeddingModelId;
+    if (parsed.customEmbedding && !migratedEmbeddings?.length) {
+      const legacy = parsed.customEmbedding;
+      migratedEmbeddings = [legacy];
+      if (migratedEmbeddingId === "custom") {
+        migratedEmbeddingId = `custom:${legacy.modelName}`;
+      }
+    }
+    const result = {
+      ...DEFAULT_CONFIG,
+      ...parsed,
+      embeddingModelId: migratedEmbeddingId ?? DEFAULT_CONFIG.embeddingModelId,
+      customEmbeddings: migratedEmbeddings,
+      chunking: { ...DEFAULT_CONFIG.chunking, ...parsed.chunking },
+      storeConfig: { ...parsed.storeConfig }
+    };
+    delete result["customEmbedding"];
+    return result;
+  } catch {
+    return DEFAULT_CONFIG;
+  }
+}
+async function writeConfig(config) {
+  const dir = await requireDataDir();
+  const next = { ...config, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  await fs2.writeFile(
+    path2.join(dir, "config.json"),
+    JSON.stringify(next, null, 2),
+    "utf8"
+  );
+  return next;
+}
+
+// ../../packages/core/src/documents-store.ts
+import { promises as fs3 } from "fs";
+import path3 from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+var writeChain2 = Promise.resolve();
+function serialize2(fn) {
+  const run = writeChain2.then(fn, fn);
+  writeChain2 = run.catch(() => {
+  });
+  return run;
+}
+async function docsPath(create) {
+  const dir = create ? await requireDataDir() : await getDataDir();
+  if (!dir) return null;
+  return path3.join(dir, "documents.json");
+}
+async function readDocuments() {
+  const file = await docsPath(false);
+  if (!file) return [];
+  try {
+    const raw = await fs3.readFile(file, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+async function writeAll(docs) {
+  const file = await docsPath(true);
+  if (!file) return;
+  await fs3.writeFile(file, JSON.stringify(docs, null, 2), "utf8");
+}
+function normalize(input) {
+  const content = input.content.trim();
+  return {
+    id: randomUUID2(),
+    title: input.title.trim() || "Untitled",
+    url: input.url,
+    source: input.source,
+    content,
+    charCount: content.length,
+    jobId: input.jobId,
+    metadata: input.metadata,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function addDocument(input) {
+  return serialize2(async () => {
+    const docs = await readDocuments();
+    const doc = normalize(input);
+    docs.push(doc);
+    await writeAll(docs);
+    return doc;
+  });
+}
+async function corpusStats() {
+  const docs = await readDocuments();
+  const chars = docs.reduce((sum, d) => sum + d.charCount, 0);
+  return {
+    docCount: docs.length,
+    charCount: chars,
+    bySource: docs.reduce((acc, d) => {
+      acc[d.source] = (acc[d.source] ?? 0) + 1;
+      return acc;
+    }, {})
+  };
+}
+
+// ../../packages/core/src/index-store.ts
+import { promises as fs4 } from "fs";
+import path4 from "path";
+var writeChain3 = Promise.resolve();
+function serialize3(fn) {
+  const run = writeChain3.then(fn, fn);
+  writeChain3 = run.catch(() => {
+  });
+  return run;
+}
+async function runPath(create) {
+  const dir = create ? await requireDataDir() : await getDataDir();
+  if (!dir) return null;
+  return path4.join(dir, "index-run.json");
+}
+async function readRun() {
+  const file = await runPath(false);
+  if (!file) return null;
+  try {
+    const raw = await fs4.readFile(file, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function writeRun(run) {
+  return serialize3(async () => {
+    const file = await runPath(true);
+    const next = { ...run, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    if (file) await fs4.writeFile(file, JSON.stringify(next, null, 2), "utf8");
+    return next;
+  });
+}
+function patchRun(patch) {
+  return serialize3(async () => {
+    const current = await readRun();
+    if (!current) return null;
+    const next = {
+      ...current,
+      ...patch,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const file = await runPath(true);
+    if (file) await fs4.writeFile(file, JSON.stringify(next, null, 2), "utf8");
+    return next;
+  });
+}
+
+// ../../packages/vector-stores/src/registry.ts
+var VECTOR_STORES = {
+  lancedb: {
+    id: "lancedb",
+    label: "LanceDB",
+    description: "Embedded, file-based vector DB. Runs fully local for dev or against LanceDB Cloud for production.",
+    runtime: "both",
+    installStatus: "installed",
+    docsUrl: "https://lancedb.github.io/lancedb/",
+    serverDependencies: {
+      "@lancedb/lancedb": "^0.30.0"
+    },
+    fields: [
+      {
+        key: "mode",
+        label: "Mode",
+        type: "select",
+        required: true,
+        defaultValue: "local",
+        help: "Local writes to disk on the toolkit host. Cloud connects to LanceDB Cloud.",
+        options: [
+          { label: "Local (on-disk)", value: "local" },
+          { label: "Cloud", value: "cloud" }
+        ]
+      },
+      {
+        key: "dbPath",
+        label: "Database path",
+        type: "path",
+        required: true,
+        defaultValue: "./.larkup/lancedb",
+        placeholder: "./.larkup/lancedb",
+        help: "Directory where the LanceDB tables are stored.",
+        showWhen: { key: "mode", equals: ["local"] }
+      },
+      {
+        key: "uri",
+        label: "Cloud URI",
+        type: "text",
+        required: true,
+        placeholder: "db://my-database",
+        help: "Your LanceDB Cloud database URI.",
+        showWhen: { key: "mode", equals: ["cloud"] }
+      },
+      {
+        key: "apiKey",
+        label: "API key",
+        type: "password",
+        required: true,
+        secret: true,
+        placeholder: "sk_...",
+        help: "LanceDB Cloud API key. Stored as an env var in the generated server.",
+        showWhen: { key: "mode", equals: ["cloud"] }
+      },
+      {
+        key: "tableName",
+        label: "Table name",
+        type: "text",
+        required: true,
+        defaultValue: "documents",
+        help: "The table that holds your embedded chunks."
+      }
+    ]
+  },
+  pinecone: {
+    id: "pinecone",
+    label: "Pinecone",
+    description: "Fully-managed cloud vector database. Cloud-only \u2014 requires an API key and an existing index.",
+    runtime: "cloud",
+    installStatus: "installed",
+    docsUrl: "https://docs.pinecone.io/",
+    serverDependencies: {
+      "@pinecone-database/pinecone": "^6.0.0"
+    },
+    fields: [
+      {
+        key: "apiKey",
+        label: "API key",
+        type: "password",
+        required: true,
+        secret: true,
+        placeholder: "pcsk_...",
+        help: "Pinecone API key. Stored as an env var in the generated server."
+      },
+      {
+        key: "indexName",
+        label: "Index name",
+        type: "text",
+        required: true,
+        placeholder: "rag-index",
+        help: "Name of the Pinecone index to upsert into / query. For hybrid/lexical mode this index must use the 'dotproduct' metric."
+      },
+      {
+        key: "namespace",
+        label: "Namespace",
+        type: "text",
+        required: false,
+        placeholder: "default",
+        help: "Optional namespace to isolate this dataset within the index."
+      },
+      {
+        key: "sparseModel",
+        label: "Sparse model",
+        type: "text",
+        required: true,
+        defaultValue: "pinecone-sparse-english-v0",
+        help: "Pinecone-hosted sparse model used to generate keyword vectors via the Inference API. Both dense and sparse vectors are stored in the same index.",
+        showWhenIndexType: ["lexical", "hybrid"]
+      }
+    ]
+  },
+  weaviate: {
+    id: "weaviate",
+    label: "Weaviate",
+    description: "Open-source AI-native vector database with built-in hybrid search, BM25, and multi-tenancy.",
+    runtime: "both",
+    installStatus: "coming-soon",
+    docsUrl: "https://weaviate.io/developers/weaviate",
+    serverDependencies: {
+      weaviate: "^3.0.0"
+    },
+    fields: [
+      {
+        key: "host",
+        label: "Host URL",
+        type: "text",
+        required: true,
+        placeholder: "https://my-cluster.weaviate.network",
+        help: "Weaviate Cloud URL or self-hosted host address."
+      },
+      {
+        key: "apiKey",
+        label: "API key",
+        type: "password",
+        required: false,
+        secret: true,
+        placeholder: "weaviate-api-key",
+        help: "Weaviate Cloud API key (optional for self-hosted)."
+      },
+      {
+        key: "className",
+        label: "Collection name",
+        type: "text",
+        required: true,
+        defaultValue: "Documents",
+        help: "The Weaviate collection (class) that holds your embedded chunks."
+      }
+    ]
+  },
+  qdrant: {
+    id: "qdrant",
+    label: "Qdrant",
+    description: "High-performance vector search engine with rich filtering, built for production-scale RAG.",
+    runtime: "both",
+    installStatus: "coming-soon",
+    docsUrl: "https://qdrant.tech/documentation/",
+    serverDependencies: {
+      "@qdrant/js-client-rest": "^1.9.0"
+    },
+    fields: [
+      {
+        key: "url",
+        label: "Host URL",
+        type: "text",
+        required: true,
+        placeholder: "http://localhost:6333",
+        help: "Qdrant server URL (local or Qdrant Cloud endpoint)."
+      },
+      {
+        key: "apiKey",
+        label: "API key",
+        type: "password",
+        required: false,
+        secret: true,
+        placeholder: "qdrant-api-key",
+        help: "Qdrant Cloud API key (leave blank for local)."
+      },
+      {
+        key: "collectionName",
+        label: "Collection name",
+        type: "text",
+        required: true,
+        defaultValue: "documents",
+        help: "Qdrant collection to upsert into and query."
+      }
+    ]
+  },
+  chroma: {
+    id: "chroma",
+    label: "Chroma",
+    description: "Open-source, developer-friendly embedding database. Great for rapid local prototyping.",
+    runtime: "both",
+    installStatus: "installable",
+    docsUrl: "https://docs.trychroma.com/",
+    serverDependencies: {
+      chromadb: "^1.9.0"
+    },
+    fields: [
+      {
+        key: "mode",
+        label: "Mode",
+        type: "select",
+        required: true,
+        defaultValue: "server",
+        help: "Server connects to a self-hosted Chroma instance. Cloud connects to Chroma Cloud.",
+        options: [
+          { label: "Server (Self-hosted)", value: "server" },
+          { label: "Cloud (Chroma Cloud)", value: "cloud" }
+        ]
+      },
+      {
+        key: "host",
+        label: "Server URL",
+        type: "text",
+        required: true,
+        placeholder: "http://localhost:8000",
+        defaultValue: "http://localhost:8000",
+        help: "Chroma server URL (local Docker or remote).",
+        showWhen: { key: "mode", equals: ["server"] }
+      },
+      {
+        key: "authToken",
+        label: "Auth Token",
+        type: "password",
+        required: false,
+        secret: true,
+        placeholder: "chroma-token",
+        help: "Optional static auth token for Chroma server.",
+        showWhen: { key: "mode", equals: ["server"] }
+      },
+      {
+        key: "apiKey",
+        label: "API Key",
+        type: "password",
+        required: true,
+        secret: true,
+        placeholder: "sk_...",
+        help: "Chroma Cloud API Key.",
+        showWhen: { key: "mode", equals: ["cloud"] }
+      },
+      {
+        key: "tenant",
+        label: "Tenant",
+        type: "text",
+        required: true,
+        defaultValue: "default_tenant",
+        help: "Tenant name for Chroma Cloud.",
+        showWhen: { key: "mode", equals: ["cloud"] }
+      },
+      {
+        key: "database",
+        label: "Database",
+        type: "text",
+        required: true,
+        defaultValue: "default_database",
+        help: "Database name for Chroma Cloud.",
+        showWhen: { key: "mode", equals: ["cloud"] }
+      },
+      {
+        key: "collectionName",
+        label: "Collection name",
+        type: "text",
+        required: true,
+        defaultValue: "documents",
+        help: "Chroma collection to store and retrieve embeddings."
+      }
+    ]
+  },
+  pgvector: {
+    id: "pgvector",
+    label: "pgvector",
+    description: "PostgreSQL extension for vector similarity search. Self-host vectors alongside your relational data.",
+    runtime: "both",
+    installStatus: "coming-soon",
+    docsUrl: "https://github.com/pgvector/pgvector",
+    serverDependencies: {
+      pg: "^8.11.0",
+      pgvector: "^0.2.0"
+    },
+    fields: [
+      {
+        key: "connectionString",
+        label: "Connection string",
+        type: "password",
+        required: true,
+        secret: true,
+        placeholder: "postgresql://user:pass@localhost:5432/db",
+        help: "Full PostgreSQL connection string."
+      },
+      {
+        key: "tableName",
+        label: "Table name",
+        type: "text",
+        required: true,
+        defaultValue: "embeddings",
+        help: "The table used to store vector embeddings. Created automatically if absent."
+      }
+    ]
+  },
+  supabase: {
+    id: "supabase",
+    label: "Supabase",
+    description: "Postgres-backed vector store via the pgvector extension with Supabase's managed infrastructure.",
+    runtime: "cloud",
+    installStatus: "coming-soon",
+    docsUrl: "https://supabase.com/docs/guides/ai",
+    serverDependencies: {
+      "@supabase/supabase-js": "^2.43.0"
+    },
+    fields: [
+      {
+        key: "url",
+        label: "Project URL",
+        type: "text",
+        required: true,
+        placeholder: "https://xyz.supabase.co",
+        help: "Your Supabase project URL."
+      },
+      {
+        key: "serviceKey",
+        label: "Service role key",
+        type: "password",
+        required: true,
+        secret: true,
+        placeholder: "eyJhbGci...",
+        help: "Supabase service_role key (not the anon key). Stored as an env var."
+      },
+      {
+        key: "tableName",
+        label: "Table name",
+        type: "text",
+        required: true,
+        defaultValue: "documents",
+        help: "Supabase table with a vector column for embeddings."
+      }
+    ]
+  }
+};
+var VECTOR_STORE_LIST = Object.values(VECTOR_STORES);
+function getVectorStore(id) {
+  return VECTOR_STORES[id];
+}
+
+// ../../packages/core/src/embeddings/registry.ts
+var EMBEDDING_MODELS = [
+  // ── OpenAI ──────────────────────────────────────────────────────────
+  {
+    id: "openai/text-embedding-3-small",
+    label: "text-embedding-3-small",
+    provider: "openai",
+    dimensions: 1536,
+    maxInputTokens: 8191,
+    description: "Fast, cheap, strong general-purpose default."
+  },
+  {
+    id: "openai/text-embedding-3-large",
+    label: "text-embedding-3-large",
+    provider: "openai",
+    dimensions: 3072,
+    maxInputTokens: 8191,
+    description: "Highest quality OpenAI embeddings, larger vectors."
+  },
+  {
+    id: "openai/text-embedding-ada-002",
+    label: "text-embedding-ada-002",
+    provider: "openai",
+    dimensions: 1536,
+    maxInputTokens: 8191,
+    description: "Legacy model \u2014 kept for backward compatibility."
+  },
+  // ── Google ───────────────────────────────────────────────────────────
+  {
+    id: "google/text-embedding-004",
+    label: "text-embedding-004",
+    provider: "google",
+    dimensions: 768,
+    maxInputTokens: 2048,
+    description: "Compact, high-quality embeddings from Google."
+  },
+  {
+    id: "google/gemini-embedding-exp-03-07",
+    label: "gemini-embedding-exp-03-07",
+    provider: "google",
+    dimensions: 3072,
+    maxInputTokens: 8192,
+    description: "State-of-the-art Gemini embeddings with flexible dimensions."
+  },
+  // ── Cohere ───────────────────────────────────────────────────────────
+  {
+    id: "cohere/embed-english-v3.0",
+    label: "embed-english-v3.0",
+    provider: "cohere",
+    dimensions: 1024,
+    maxInputTokens: 512,
+    description: "Tuned for retrieval; great for English-heavy corpora."
+  },
+  {
+    id: "cohere/embed-multilingual-v3.0",
+    label: "embed-multilingual-v3.0",
+    provider: "cohere",
+    dimensions: 1024,
+    maxInputTokens: 512,
+    description: "100+ language multilingual retrieval embeddings."
+  },
+  // ── Voyage AI ────────────────────────────────────────────────────────
+  {
+    id: "voyage/voyage-3",
+    label: "voyage-3",
+    provider: "voyage",
+    dimensions: 1024,
+    maxInputTokens: 32e3,
+    description: "Voyage's best general-purpose retrieval model."
+  },
+  {
+    id: "voyage/voyage-3-lite",
+    label: "voyage-3-lite",
+    provider: "voyage",
+    dimensions: 512,
+    maxInputTokens: 32e3,
+    description: "Optimized for latency and cost with strong performance."
+  },
+  {
+    id: "voyage/voyage-code-3",
+    label: "voyage-code-3",
+    provider: "voyage",
+    dimensions: 1024,
+    maxInputTokens: 32e3,
+    description: "Specialized for code retrieval tasks."
+  },
+  // ── Mistral ──────────────────────────────────────────────────────────
+  {
+    id: "mistral/mistral-embed",
+    label: "mistral-embed",
+    provider: "mistral",
+    dimensions: 1024,
+    maxInputTokens: 8192,
+    description: "Mistral's efficient embedding model for retrieval."
+  },
+  // ── Jina AI ──────────────────────────────────────────────────────────
+  {
+    id: "jina/jina-embeddings-v3",
+    label: "jina-embeddings-v3",
+    provider: "jina",
+    dimensions: 1024,
+    maxInputTokens: 8192,
+    description: "Multilingual, task-specific embeddings from Jina AI."
+  },
+  {
+    id: "jina/jina-clip-v2",
+    label: "jina-clip-v2",
+    provider: "jina",
+    dimensions: 1024,
+    maxInputTokens: 8192,
+    description: "Multimodal embeddings for text and images."
+  },
+  // ── Nomic ────────────────────────────────────────────────────────────
+  {
+    id: "nomic/nomic-embed-text-v1.5",
+    label: "nomic-embed-text-v1.5",
+    provider: "nomic",
+    dimensions: 768,
+    maxInputTokens: 8192,
+    description: "Open-source, highly capable text embeddings."
+  }
+];
+function getEmbeddingModel(id) {
+  return EMBEDDING_MODELS.find((m) => m.id === id);
+}
+
+// src/lib/scope.ts
+async function inServerScope(serverId, fn) {
+  if (serverId) {
+    const found = await runWithServer(serverId, () => getActiveServer());
+    if (!found) log.error(`No server with id "${serverId}".`);
+    return runWithServer(serverId, fn);
+  }
+  return fn();
+}
+async function requireActive() {
+  const server = await getActiveServer();
+  if (!server) {
+    log.error('No active server. Create one first with: larkup init "my-rag"');
+  }
+  return server;
+}
+
+// src/commands/config.ts
+async function configCommand(options) {
+  await inServerScope(options.server, async () => {
+    const server = await requireActive();
+    const config = await readConfig();
+    const stats = await corpusStats();
+    const run = await readRun();
+    const store = getVectorStore(config.vectorStore);
+    const model = getEmbeddingModel(config.embeddingModelId);
+    log.bold(server.name);
+    log.info(`  project    ${config.projectName}`);
+    log.info(`  model      ${model?.label ?? config.embeddingModelId}`);
+    log.info(`  store      ${store?.label ?? config.vectorStore}`);
+    log.info(`  index      ${config.indexType}`);
+    log.info(`  chunking   ${config.chunking.chunkSize}/${config.chunking.chunkOverlap} (${config.chunking.strategy})`);
+    log.info(`  top-k      ${config.topK}`);
+    log.info(`  corpus     ${stats.docCount} docs \xB7 ${stats.charCount.toLocaleString()} chars`);
+    log.info(`  indexed    ${run?.status === "completed" ? `yes (${run.totalChunks} chunks)` : "no"}`);
+  });
+}
+
+// src/commands/add-doc.ts
+import { promises as fs5 } from "fs";
+import path5 from "path";
+async function addDocCommand(options) {
+  await inServerScope(options.server, async () => {
+    await requireActive();
+    let content;
+    let title = options.title;
+    if (options.file) {
+      const abs = path5.isAbsolute(options.file) ? options.file : path5.join(process.cwd(), options.file);
+      try {
+        content = await fs5.readFile(abs, "utf8");
+      } catch {
+        log.error(`Could not read file: ${abs}`);
+      }
+      if (!title) title = path5.basename(options.file);
+    } else if (options.text) {
+      content = options.text;
+    } else {
+      log.error("Provide --file <path> or --text <string>.");
+    }
+    if (!content.trim()) log.error("The document content is empty.");
+    const doc = await addDocument({
+      title: title ?? "Untitled",
+      content,
+      source: options.file ? "upload" : "paste",
+      url: options.url
+    });
+    log.success(`Added "${doc.title}" (${doc.charCount.toLocaleString()} chars)`);
+    const stats = await corpusStats();
+    log.dim(`  corpus now has ${stats.docCount} document(s)`);
+  });
+}
+
+// ../../packages/core/src/indexing/indexer.ts
+import { randomUUID as randomUUID3 } from "crypto";
+
+// ../../packages/core/src/indexing/chunker.ts
+var CHARS_PER_TOKEN = 4;
+function tokensToChars(tokens) {
+  return Math.max(1, Math.round(tokens * CHARS_PER_TOKEN));
+}
+var RECURSIVE_SEPARATORS = ["\n\n", "\n", ". ", "? ", "! ", " "];
+function splitRecursive(text4, maxChars) {
+  if (text4.length <= maxChars) return [text4];
+  for (const sep of RECURSIVE_SEPARATORS) {
+    if (!text4.includes(sep)) continue;
+    const parts = text4.split(sep);
+    const out = [];
+    let buf = "";
+    for (const part of parts) {
+      const piece = buf ? buf + sep + part : part;
+      if (piece.length <= maxChars) {
+        buf = piece;
+      } else {
+        if (buf) out.push(buf);
+        if (part.length > maxChars) out.push(...splitRecursive(part, maxChars));
+        else buf = part;
+      }
+    }
+    if (buf) out.push(buf);
+    if (out.length > 1) return out;
+  }
+  return hardSlice(text4, maxChars);
+}
+function splitSentences(text4, maxChars) {
+  const sentences = text4.match(/[^.!?]+[.!?]+[\s]*|[^.!?]+$/g) ?? [text4];
+  const out = [];
+  let buf = "";
+  for (const s of sentences) {
+    const piece = buf + s;
+    if (piece.length <= maxChars) buf = piece;
+    else {
+      if (buf) out.push(buf.trim());
+      buf = s.length > maxChars ? "" : s;
+      if (s.length > maxChars) out.push(...hardSlice(s, maxChars));
+    }
+  }
+  if (buf.trim()) out.push(buf.trim());
+  return out;
+}
+function hardSlice(text4, maxChars) {
+  const out = [];
+  for (let i = 0; i < text4.length; i += maxChars) {
+    out.push(text4.slice(i, i + maxChars));
+  }
+  return out;
+}
+function applyOverlap(chunks, overlapChars) {
+  if (overlapChars <= 0 || chunks.length <= 1) return chunks;
+  return chunks.map((chunk, i) => {
+    if (i === 0) return chunk;
+    const tail = chunks[i - 1].slice(-overlapChars);
+    return `${tail} ${chunk}`.trim();
+  });
+}
+function chunkDocument(doc, params) {
+  const maxChars = tokensToChars(params.chunkSize);
+  const overlapChars = tokensToChars(params.chunkOverlap);
+  const text4 = doc.content.trim();
+  if (!text4) return [];
+  let raw;
+  switch (params.strategy) {
+    case "sentence":
+      raw = splitSentences(text4, maxChars);
+      break;
+    case "fixed":
+      raw = hardSlice(text4, maxChars);
+      break;
+    case "recursive":
+    default:
+      raw = splitRecursive(text4, maxChars);
+      break;
+  }
+  const withOverlap = applyOverlap(
+    raw.map((c) => c.trim()).filter(Boolean),
+    overlapChars
+  );
+  return withOverlap.map((textChunk, index) => ({
+    id: `${doc.id}#${index}`,
+    documentId: doc.id,
+    index,
+    text: textChunk,
+    title: doc.title,
+    url: doc.url,
+    source: doc.source,
+    charCount: textChunk.length,
+    metadata: doc.metadata
+  }));
+}
+function chunkCorpus(docs, params) {
+  return docs.flatMap((d) => chunkDocument(d, params));
+}
+
+// ../../packages/core/src/indexing/embedder.ts
+import { embed, embedMany } from "ai";
+
+// ../../packages/core/src/embeddings/providers.ts
+import { createOpenAI } from "@ai-sdk/openai";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { createDeepSeek } from "@ai-sdk/deepseek";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { createCohere } from "@ai-sdk/cohere";
+import { createMistral } from "@ai-sdk/mistral";
+import { createGateway } from "@ai-sdk/gateway";
+function getAIModel(config) {
+  let modelName = config.embeddingModelId;
+  if (modelName.includes("/")) {
+    modelName = modelName.split("/")[1];
+  }
+  if (config.embeddingModelId.startsWith("custom:")) {
+    const customName = config.embeddingModelId.slice("custom:".length);
+    const custom = (config.customEmbeddings ?? []).find(
+      (m) => m.modelName === customName
+    );
+    if (custom) {
+      const customProvider = createOpenAICompatible({
+        name: "custom_provider",
+        baseURL: custom.baseUrl,
+        apiKey: custom.apiKey || config.embeddingApiKey || void 0
+      });
+      return customProvider.embeddingModel(custom.modelName);
+    }
+  }
+  if (config.embeddingProvider === "deepseek") {
+    const deepseek = createDeepSeek({
+      apiKey: config.embeddingApiKey || void 0
+    });
+    return deepseek.embeddingModel(modelName);
+  }
+  if (config.embeddingProvider === "google") {
+    const google = createGoogleGenerativeAI({
+      apiKey: config.embeddingApiKey || void 0
+    });
+    return google.embedding(modelName);
+  }
+  if (config.embeddingProvider === "cohere") {
+    const cohere = createCohere({
+      apiKey: config.embeddingApiKey || void 0
+    });
+    return cohere.embedding(modelName);
+  }
+  if (config.embeddingProvider === "mistral") {
+    const mistral = createMistral({
+      apiKey: config.embeddingApiKey || void 0
+    });
+    return mistral.embedding(modelName);
+  }
+  if (config.embeddingProvider === "vercel_ai_gateway") {
+    const gateway = createGateway({
+      apiKey: config.embeddingApiKey || void 0
+    });
+    return gateway.embedding(config.embeddingModelId);
+  }
+  const openai = createOpenAI({
+    apiKey: config.embeddingApiKey || void 0
+  });
+  return openai.embedding(modelName);
+}
+
+// ../../packages/core/src/indexing/embedder.ts
+async function embedTexts(config, texts) {
+  if (texts.length === 0) return { embeddings: [], dimensions: 0 };
+  const model = getAIModel(config);
+  const { embeddings } = await embedMany({
+    model,
+    values: texts
+  });
+  return {
+    embeddings,
+    dimensions: embeddings[0]?.length ?? 0
+  };
+}
+async function embedQuery(config, text4) {
+  const model = getAIModel(config);
+  const { embedding } = await embed({ model, value: text4 });
+  return embedding;
+}
+function expectedDimensions(config) {
+  if (config.embeddingModelId.startsWith("custom:")) {
+    const customName = config.embeddingModelId.slice("custom:".length);
+    const custom = (config.customEmbeddings ?? []).find(
+      (m) => m.modelName === customName
+    );
+    if (custom) return custom.dimensions;
+  }
+  return getEmbeddingModel(config.embeddingModelId)?.dimensions ?? 0;
+}
+
+// ../../packages/vector-stores/src/factory.ts
+async function createAdapter(config, onRateLimit) {
+  switch (config.vectorStore) {
+    case "pinecone": {
+      const { PineconeAdapter } = await import("./pinecone-YZHFLCKI.js");
+      return new PineconeAdapter({
+        apiKey: config.storeConfig.apiKey,
+        indexName: config.storeConfig.indexName,
+        namespace: config.storeConfig.namespace,
+        sparseModel: config.storeConfig.sparseModel,
+        indexType: config.indexType,
+        onRateLimit
+      });
+    }
+    case "chroma": {
+      const { ChromaAdapter } = await import("./chroma-GIDEKUIH.js");
+      return new ChromaAdapter({
+        mode: config.storeConfig.mode,
+        host: config.storeConfig.host,
+        authToken: config.storeConfig.authToken,
+        apiKey: config.storeConfig.apiKey,
+        tenant: config.storeConfig.tenant,
+        database: config.storeConfig.database,
+        collectionName: config.storeConfig.collectionName,
+        indexType: config.indexType
+      });
+    }
+    case "lancedb":
+    default: {
+      const { LanceDBAdapter } = await import("./lancedb-E2JLQERV.js");
+      return new LanceDBAdapter({
+        mode: config.storeConfig.mode,
+        dbPath: config.storeConfig.dbPath,
+        uri: config.storeConfig.uri,
+        apiKey: config.storeConfig.apiKey,
+        tableName: config.storeConfig.tableName
+      });
+    }
+  }
+}
+
+// ../../packages/core/src/indexing/indexer.ts
+var EMBED_BATCH = 64;
+async function createRun(config) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const run = {
+    id: randomUUID3(),
+    status: "chunking",
+    embeddingModelId: config.embeddingModelId,
+    vectorStore: config.vectorStore,
+    indexType: config.indexType,
+    totalChunks: 0,
+    processedChunks: 0,
+    docCount: 0,
+    dimensions: expectedDimensions(config),
+    startedAt: now,
+    updatedAt: now
+  };
+  return writeRun(run);
+}
+async function runIndexer(runId, config, previousRun = null) {
+  const started = Date.now();
+  try {
+    let docs = await readDocuments();
+    if (previousRun && previousRun.status === "completed") {
+      docs = docs.filter((d) => d.createdAt > previousRun.startedAt);
+    }
+    if (docs.length === 0) {
+      if (previousRun) {
+        await patchRun({
+          status: "completed",
+          docCount: 0,
+          finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          durationMs: Date.now() - started
+        });
+      } else {
+        await patchRun({
+          status: "failed",
+          error: "The corpus is empty. Load documents before indexing.",
+          finishedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+      return;
+    }
+    await patchRun({ status: "chunking", docCount: docs.length });
+    const chunks = chunkCorpus(docs, config.chunking);
+    if (chunks.length === 0) {
+      if (previousRun) {
+        await patchRun({
+          status: "completed",
+          finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          durationMs: Date.now() - started
+        });
+      } else {
+        await patchRun({
+          status: "failed",
+          error: "No chunks were produced from the corpus.",
+          finishedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+      return;
+    }
+    await patchRun({ totalChunks: chunks.length, status: "embedding" });
+    const adapter = await createAdapter(config, async (waitSecs, attempt) => {
+      await patchRun({
+        warning: `Sparse model rate-limited \u2014 pausing ${waitSecs}s (retry ${attempt}/${3})\u2026`
+      });
+    });
+    let dimensions = expectedDimensions(config);
+    let processed = 0;
+    let initialized = false;
+    let currentDelayMs = 0;
+    for (let i = 0; i < chunks.length; i += EMBED_BATCH) {
+      const batch = chunks.slice(i, i + EMBED_BATCH);
+      if (currentDelayMs > 0) {
+        await new Promise((r) => setTimeout(r, currentDelayMs));
+      }
+      await patchRun({ status: "embedding" });
+      let attempt = 1;
+      let batchEmbeddings = [];
+      let batchDimensions = dimensions;
+      while (true) {
+        try {
+          const { embeddings, dimensions: dim } = await embedTexts(
+            config,
+            batch.map((c) => c.text)
+          );
+          batchEmbeddings = embeddings;
+          if (dim) batchDimensions = dim;
+          break;
+        } catch (err) {
+          const is429 = err?.status === 429 || err?.statusCode === 429 || String(err?.message ?? "").includes("429") || String(err?.message ?? "").includes("rate limit") || String(err?.message ?? "").toLowerCase().includes("too many requests");
+          if (is429 && attempt <= 3) {
+            const waitSecs = attempt * 10;
+            await patchRun({
+              warning: `Dense model rate-limited \u2014 pausing ${waitSecs}s (retry ${attempt}/${3})\u2026`
+            });
+            await new Promise((r) => setTimeout(r, waitSecs * 1e3));
+            currentDelayMs = Math.max(currentDelayMs, 2e3);
+            attempt++;
+          } else {
+            throw err;
+          }
+        }
+      }
+      dimensions = batchDimensions;
+      if (!initialized) {
+        await adapter.init(dimensions);
+        if (!previousRun) {
+          await adapter.reset();
+        }
+        initialized = true;
+        await patchRun({ dimensions });
+      }
+      const records = batch.map((c, j) => ({
+        id: c.id,
+        vector: batchEmbeddings[j],
+        text: c.text,
+        title: c.title,
+        url: c.url,
+        source: c.source,
+        documentId: c.documentId,
+        chunkIndex: c.index,
+        metadata: c.metadata
+      }));
+      await patchRun({ status: "upserting" });
+      let upsertAttempt = 1;
+      while (true) {
+        try {
+          await adapter.upsert(records);
+          break;
+        } catch (err) {
+          const is429 = err?.status === 429 || err?.statusCode === 429 || String(err?.message ?? "").includes("429") || String(err?.message ?? "").includes("rate limit") || String(err?.message ?? "").toLowerCase().includes("too many requests") || String(err?.message ?? "").includes("RESOURCE_EXHAUSTED");
+          if (is429 && upsertAttempt <= 3) {
+            const waitSecs = upsertAttempt * 10;
+            await patchRun({
+              warning: `Vector store rate-limited \u2014 pausing ${waitSecs}s (retry ${upsertAttempt}/${3})\u2026`
+            });
+            await new Promise((r) => setTimeout(r, waitSecs * 1e3));
+            currentDelayMs = Math.max(currentDelayMs, 2e3);
+            upsertAttempt++;
+          } else {
+            throw err;
+          }
+        }
+      }
+      processed += batch.length;
+      await patchRun({ processedChunks: processed, status: "embedding", warning: void 0 });
+    }
+    await patchRun({
+      status: "completed",
+      processedChunks: processed,
+      dimensions,
+      finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      durationMs: Date.now() - started
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Indexing failed unexpectedly.";
+    await patchRun({
+      status: "failed",
+      error: message,
+      finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      durationMs: Date.now() - started
+    });
+  }
+}
+
+// src/lib/keys.ts
+import * as p2 from "@clack/prompts";
+async function ensureApiKey(config, keyType = "embedding") {
+  const envKey = keyType === "embedding" ? process.env.OPENAI_API_KEY : process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY;
+  const currentKey = keyType === "embedding" ? config.embeddingApiKey : config.chatApiKey || config.embeddingApiKey;
+  if (envKey && !currentKey) {
+    return;
+  }
+  if (!currentKey) {
+    log.warn(`Your ${keyType} API key is not configured.`);
+    const key = await p2.text({
+      message: `Please enter your ${config.embeddingProvider} API key:`,
+      placeholder: "sk-..."
+    });
+    if (p2.isCancel(key)) {
+      log.error("Canceled.");
+      process.exit(1);
+    }
+    if (key && typeof key === "string" && key.trim()) {
+      if (keyType === "embedding") {
+        config.embeddingApiKey = key.trim();
+      } else {
+        config.chatApiKey = key.trim();
+      }
+      await writeConfig(config);
+      log.success(`Saved API key to local configuration.`);
+    } else {
+      log.error("API Key is required to proceed.");
+      process.exit(1);
+    }
+  }
+}
+
+// src/commands/index-cmd.ts
+async function indexCommand(options) {
+  await inServerScope(options.server, async () => {
+    await requireActive();
+    const config = await readConfig();
+    const docs = await readDocuments();
+    if (docs.length === 0) {
+      log.error("Corpus is empty. Add documents first: larkup add-doc --file <path>");
+    }
+    if (!getEmbeddingModel(config.embeddingModelId)) {
+      log.error(`Unknown embedding model "${config.embeddingModelId}". Set it in the Configure stage.`);
+    }
+    await ensureApiKey(config, "embedding");
+    log.info(log.fmt.cyan(`Indexing ${docs.length} document(s) into ${config.vectorStore}\u2026`));
+    const run = await createRun(config);
+    const s = prompts.spinner();
+    s.start("Starting indexer...");
+    let done = false;
+    const timer = setInterval(async () => {
+      const r = await readRun();
+      if (!r || done) return;
+      if (r.totalChunks > 0) {
+        s.message(`${r.status.padEnd(10)} ${r.processedChunks}/${r.totalChunks} chunks`);
+      } else {
+        s.message(`${r.status}\u2026`);
+      }
+    }, 400);
+    try {
+      await runIndexer(run.id, config);
+    } catch (e) {
+      done = true;
+      clearInterval(timer);
+      s.stop("Indexing failed.");
+      log.error(e.message || "Indexing failed");
+    }
+    done = true;
+    clearInterval(timer);
+    const final = await readRun();
+    if (final?.status === "completed") {
+      s.stop(`Indexed ${final.totalChunks} chunks (${final.dimensions}-dim) in ${((final.durationMs ?? 0) / 1e3).toFixed(1)}s`);
+      log.success("Indexing complete!");
+    } else {
+      s.stop("Indexing failed.");
+      log.error(final?.error ?? "Indexing failed.");
+    }
+  });
+}
+
+// src/commands/generate.ts
+import { promises as fs7 } from "fs";
+import path7 from "path";
+
+// ../../packages/core/src/generator/generate-server.ts
+function lang(path9) {
+  if (path9.endsWith(".json")) return "json";
+  if (path9.endsWith(".mjs") || path9.endsWith(".js")) return "javascript";
+  if (path9.endsWith(".md")) return "markdown";
+  if (path9.endsWith("Dockerfile")) return "dockerfile";
+  if (path9.endsWith(".yml") || path9.endsWith(".yaml")) return "yaml";
+  return "text";
+}
+function lancedbStore() {
+  return `import * as lancedb from "@lancedb/lancedb"
+import path from "node:path"
+
+const MODE = process.env.LANCEDB_MODE || "local"
+// On Vercel (and other serverless platforms), /var/task is read-only.
+// Fall back to /tmp which is writable, though ephemeral per invocation.
+const IS_SERVERLESS = !!process.env.VERCEL || !!process.env.AWS_LAMBDA_FUNCTION_NAME
+const DEFAULT_DB_PATH = IS_SERVERLESS ? "/tmp/lancedb" : "./.larkup/lancedb"
+const DB_PATH = process.env.LANCEDB_PATH || DEFAULT_DB_PATH
+const URI = process.env.LANCEDB_URI || ""
+const API_KEY = process.env.LANCEDB_API_KEY || ""
+const TABLE = process.env.LANCEDB_TABLE || "documents"
+
+if (IS_SERVERLESS && MODE !== "cloud") {
+  console.warn("[LanceDB] Running on serverless \u2014 using /tmp/lancedb. Data will NOT persist between invocations. Use LanceDB Cloud for production.")
+}
+
+let _table = null
+
+async function table() {
+  if (_table) return _table
+  let conn
+  if (MODE === "cloud") {
+    if (!URI || !API_KEY) {
+      throw new Error("LanceDB Cloud needs LANCEDB_URI and LANCEDB_API_KEY.")
+    }
+    conn = await lancedb.connect(URI, { apiKey: API_KEY })
+  } else {
+    const abs = path.isAbsolute(DB_PATH) ? DB_PATH : path.join(process.cwd(), DB_PATH)
+    conn = await lancedb.connect(abs)
+  }
+
+  _table = await conn.openTable(TABLE)
+  return _table
+}
+
+export async function query(vector, topK) {
+  const t = await table()
+  const rows = await t.search(vector).limit(topK).toArray()
+  return rows.map((row) => ({
+    id: row.id,
+    score: typeof row._distance === "number" ? 1 / (1 + row._distance) : 0,
+    text: row.text,
+    title: row.title,
+    url: row.url || undefined,
+    documentId: row.documentId,
+  }))
+}
+
+export async function list({ page = 1, limit = 20 } = {}) {
+  const t = await table()
+  // Fetch all rows to get total count, then slice for the page.
+  // We explicitly exclude the "vector" column to avoid memory bloat and Rust panics on full scans.
+  const allRows = await t.query().select(["id", "text", "title", "url", "documentId"]).toArray()
+  const total = allRows.length
+  const start = (page - 1) * limit
+  const pageRows = allRows.slice(start, start + limit)
+  return {
+    documents: pageRows.map((row) => ({
+      id: row.id,
+      text: row.text,
+      title: row.title,
+      url: row.url || undefined,
+      documentId: row.documentId,
+    })),
+    total,
+    page,
+    limit,
+    totalPages: Math.ceil(total / limit),
+  }
+}
+
+export async function get(id) {
+  const t = await table()
+  const rows = await t.query().filter(\`id = '\${id}'\`).limit(1).toArray()
+  if (!rows.length) return null;
+  const row = rows[0];
+  return { id: row.id, text: row.text, title: row.title, url: row.url || undefined, documentId: row.documentId }
+}
+
+export async function add(docs) {
+  const t = await table()
+  await t.add(docs)
+  return { success: true }
+}
+
+export async function remove(id) {
+  const t = await table()
+  await t.delete(\`id = '\${id}'\`)
+  return { success: true }
+}
+
+export async function update(id, doc) {
+  const t = await table()
+  await t.delete(\`id = '\${id}'\`)
+  await t.add([doc])
+  return { success: true }
+}
+`;
+}
+function pineconeStore() {
+  return `import { Pinecone } from "@pinecone-database/pinecone"
+
+const API_KEY = process.env.PINECONE_API_KEY || ""
+const INDEX = process.env.PINECONE_INDEX || ""
+const NAMESPACE = process.env.PINECONE_NAMESPACE || "default"
+
+if (!API_KEY) throw new Error("PINECONE_API_KEY is required.")
+if (!INDEX) throw new Error("PINECONE_INDEX is required.")
+
+const pc = new Pinecone({ apiKey: API_KEY })
+const ns = pc.index(INDEX).namespace(NAMESPACE)
+
+export async function query(vector, topK) {
+  const res = await ns.query({ vector, topK, includeMetadata: true })
+  return (res.matches ?? []).map((m) => {
+    const meta = m.metadata ?? {}
+    return {
+      id: m.id,
+      score: m.score ?? 0,
+      text: meta.text ?? "",
+      title: meta.title ?? "Untitled",
+      url: meta.url || undefined,
+      documentId: meta.documentId ?? "",
+    }
+  })
+}
+
+export async function list({ page = 1, limit = 20 } = {}) {
+  // Collect all IDs via Pinecone's cursor-based pagination
+  const allIds = []
+  let paginationToken = undefined
+  do {
+    const res = await ns.listPaginated({ limit: 100, paginationToken })
+    if (res.vectors) allIds.push(...res.vectors.map(v => v.id))
+    paginationToken = res.pagination?.next
+  } while (paginationToken)
+
+  const total = allIds.length
+  const start = (page - 1) * limit
+  const pageIds = allIds.slice(start, start + limit)
+
+  if (pageIds.length === 0) {
+    return { documents: [], total, page, limit, totalPages: Math.ceil(total / limit) }
+  }
+
+  const fetched = await ns.fetch(pageIds)
+  const documents = Object.values(fetched.records).map(r => {
+    const meta = r.metadata ?? {}
+    return {
+      id: r.id,
+      text: meta.text ?? "",
+      title: meta.title ?? "Untitled",
+      url: meta.url || undefined,
+      documentId: meta.documentId ?? "",
+    }
+  })
+  return { documents, total, page, limit, totalPages: Math.ceil(total / limit) }
+}
+
+export async function get(id) {
+  const fetched = await ns.fetch([id])
+  const r = fetched.records[id]
+  if (!r) return null;
+  const meta = r.metadata ?? {}
+  return {
+    id: r.id,
+    text: meta.text ?? "",
+    title: meta.title ?? "Untitled",
+    url: meta.url || undefined,
+    documentId: meta.documentId ?? "",
+  }
+}
+
+export async function add(docs) {
+  const vectors = docs.map(d => ({
+    id: d.id,
+    values: d.vector,
+    metadata: {
+      text: d.text,
+      title: d.title,
+      url: d.url || "",
+      documentId: d.documentId,
+    }
+  }))
+  await ns.upsert(vectors)
+  return { success: true }
+}
+
+export async function remove(id) {
+  await ns.deleteOne(id)
+  return { success: true }
+}
+
+export async function update(id, doc) {
+  await ns.update({
+    id,
+    values: doc.vector,
+    setMetadata: {
+      text: doc.text,
+      title: doc.title,
+      url: doc.url || "",
+      documentId: doc.documentId,
+    }
+  })
+  return { success: true }
+}
+`;
+}
+function embedSource(config) {
+  let imports = `import { embed } from "ai"
+`;
+  let init = ``;
+  if (config.embeddingModelId.startsWith("custom:")) {
+    const customName = config.embeddingModelId.slice("custom:".length);
+    const custom = (config.customEmbeddings ?? []).find(
+      (m) => m.modelName === customName
+    );
+    imports += `import { createOpenAICompatible } from "@ai-sdk/openai-compatible"
+`;
+    init = `const provider = createOpenAICompatible({
+  name: "custom_provider",
+  baseURL: process.env.EMBEDDING_BASE_URL || ${JSON.stringify(custom?.baseUrl || "")},
+  apiKey: process.env.EMBEDDING_API_KEY
+})
+const MODEL = provider.embedding(process.env.EMBEDDING_MODEL || ${JSON.stringify(custom?.modelName || "")})`;
+  } else if (config.embeddingProvider === "deepseek") {
+    imports += `import { createDeepSeek } from "@ai-sdk/deepseek"
+`;
+    init = `const provider = createDeepSeek({
+  apiKey: process.env.EMBEDDING_API_KEY
+})
+const MODEL = provider.embedding(process.env.EMBEDDING_MODEL || ${JSON.stringify(config.embeddingModelId)})`;
+  } else if (config.embeddingProvider === "google") {
+    imports += `import { createGoogleGenerativeAI } from "@ai-sdk/google"
+`;
+    init = `const provider = createGoogleGenerativeAI({
+  apiKey: process.env.EMBEDDING_API_KEY
+})
+const MODEL = provider.embedding(process.env.EMBEDDING_MODEL || ${JSON.stringify(config.embeddingModelId)})`;
+  } else if (config.embeddingProvider === "cohere") {
+    imports += `import { createCohere } from "@ai-sdk/cohere"
+`;
+    init = `const provider = createCohere({
+  apiKey: process.env.EMBEDDING_API_KEY
+})
+const MODEL = provider.embedding(process.env.EMBEDDING_MODEL || ${JSON.stringify(config.embeddingModelId)})`;
+  } else if (config.embeddingProvider === "mistral") {
+    imports += `import { createMistral } from "@ai-sdk/mistral"
+`;
+    init = `const provider = createMistral({
+  apiKey: process.env.EMBEDDING_API_KEY
+})
+const MODEL = provider.embedding(process.env.EMBEDDING_MODEL || ${JSON.stringify(config.embeddingModelId)})`;
+  } else if (config.embeddingProvider === "vercel_ai_gateway") {
+    imports += `import { createGateway } from "@ai-sdk/gateway"
+`;
+    init = `const gateway = createGateway({
+  apiKey: process.env.EMBEDDING_API_KEY
+})
+const MODEL = gateway.embedding(process.env.EMBEDDING_MODEL || ${JSON.stringify(config.embeddingModelId)})`;
+  } else {
+    imports += `import { createOpenAI } from "@ai-sdk/openai"
+`;
+    init = `const provider = createOpenAI({
+  apiKey: process.env.EMBEDDING_API_KEY
+})
+const modelName = process.env.EMBEDDING_MODEL || ${JSON.stringify(config.embeddingModelId)};
+const MODEL = provider.embedding(modelName.includes("/") ? modelName.split("/")[1] : modelName)`;
+  }
+  return `${imports}
+${init}
+
+export async function embedQuery(text) {
+  const { embedding } = await embed({ model: MODEL, value: text })
+  return embedding
+}
+`;
+}
+function serverSource(config) {
+  return `import { createServer } from "node:http"
+import { embedQuery } from "./embed.mjs"
+import * as store from "./store.mjs"
+import fs from "node:fs"
+import path from "node:path"
+import * as cheerio from "cheerio"
+
+const PORT = process.env.PORT || 8080
+const DEFAULT_TOP_K = Number(process.env.TOP_K || ${config.topK})
+
+console.log('[${config.projectName}] SERVER_API_KEY:', process.env.SERVER_API_KEY ? 'SET ('+process.env.SERVER_API_KEY.length+' chars, starts with: '+process.env.SERVER_API_KEY.slice(0,8)+'...)' : 'NOT SET (open access)')
+
+function send(res, status, body) {
+  const json = JSON.stringify(body)
+  res.writeHead(status, {
+    "Content-Type": "application/json",
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Headers": "Content-Type",
+    "Access-Control-Allow-Methods": "GET,POST,PUT,DELETE,OPTIONS",
+  })
+  res.end(json)
+}
+
+async function readBody(req) {
+  const chunks = []
+  for await (const c of req) chunks.push(c)
+  if (chunks.length === 0) return {}
+  try {
+    return JSON.parse(Buffer.concat(chunks).toString("utf8"))
+  } catch {
+    return {}
+  }
+}
+
+const server = createServer(async (req, res) => {
+  if (req.method === "OPTIONS") return send(res, 204, {})
+
+  const url = new URL(req.url, \`http://\${req.headers.host}\`)
+
+  if (req.method === "GET" && url.pathname === "/favicon2.ico") {
+    try {
+      const filepath = path.join(process.cwd(), "public", "favicon2.ico")
+      if (fs.existsSync(filepath)) {
+        res.writeHead(200, { "Content-Type": "image/x-icon" })
+        return res.end(fs.readFileSync(filepath))
+      }
+      const rootFilepath = path.join(process.cwd(), "favicon2.ico")
+      if (fs.existsSync(rootFilepath)) {
+        res.writeHead(200, { "Content-Type": "image/x-icon" })
+        return res.end(fs.readFileSync(rootFilepath))
+      }
+    } catch {}
+  }
+
+  const expectedKey = process.env.SERVER_API_KEY
+  
+  if (expectedKey) {
+    const auth = req.headers.authorization
+    const isPublic = url.pathname === "/" || url.pathname === "/health" || url.pathname === "/openapi.json" || url.pathname === "/reference"
+    if (!isPublic) {
+      if (!auth) {
+        return send(res, 401, { error: "Missing Authorization header. Expected Bearer token." })
+      }
+      const token = auth.replace(/^Bearer\\s+/i, "").trim()
+      if (token !== expectedKey.trim()) {
+        console.error('[AUTH] Token mismatch. Got:', token.slice(0,20), '| Expected starts with:', expectedKey.trim().slice(0,20))
+        return send(res, 403, { error: "Invalid API key." })
+      }
+    }
+  }
+
+  if (req.method === "GET" && url.pathname === "/health") {
+    return send(res, 200, { ok: true, service: ${JSON.stringify(config.projectName)} })
+  }
+
+  if (req.method === "GET" && url.pathname === "/") {
+    res.writeHead(200, { "Content-Type": "text/html" })
+    return res.end(\`<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>\${${JSON.stringify(config.projectName)}} \u2014 RAG Server</title>
+  <link rel="icon" href="/favicon2.ico" type="image/x-icon" />
+  <link rel="preconnect" href="https://fonts.googleapis.com">
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+  <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+  <style>
+    *{margin:0;padding:0;box-sizing:border-box}
+    body{font-family:'Inter',system-ui,sans-serif;min-height:100vh;display:flex;align-items:center;justify-content:center;background:#F2EDE8;color:#18181b;overflow:hidden;position:relative}
+    body::after{content:'';position:fixed;inset:0;pointer-events:none;z-index:0;background-image:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='400' height='400'%3E%3Cfilter id='n'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='0.75' numOctaves='3' stitchTiles='stitch'/%3E%3CfeColorMatrix values='0 0 0 0 0.28 0 0 0 0 0.23 0 0 0 0 0.16 0 0 0 0.55 0'/%3E%3C/filter%3E%3Crect width='100%25' height='100%25' filter='url(%23n)'/%3E%3C/svg%3E");background-size:512px 512px;background-repeat:repeat;opacity:0.79;mix-blend-mode:overlay}
+    .bg-mesh{position:fixed;inset:0;z-index:0;background-image:radial-gradient(ellipse 55% 45% at 8% 4%,rgba(0,0,0,0.12),transparent 70%),radial-gradient(ellipse 45% 40% at 94% 92%,rgba(220,160,120,0.15),transparent 65%),radial-gradient(ellipse 70% 55% at 50% 50%,rgba(0,0,0,0.05),transparent 80%)}
+    .container{position:relative;z-index:1;text-align:center;max-width:800px;padding:2rem;}
+    .badge{display:inline-flex;align-items:center;gap:6px;padding:6px 16px;border-radius:100px;font-size:0.75rem;font-weight:500;color:#000;background:rgba(255,255,255,0.8);border:1px solid rgba(0,0,0,0.1);margin-bottom:2rem;backdrop-filter:blur(4px);transition:colors .2s}
+    .badge:hover{background:#fff}
+    .badge .dot{width:6px;height:6px;border-radius:50%;background:#10b981;box-shadow:0 0 6px rgba(16,185,129,.4);animation:pulse 2s ease-in-out infinite}
+    @keyframes pulse{0%,100%{opacity:1}50%{opacity:.4}}
+    h1{font-size:3.5rem;font-weight:500;letter-spacing:-0.02em;color:#000;margin-bottom:1.5rem;line-height:1.05;}
+    .subtitle{font-size:1.125rem;color:#52525b;line-height:1.6;margin-bottom:3rem;max-width:600px;margin-left:auto;margin-right:auto;}
+    .actions{display:flex;flex-wrap:wrap;gap:1rem;justify-content:center}
+    .btn{display:inline-flex;align-items:center;justify-content:center;gap:8px;padding:0.75rem 1.5rem;font-size:0.875rem;font-weight:500;text-decoration:none;transition:all .2s ease;cursor:pointer;border:none;}
+    .btn-primary{background:#000000;color:#fff;box-shadow:0 2px 12px rgba(0,0,0,.15)}
+    .btn-primary:hover{transform:translateY(-1px);box-shadow:0 4px 20px rgba(0,0,0,.25)}
+    .btn-outline{background:transparent;color:#000;border:1px solid rgba(0,0,0,.12);}
+    .btn-outline:hover{background:rgba(255,255,255,0.5);border-color:rgba(0,0,0,.2);transform:translateY(-1px);}
+    .footer{margin-top:4rem;font-size:.875rem;color:#71717a}
+    .footer a{color:#000;text-decoration:underline;text-underline-offset:2px;}
+    .footer a:hover{color:#333;}
+    .icon{width:16px;height:16px;stroke:currentColor;fill:none;stroke-width:2;stroke-linecap:round;stroke-linejoin:round}
+    @media (max-width: 640px){ h1{font-size:2.5rem;} }
+  </style>
+</head>
+<body>
+  <div class="bg-mesh"></div>
+  <div class="container">
+    <div class="badge"><span class="dot"></span> Server Online</div>
+    <h1>\${${JSON.stringify(config.projectName)}}</h1>
+    <p class="subtitle">Your RAG retrieval server is live and ready to accept queries.<br/>Powered by <strong style="color:#000000">Larkup</strong></p>
+    <div class="actions">
+      <a href="/reference" class="btn btn-primary">
+        <svg class="icon" viewBox="0 0 24 24"><path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/><polyline points="14 2 14 8 20 8"/><line x1="16" y1="13" x2="8" y2="13"/><line x1="16" y1="17" x2="8" y2="17"/></svg>
+        API Reference
+      </a>
+      <a href="https://github.com/BuddyHere-AI" target="_blank" rel="noopener" class="btn btn-outline">
+        <svg class="icon" viewBox="0 0 24 24"><path d="M17 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2"/><circle cx="9" cy="7" r="4"/><path d="M23 21v-2a4 4 0 0 0-3-3.87"/><path d="M16 3.13a4 4 0 0 1 0 7.75"/></svg>
+        Larkup Team
+      </a>
+      <a href="mailto:contact@larkup.de" class="btn btn-outline">
+        <svg class="icon" viewBox="0 0 24 24"><path d="M4 4h16c1.1 0 2 .9 2 2v12c0 1.1-.9 2-2 2H4c-1.1 0-2-.9-2-2V6c0-1.1.9-2 2-2z"/><polyline points="22,6 12,13 2,6"/></svg>
+        Contact
+      </a>
+    </div>
+    <div class="footer">Built with <a href="https://github.com/BuddyHere-AI/buddy-rag" target="_blank" rel="noopener">larkup</a> \xB7 v1.0</div>
+  </div>
+</body>
+</html>\`)
+  }
+
+  if (req.method === "POST" && url.pathname === "/query") {
+    try {
+      const { query: q, topK } = await readBody(req)
+      if (!q || typeof q !== "string") {
+        return send(res, 400, { error: "Body must include a 'query' string." })
+      }
+      const vector = await embedQuery(q)
+      const hits = await store.query(vector, Number(topK) || DEFAULT_TOP_K)
+      return send(res, 200, { query: q, hits })
+    } catch (err) {
+      return send(res, 500, { error: String(err?.message || err) })
+    }
+  }
+
+  if (req.method === "GET" && url.pathname === "/documents") {
+    try {
+      const page  = Math.max(1, parseInt(url.searchParams.get("page")  || "1",  10) || 1)
+      const limit = Math.min(100, Math.max(1, parseInt(url.searchParams.get("limit") || "20", 10) || 20))
+      const result = await store.list({ page, limit })
+      return send(res, 200, result)
+    } catch (err) {
+      return send(res, 500, { error: String(err?.message || err) })
+    }
+  }
+
+  if (req.method === "GET" && url.pathname.match(/^\\/documents\\/[^/]+$/) && !url.pathname.endsWith("/documents")) {
+    try {
+      const id = url.pathname.split("/").pop()
+      const doc = await store.get(id)
+      if (!doc) return send(res, 404, { error: "Document not found" })
+      return send(res, 200, doc)
+    } catch (err) {
+      return send(res, 500, { error: String(err?.message || err) })
+    }
+  }
+
+  if (req.method === "POST" && url.pathname === "/documents") {
+    try {
+      const doc = await readBody(req)
+      if (!doc.text) return send(res, 400, { error: "Missing text" })
+      const vector = await embedQuery(doc.text)
+      const id = doc.id || Math.random().toString(36).slice(2)
+      await store.add([{ id, vector, text: doc.text, title: doc.title || "Untitled", url: doc.url, documentId: doc.documentId || id }])
+      return send(res, 200, { success: true, id })
+    } catch (err) {
+      return send(res, 500, { error: String(err?.message || err) })
+    }
+  }
+
+  if (req.method === "PUT" && url.pathname.startsWith("/documents/")) {
+    try {
+      const id = url.pathname.split("/").pop()
+      const doc = await readBody(req)
+      if (!doc.text) return send(res, 400, { error: "Missing text" })
+      const vector = await embedQuery(doc.text)
+      await store.update(id, { id, vector, text: doc.text, title: doc.title || "Untitled", url: doc.url, documentId: doc.documentId || id })
+      return send(res, 200, { success: true })
+    } catch (err) {
+      return send(res, 500, { error: String(err?.message || err) })
+    }
+  }
+
+  if (req.method === "DELETE" && url.pathname.startsWith("/documents/")) {
+    try {
+      const id = url.pathname.split("/").pop()
+      await store.remove(id)
+      return send(res, 200, { success: true })
+    } catch (err) {
+      return send(res, 500, { error: String(err?.message || err) })
+    }
+  }
+
+  if (req.method === "POST" && url.pathname === "/scrape") {
+    try {
+      const { url: targetUrl } = await readBody(req)
+      if (!targetUrl || typeof targetUrl !== "string") {
+        return send(res, 400, { error: "Body must include a 'url' string." })
+      }
+      const fetchRes = await fetch(targetUrl)
+      if (!fetchRes.ok) return send(res, 502, { error: \`Failed to fetch \${targetUrl}: \${fetchRes.status}\` })
+      const html = await fetchRes.text()
+      const $ = cheerio.load(html)
+      $("script, style, nav, footer, header, iframe, noscript").remove()
+      const rawText = $("body").text().replace(/\\s+/g, " ").trim()
+      if (!rawText) return send(res, 422, { error: "No text content extracted from URL." })
+
+      const title = $("title").text().trim() || new URL(targetUrl).hostname
+      const CHUNK_SIZE = 1000
+      const chunks = []
+      for (let i = 0; i < rawText.length; i += CHUNK_SIZE) {
+        chunks.push(rawText.slice(i, i + CHUNK_SIZE))
+      }
+
+      const documentId = Math.random().toString(36).slice(2)
+      for (const [idx, chunk] of chunks.entries()) {
+        const id = \`\${documentId}-\${idx}\`
+        const vector = await embedQuery(chunk)
+        await store.add([{ id, vector, text: chunk, title: \`\${title} (part \${idx + 1})\`, url: targetUrl, documentId }])
+      }
+
+      return send(res, 200, { success: true, documentId, chunks: chunks.length })
+    } catch (err) {
+      return send(res, 500, { error: String(err?.message || err) })
+    }
+  }
+
+  if (req.method === "GET" && url.pathname === "/openapi.json") {
+    return send(res, 200, {
+      openapi: "3.1.0",
+      info: { title: "Larkup Server", version: "1.0.0" },
+      security: [{ bearerAuth: [] }],
+      paths: {
+        "/query": {
+          post: {
+            summary: "Query the RAG knowledge base",
+            security: [{ bearerAuth: [] }],
+            requestBody: {
+              content: { "application/json": { schema: { type: "object", properties: { query: { type: "string" }, topK: { type: "number" } } } } }
+            },
+            responses: { "200": { description: "Successful response" } }
+          }
+        },
+        "/documents": {
+          get: {
+            summary: "List documents (paginated)",
+            security: [{ bearerAuth: [] }],
+            parameters: [
+              { name: "page",  in: "query", required: false, schema: { type: "integer", default: 1,  minimum: 1 }, description: "Page number (1-indexed)" },
+              { name: "limit", in: "query", required: false, schema: { type: "integer", default: 20, minimum: 1, maximum: 100 }, description: "Items per page" }
+            ],
+            responses: {
+              "200": {
+                description: "Paginated list of documents",
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object",
+                      properties: {
+                        documents:  { type: "array",   items: { type: "object" } },
+                        total:      { type: "integer", description: "Total number of documents" },
+                        page:       { type: "integer", description: "Current page" },
+                        limit:      { type: "integer", description: "Items per page" },
+                        totalPages: { type: "integer", description: "Total number of pages" }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          },
+          post: {
+            summary: "Add a new document",
+            security: [{ bearerAuth: [] }],
+            requestBody: {
+              content: { "application/json": { schema: { type: "object", properties: { text: { type: "string" }, title: { type: "string" }, url: { type: "string" }, documentId: { type: "string" } } } } }
+            },
+            responses: { "200": { description: "Successful response" } }
+          }
+        },
+        "/documents/{id}": {
+          get: {
+            summary: "Get a single document by ID",
+            security: [{ bearerAuth: [] }],
+            parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
+            responses: {
+              "200": { description: "Document object" },
+              "404": { description: "Document not found" }
+            }
+          },
+          put: {
+            summary: "Update a document",
+            security: [{ bearerAuth: [] }],
+            parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
+            requestBody: {
+              content: { "application/json": { schema: { type: "object", properties: { text: { type: "string" }, title: { type: "string" }, url: { type: "string" }, documentId: { type: "string" } } } } }
+            },
+            responses: { "200": { description: "Successful response" } }
+          },
+          delete: {
+            summary: "Delete a document",
+            security: [{ bearerAuth: [] }],
+            parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
+            responses: { "200": { description: "Successful response" } }
+          }
+        },
+        "/scrape": {
+          post: {
+            summary: "Scrape a URL and ingest into the corpus",
+            security: [{ bearerAuth: [] }],
+            requestBody: {
+              content: { "application/json": { schema: { type: "object", required: ["url"], properties: { url: { type: "string", description: "URL to scrape" } } } } }
+            },
+            responses: {
+              "200": { description: "Scrape successful", content: { "application/json": { schema: { type: "object", properties: { success: { type: "boolean" }, documentId: { type: "string" }, chunks: { type: "integer" } } } } } },
+              "502": { description: "Failed to fetch the target URL" }
+            }
+          }
+        },
+        "/health": {
+          get: {
+            summary: "Health check",
+            responses: { "200": { description: "OK" } }
+          }
+        }
+      },
+      components: {
+        securitySchemes: {
+          bearerAuth: {
+            type: "http",
+            scheme: "bearer"
+          }
+        }
+      }
+    })
+  }
+
+  if (req.method === "GET" && url.pathname === "/reference") {
+    const defaultToken = process.env.SERVER_API_KEY || ""
+    res.writeHead(200, { "Content-Type": "text/html" })
+    return res.end(\`
+      <!DOCTYPE html>
+      <html>
+        <head>
+          <title>API Reference</title>
+          <meta charset="utf-8" />
+          <meta name="viewport" content="width=device-width, initial-scale=1" />
+          <link rel="icon" href="/favicon2.ico" type="image/x-icon" />
+        </head>
+        <body>
+          <script id="api-reference" data-url="/openapi.json"></script>
+          <script>
+            const configuration = {
+              "theme": "kepler",
+              "hideClientButton": false,
+              "showSidebar": true,
+              "showDeveloperTools": "localhost",
+              "showToolbar": "localhost",
+              "operationTitleSource": "summary",
+              "persistAuth": true,
+              "telemetry": true,
+              "externalUrls": {
+                "dashboardUrl": "https://dashboard.scalar.com",
+                "registryUrl": "https://registry.scalar.com",
+                "proxyUrl": "https://proxy.scalar.com",
+                "apiBaseUrl": "https://api.scalar.com"
+              },
+              "default": false,
+              "layout": "modern",
+              "isEditable": false,
+              "isLoading": false,
+              "hideModels": false,
+              "documentDownloadType": "both",
+              "hideTestRequestButton": false,
+              "hideSearch": false,
+              "showOperationId": false,
+              "hideDarkModeToggle": false,
+              "withDefaultFonts": true,
+              "defaultOpenFirstTag": true,
+              "defaultOpenAllTags": false,
+              "expandAllModelSections": false,
+              "expandAllResponses": false,
+              "orderSchemaPropertiesBy": "alpha",
+              "orderRequiredPropertiesFirst": true,
+              "_integration": "html",
+              "modelsSectionLabel": "Models",
+              "slug": "api-1",
+              "title": "API #1",
+              "authentication": {
+                "preferredSecurityScheme": "bearerAuth",
+                "http": {
+                  "basic": { "username": "", "password": "" },
+                  "bearer": { "token": "\${defaultToken}" }
+                }
+              }
+            };
+            document.getElementById('api-reference').dataset.configuration = JSON.stringify(configuration);
+          </script>
+          <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"></script>
+        </body>
+      </html>
+    \`)
+  }
+
+  return send(res, 404, { error: "Not found" })
+})
+
+server.listen(PORT, () => {
+  console.log(\`[${config.projectName}] RAG server listening on :\${PORT}\`)
+})
+`;
+}
+function demoSource() {
+  return `const BASE = process.env.RAG_SERVER_URL || "http://localhost:8080"
+
+const question = process.argv.slice(2).join(" ") || "What is this corpus about?"
+
+const res = await fetch(\`\${BASE}/query\`, {
+  method: "POST",
+  headers: { "Content-Type": "application/json" },
+  body: JSON.stringify({ query: question }),
+})
+
+const data = await res.json()
+if (!res.ok) {
+  console.error("Error:", data.error)
+  process.exit(1)
+}
+
+console.log(\`\\nQuery: \${data.query}\\n\`)
+for (const [i, hit] of data.hits.entries()) {
+  console.log(\`#\${i + 1} [\${hit.score.toFixed(3)}] \${hit.title}\`)
+  if (hit.url) console.log(\`   \${hit.url}\`)
+  console.log(\`   \${hit.text.slice(0, 160).replace(/\\n/g, " ")}...\\n\`)
+}
+`;
+}
+function dockerfile() {
+  return `FROM node:22-slim
+
+WORKDIR /app
+
+COPY package.json ./
+RUN npm install --omit=dev
+
+COPY . .
+
+ENV PORT=8080
+EXPOSE 8080
+
+CMD ["node", "server.mjs"]
+`;
+}
+function dockerignore() {
+  return `node_modules
+npm-debug.log
+.env
+.git
+.DS_Store
+`;
+}
+function dockerCompose(projectName, usesLocalLance) {
+  const volume = usesLocalLance ? `    volumes:
+      - ./.larkup:/app/.larkup
+` : "";
+  return `services:
+  ${projectName}:
+    build: .
+    container_name: ${projectName}
+    restart: unless-stopped
+    ports:
+      - "8080:8080"
+    env_file:
+      - .env
+${volume}`;
+}
+function vercelJson() {
+  return `{
+  "$schema": "https://openapi.vercel.sh/vercel.json",
+  "builds": [{ "src": "server.mjs", "use": "@vercel/node" }],
+  "routes": [
+    { "handle": "filesystem" },
+    { "src": "/(.*)", "dest": "server.mjs" }
+  ]
+}
+`;
+}
+function envExample(server) {
+  return server.envVars.map((e) => `# ${e.help}${e.required ? "" : " (optional)"}
+${e.key}=`).join("\n");
+}
+function readme(config, server) {
+  const store = getVectorStore(config.vectorStore);
+  const deps = Object.entries(server.dependencies).map(([k, v]) => `- \`${k}@${v}\``).join("\n");
+  return `# ${config.projectName}
+
+A lightweight RAG retrieval server generated by **larkup**.
+
+- **Vector store:** ${store.label}
+- **Embedding model:** ${config.embeddingModelId}
+- **Index type:** ${config.indexType}
+- **Default top-k:** ${config.topK}
+
+## Dependencies
+${deps}
+
+## Run locally
+\`\`\`bash
+npm install
+cp .env.example .env
+node server.mjs
+\`\`\`
+
+Then query it:
+\`\`\`bash
+node demo.mjs "your question here"
+# or
+curl -X POST http://localhost:8080/query \\
+  -H "Content-Type: application/json" \\
+  -H "Authorization: Bearer <your-key>" \\
+  -d '{"query":"your question","topK":${config.topK}}'
+\`\`\`
+
+## Deploy
+
+### Docker / VPS
+\`\`\`bash
+docker compose up -d --build
+\`\`\`
+
+### Vercel
+\`\`\`bash
+vercel deploy
+\`\`\`
+
+## API
+- \`GET  /health\`           \u2192 \`{ ok: true }\`
+- \`GET  /reference\`        \u2192 Scalar API docs UI
+- \`POST /query\`            \u2192 \`{ query, hits: [{ id, score, title, url, text, documentId }] }\`
+- \`GET  /documents\`        \u2192 list all documents (paginated)
+- \`GET  /documents/:id\`    \u2192 get a single document
+- \`POST /documents\`        \u2192 add a document
+- \`PUT  /documents/:id\`    \u2192 update a document
+- \`DELETE /documents/:id\`  \u2192 delete a document
+- \`POST /scrape\`           \u2192 scrape a URL and ingest into the corpus
+`;
+}
+function generateServer(config) {
+  const store = getVectorStore(config.vectorStore);
+  const model = getEmbeddingModel(config.embeddingModelId);
+  const usesLocalLance = config.vectorStore === "lancedb" && config.storeConfig.mode !== "cloud";
+  const dependencies = {
+    ai: "^6.0.0",
+    cheerio: "^1.0.0",
+    ...store.serverDependencies
+  };
+  const envVars = [
+    {
+      key: "EMBEDDING_API_KEY",
+      required: true,
+      help: "API key used to embed incoming queries."
+    },
+    {
+      key: "PORT",
+      required: false,
+      help: "Port to listen on (default 8080)."
+    },
+    {
+      key: "SERVER_API_KEY",
+      required: false,
+      help: "Bearer token to secure your server endpoints. If set, requests must include 'Authorization: Bearer <key>'."
+    },
+    {
+      key: "TOP_K",
+      required: false,
+      help: `Default number of documents to retrieve (default ${config.topK}).`
+    }
+  ];
+  if (config.vectorStore === "pinecone") {
+    envVars.push(
+      { key: "PINECONE_API_KEY", required: true, help: "Pinecone API key." },
+      {
+        key: "PINECONE_INDEX",
+        required: true,
+        help: "Pinecone index name to query."
+      },
+      {
+        key: "PINECONE_NAMESPACE",
+        required: false,
+        help: "Pinecone namespace (default 'default')."
+      },
+      {
+        key: "PINECONE_SPARSE_MODEL",
+        required: false,
+        help: "Pinecone sparse model (for hybrid search)."
+      },
+      {
+        key: "PINECONE_SPARSE_INDEX",
+        required: false,
+        help: "Pinecone sparse index name (for hybrid search)."
+      }
+    );
+  } else {
+    envVars.push(
+      {
+        key: "LANCEDB_MODE",
+        required: false,
+        help: "'local' (on-disk) or 'cloud' (default 'local')."
+      },
+      {
+        key: "LANCEDB_PATH",
+        required: false,
+        help: "On-disk path to the LanceDB tables (local mode)."
+      },
+      {
+        key: "LANCEDB_TABLE",
+        required: false,
+        help: "Table name holding the embedded chunks (default 'documents')."
+      },
+      {
+        key: "LANCEDB_URI",
+        required: false,
+        help: "LanceDB Cloud database URI (cloud mode)."
+      },
+      {
+        key: "LANCEDB_API_KEY",
+        required: false,
+        help: "LanceDB Cloud API key (cloud mode)."
+      }
+    );
+  }
+  const server = {
+    projectName: config.projectName,
+    files: [],
+    dependencies,
+    envVars
+  };
+  const pkg = {
+    name: config.projectName,
+    version: "1.0.0",
+    private: true,
+    type: "module",
+    description: `Lightweight RAG server (${store.label}) generated by larkup`,
+    scripts: {
+      start: "node server.mjs",
+      demo: "node demo.mjs"
+    },
+    dependencies,
+    engines: { node: ">=20" }
+  };
+  const generatedEnv = server.envVars.map((e) => {
+    let val = "";
+    if (e.key === "EMBEDDING_API_KEY") val = config.embeddingApiKey || "";
+    if (e.key === "PINECONE_API_KEY") val = config.storeConfig.apiKey || "";
+    if (e.key === "PINECONE_INDEX") val = config.storeConfig.indexName || "";
+    if (e.key === "PINECONE_NAMESPACE")
+      val = config.storeConfig.namespace || "";
+    if (e.key === "LANCEDB_URI") val = config.storeConfig.uri || "";
+    if (e.key === "LANCEDB_API_KEY") val = config.storeConfig.apiKey || "";
+    return `${e.key}=${val}`;
+  }).join("\n");
+  const files = [
+    { path: "package.json", contents: JSON.stringify(pkg, null, 2) + "\n" },
+    { path: "server.mjs", contents: serverSource(config) },
+    { path: "embed.mjs", contents: embedSource(config) },
+    {
+      path: "store.mjs",
+      contents: config.vectorStore === "pinecone" ? pineconeStore() : lancedbStore()
+    },
+    { path: "demo.mjs", contents: demoSource() },
+    { path: "Dockerfile", contents: dockerfile() },
+    { path: ".dockerignore", contents: dockerignore() },
+    {
+      path: "docker-compose.yml",
+      contents: dockerCompose(config.projectName, usesLocalLance)
+    },
+    { path: "vercel.json", contents: vercelJson() },
+    { path: ".env.example", contents: envExample(server) },
+    { path: ".env", contents: generatedEnv },
+    { path: ".gitignore", contents: "node_modules\n.env\n.DS_Store\n" },
+    { path: "README.md", contents: readme(config, server) }
+  ].map((f) => ({ ...f, language: lang(f.path) }));
+  try {
+    const fs8 = __require("fs");
+    const path9 = __require("path");
+    const faviconPath = path9.resolve(process.cwd(), "public/favicon2.ico");
+    if (fs8.existsSync(faviconPath)) {
+      files.push({
+        path: "public/favicon2.ico",
+        contents: fs8.readFileSync(faviconPath).toString("base64"),
+        language: "ico",
+        encoding: "base64"
+      });
+    } else {
+      const webFaviconPath = path9.resolve(
+        process.cwd(),
+        "apps/web/public/favicon2.ico"
+      );
+      if (fs8.existsSync(webFaviconPath)) {
+        files.push({
+          path: "public/favicon2.ico",
+          contents: fs8.readFileSync(webFaviconPath).toString("base64"),
+          language: "ico",
+          encoding: "base64"
+        });
+      }
+    }
+  } catch (e) {
+  }
+  void model;
+  server.files = files;
+  return server;
+}
+
+// ../../packages/core/src/generator/server-runtime.ts
+import { promises as fs6 } from "fs";
+import path6 from "path";
+import { spawn, exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+var FALLBACK_PORT = 8080;
+async function resolvePort() {
+  const server = await getActiveServer();
+  return server?.port ?? FALLBACK_PORT;
+}
+function emptyState(port) {
+  return {
+    running: false,
+    port,
+    endpoint: `http://localhost:${port}`
+  };
+}
+async function outDir(create) {
+  const dir = create ? await requireDataDir() : await getDataDir();
+  if (!dir) return null;
+  return path6.join(dir, "generated-server");
+}
+async function statePath(create) {
+  const dir = create ? await requireDataDir() : await getDataDir();
+  if (!dir) return null;
+  return path6.join(dir, "server-local.json");
+}
+async function readServerState() {
+  const port = await resolvePort();
+  const file = await statePath(false);
+  if (!file) return emptyState(port);
+  try {
+    const raw = await fs6.readFile(file, "utf8");
+    return { ...emptyState(port), ...JSON.parse(raw), port };
+  } catch {
+    return emptyState(port);
+  }
+}
+async function writeState(state) {
+  const file = await statePath(true);
+  if (file) await fs6.writeFile(file, JSON.stringify(state, null, 2), "utf8");
+  return state;
+}
+function pidAlive(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function emitToDisk(config) {
+  const server = generateServer(config);
+  const dir = await outDir(true);
+  if (!dir) throw new Error("No active server to emit to.");
+  await fs6.mkdir(dir, { recursive: true });
+  for (const file of server.files) {
+    const dest = path6.join(dir, file.path);
+    await fs6.mkdir(path6.dirname(dest), { recursive: true });
+    if (file.encoding === "base64") {
+      await fs6.writeFile(dest, Buffer.from(file.contents, "base64"));
+    } else {
+      await fs6.writeFile(dest, file.contents, "utf8");
+    }
+  }
+  return dir;
+}
+async function isHealthy(endpoint) {
+  try {
+    const res = await fetch(`${endpoint}/health`, {
+      signal: AbortSignal.timeout(3e3)
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+async function refreshServerStatus() {
+  const state = await readServerState();
+  if (!state.startedAt) return state;
+  const alive = pidAlive(state.pid) && await isHealthy(state.endpoint);
+  if (alive !== state.running) {
+    return writeState({ ...state, running: alive });
+  }
+  return state;
+}
+
+// src/commands/generate.ts
+async function generateCommand(options) {
+  await inServerScope(options.server, async () => {
+    await requireActive();
+    const config = await readConfig();
+    if (options.out) {
+      const dir = path7.isAbsolute(options.out) ? options.out : path7.join(process.cwd(), options.out);
+      const server2 = generateServer(config);
+      await fs7.mkdir(dir, { recursive: true });
+      for (const f of server2.files) {
+        const dest = path7.join(dir, f.path);
+        await fs7.mkdir(path7.dirname(dest), { recursive: true });
+        await fs7.writeFile(dest, f.contents, "utf8");
+      }
+      log.success(`Generated ${server2.files.length} files \u2192 ${dir}`);
+    } else {
+      const dir = await emitToDisk(config);
+      const server2 = generateServer(config);
+      log.success(`Generated ${server2.files.length} files \u2192 ${dir}`);
+    }
+    const server = generateServer(config);
+    const deps = Object.entries(server.dependencies).map(([k, v]) => `${k}@${v}`).join(", ");
+    log.dim(`  deps: ${deps}`);
+    log.dim("  run it locally with: larkup serve");
+  });
+}
+
+// src/commands/serve.ts
+import path8 from "path";
+import { spawn as spawn2 } from "child_process";
+async function serveCommand(options) {
+  await inServerScope(options.server, async () => {
+    const server = await requireActive();
+    const config = await readConfig();
+    const isLocalLance = config.vectorStore === "lancedb" && config.storeConfig.mode !== "cloud";
+    const dir = await emitToDisk(config);
+    log.info(log.fmt.cyan("Installing minimal server dependencies\u2026"));
+    await new Promise((resolve, reject) => {
+      const child2 = spawn2("npm", ["install", "--omit=dev"], { cwd: dir, stdio: "inherit" });
+      child2.on(
+        "exit",
+        (code) => code === 0 ? resolve() : reject(new Error(`npm install exited with code ${code}`))
+      );
+      child2.on("error", reject);
+    });
+    const env = {
+      ...process.env,
+      PORT: String(server.port),
+      TOP_K: String(config.topK)
+    };
+    if (isLocalLance) {
+      const dbPath = config.storeConfig.dbPath || "./.larkup/lancedb";
+      env.LANCEDB_MODE = "local";
+      env.LANCEDB_PATH = path8.isAbsolute(dbPath) ? dbPath : path8.join(process.cwd(), dbPath);
+      env.LANCEDB_TABLE = config.storeConfig.tableName || "documents";
+    }
+    log.success(`Serving ${log.fmt.bold(config.projectName)} on http://localhost:${server.port}`);
+    log.dim("  POST /query  \xB7  GET /health  \xB7  Ctrl+C to stop");
+    const child = spawn2("node", ["server.mjs"], {
+      cwd: dir,
+      stdio: "inherit",
+      env
+    });
+    await new Promise((resolve) => {
+      child.on("exit", () => resolve());
+      process.on("SIGINT", () => child.kill("SIGINT"));
+      process.on("SIGTERM", () => child.kill("SIGTERM"));
+    });
+  });
+}
+
+// src/commands/query.ts
+async function queryCommand(question, options) {
+  await inServerScope(options.server, async () => {
+    await requireActive();
+    if (!question) log.error('Usage: larkup query "your question" [--topK 5]');
+    const config = await readConfig();
+    const run = await readRun();
+    if (!run || run.status !== "completed" || (run.totalChunks ?? 0) === 0) {
+      log.error("No index to query. Build one first: larkup index");
+    }
+    await ensureApiKey(config, "embedding");
+    const topK = Math.min(
+      Math.max(Number(options.topK) || config.topK, 1),
+      20
+    );
+    const started = Date.now();
+    const vector = await embedQuery(config, question);
+    const adapter = await createAdapter(config);
+    const hits = await adapter.query(vector, topK, question);
+    const took = Date.now() - started;
+    log.info(`
+${log.fmt.bold("Query:")} ${question}`);
+    log.dim(`${hits.length} result(s) \xB7 ${took}ms
+`);
+    if (hits.length === 0) {
+      log.dim("No matches. Try rephrasing or indexing more content.");
+      return;
+    }
+    hits.forEach((hit, i) => {
+      const pct = Math.round(Math.min(Math.max(hit.score, 0), 1) * 100);
+      log.info(`${log.fmt.cyan(`#${i + 1}`)} ${log.fmt.bold(hit.title || "Untitled")} ${log.fmt.dim(`(${pct}%)`)}`);
+      if (hit.url) log.dim(`   ${hit.url}`);
+      const snippet = hit.text.slice(0, 200).replace(/\s+/g, " ").trim();
+      log.info(`   ${snippet}${hit.text.length > 200 ? "\u2026" : ""}
+`);
+    });
+  });
+}
+
+// src/commands/chat.ts
+import { streamText, tool, stepCountIs } from "ai";
+import { z } from "zod";
+import * as p3 from "@clack/prompts";
+
+// ../../packages/core/src/chat-models/registry.ts
+var CHAT_MODELS = [
+  // ── OpenAI ──────────────────────────────────────────────────────────
+  {
+    id: "openai/gpt-4o-mini",
+    label: "GPT-4o Mini",
+    provider: "openai",
+    isDefault: true,
+    description: "Fast and affordable. Great for most chat use cases."
+  },
+  {
+    id: "openai/gpt-4o",
+    label: "GPT-4o",
+    provider: "openai",
+    description: "Most capable OpenAI model. Higher cost."
+  },
+  {
+    id: "openai/gpt-4.1-mini",
+    label: "GPT-4.1 Mini",
+    provider: "openai",
+    description: "Latest mini model with improved instruction following."
+  },
+  {
+    id: "openai/gpt-4.1-nano",
+    label: "GPT-4.1 Nano",
+    provider: "openai",
+    description: "Smallest and fastest GPT-4.1 variant."
+  },
+  // ── Google ──────────────────────────────────────────────────────────
+  {
+    id: "google/gemini-2.0-flash",
+    label: "Gemini 2.0 Flash",
+    provider: "google",
+    isDefault: true,
+    description: "Fast, affordable Gemini model. Great default."
+  },
+  {
+    id: "google/gemini-2.5-flash",
+    label: "Gemini 2.5 Flash",
+    provider: "google",
+    description: "Latest Gemini flash with improved reasoning."
+  },
+  {
+    id: "google/gemini-2.5-pro",
+    label: "Gemini 2.5 Pro",
+    provider: "google",
+    description: "Most capable Gemini model."
+  },
+  // ── Cohere ──────────────────────────────────────────────────────────
+  {
+    id: "cohere/command-r",
+    label: "Command R",
+    provider: "cohere",
+    isDefault: true,
+    description: "Optimized for RAG and tool use."
+  },
+  {
+    id: "cohere/command-r-plus",
+    label: "Command R+",
+    provider: "cohere",
+    description: "Most capable Cohere model for complex tasks."
+  },
+  // ── Mistral ─────────────────────────────────────────────────────────
+  {
+    id: "mistral/mistral-small-latest",
+    label: "Mistral Small",
+    provider: "mistral",
+    isDefault: true,
+    description: "Fast and efficient. Good for most tasks."
+  },
+  {
+    id: "mistral/mistral-large-latest",
+    label: "Mistral Large",
+    provider: "mistral",
+    description: "Mistral's most capable model."
+  },
+  // ── DeepSeek ────────────────────────────────────────────────────────
+  {
+    id: "deepseek/deepseek-chat",
+    label: "DeepSeek Chat",
+    provider: "deepseek",
+    isDefault: true,
+    description: "DeepSeek's primary chat model."
+  },
+  // ── Vercel AI Gateway ───────────────────────────────────────────────
+  {
+    id: "openai/gpt-4o-mini",
+    label: "GPT-4o Mini (via Gateway)",
+    provider: "vercel_ai_gateway",
+    isDefault: true,
+    description: "OpenAI GPT-4o Mini routed through Vercel AI Gateway."
+  },
+  {
+    id: "openai/gpt-4o",
+    label: "GPT-4o (via Gateway)",
+    provider: "vercel_ai_gateway",
+    description: "OpenAI GPT-4o routed through Vercel AI Gateway."
+  },
+  {
+    id: "google/gemini-2.0-flash",
+    label: "Gemini 2.0 Flash (via Gateway)",
+    provider: "vercel_ai_gateway",
+    description: "Google Gemini routed through Vercel AI Gateway."
+  },
+  {
+    id: "cohere/command-r-plus",
+    label: "Command R+ (via Gateway)",
+    provider: "vercel_ai_gateway",
+    description: "Cohere Command R+ routed through Vercel AI Gateway."
+  },
+  {
+    id: "mistral/mistral-large-latest",
+    label: "Mistral Large (via Gateway)",
+    provider: "vercel_ai_gateway",
+    description: "Mistral Large routed through Vercel AI Gateway."
+  },
+  {
+    id: "anthropic/claude-3-5-sonnet-20240620",
+    label: "Claude 3.5 Sonnet (via Gateway)",
+    provider: "vercel_ai_gateway",
+    description: "Anthropic Claude 3.5 Sonnet via Vercel AI Gateway."
+  },
+  {
+    id: "anthropic/claude-3-haiku-20240307",
+    label: "Claude 3 Haiku (via Gateway)",
+    provider: "vercel_ai_gateway",
+    description: "Anthropic Claude 3 Haiku via Vercel AI Gateway."
+  }
+];
+function getDefaultChatModel(provider) {
+  return CHAT_MODELS.find((m) => m.provider === provider && m.isDefault) ?? CHAT_MODELS.find((m) => m.provider === provider);
+}
+function getChatModel(id) {
+  return CHAT_MODELS.find((m) => m.id === id);
+}
+
+// src/commands/chat.ts
+import { createOpenAI as createOpenAI2 } from "@ai-sdk/openai";
+import { createGoogleGenerativeAI as createGoogleGenerativeAI2 } from "@ai-sdk/google";
+import { createCohere as createCohere2 } from "@ai-sdk/cohere";
+import { createMistral as createMistral2 } from "@ai-sdk/mistral";
+import { createDeepSeek as createDeepSeek2 } from "@ai-sdk/deepseek";
+import { createGateway as createGateway2 } from "@ai-sdk/gateway";
+var SYSTEM_PROMPT = `You are a helpful research assistant powered by a knowledge base.
+You have one tool:
+- "searchKnowledgeBase" \u2014 searches a private RAG knowledge base.
+
+Guidelines:
+- For factual questions about the knowledge base content, call searchKnowledgeBase.
+- Synthesize a clear, well-structured answer based on the retrieved documents.
+- Cite sources inline when available.
+- Be concise and accurate. Never fabricate sources or facts.
+- For casual conversation, respond naturally without using the tool.
+`;
+function createChatModel(provider, modelId, apiKey) {
+  const modelName = modelId.includes("/") ? modelId.split("/").slice(1).join("/") : modelId;
+  switch (provider) {
+    case "google":
+      return createGoogleGenerativeAI2({ apiKey })(modelName);
+    case "cohere":
+      return createCohere2({ apiKey })(modelName);
+    case "mistral":
+      return createMistral2({ apiKey })(modelName);
+    case "deepseek":
+      return createDeepSeek2({ apiKey })(modelName);
+    case "vercel_ai_gateway":
+      return createGateway2({ apiKey })(modelId);
+    case "openai":
+    default:
+      return createOpenAI2({ apiKey })(modelName);
+  }
+}
+async function queryKnowledgeBase(query, topK) {
+  const config = await readConfig();
+  const server = await refreshServerStatus();
+  if (server.running) {
+    try {
+      const res = await fetch(`${server.endpoint}/query`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ query, topK }),
+        signal: AbortSignal.timeout(15e3)
+      });
+      const data = await res.json();
+      if (res.ok && data.hits) {
+        return { query, hits: data.hits };
+      }
+    } catch {
+    }
+  }
+  const run = await readRun();
+  if (!run || run.status !== "completed" || (run.totalChunks ?? 0) === 0) {
+    return { query, hits: [] };
+  }
+  const vector = await embedQuery(config, query);
+  const adapter = await createAdapter(config);
+  const hits = await adapter.query(vector, topK, query);
+  return { query, hits };
+}
+async function chatCommand(options) {
+  await inServerScope(options.server, async () => {
+    const server = await requireActive();
+    const config = await readConfig();
+    const provider = config.embeddingProvider;
+    const chatModelId = options.model || config.chatModelId || getDefaultChatModel(provider)?.id || "openai/gpt-4o-mini";
+    const descriptor = getChatModel(chatModelId);
+    const resolvedProvider = descriptor?.provider || provider;
+    await ensureApiKey(config, "chat");
+    log.info(log.fmt.cyan(`Starting chat session... (Type 'exit' to quit)`));
+    log.dim(`Server: ${server.name} | Model: ${chatModelId}`);
+    const aiModel = createChatModel(resolvedProvider, chatModelId, config.chatApiKey || config.embeddingApiKey);
+    const messages = [];
+    while (true) {
+      const input = await p3.text({
+        message: log.fmt.bold("You:"),
+        placeholder: "Ask something..."
+      });
+      if (p3.isCancel(input)) {
+        log.info("Goodbye.");
+        process.exit(0);
+      }
+      const text4 = input.trim();
+      if (!text4) continue;
+      if (text4.toLowerCase() === "exit" || text4.toLowerCase() === "quit") {
+        log.info("Goodbye.");
+        break;
+      }
+      messages.push({ role: "user", content: text4 });
+      try {
+        process.stdout.write(log.fmt.green(log.fmt.bold("Buddy: ")));
+        const result = streamText({
+          model: aiModel,
+          system: SYSTEM_PROMPT,
+          messages,
+          stopWhen: stepCountIs(5),
+          tools: {
+            searchKnowledgeBase: tool({
+              description: "Search the private knowledge base.",
+              inputSchema: z.object({ query: z.string() }),
+              execute: async ({ query }) => {
+                log.dim(`
+[Tool: searching knowledge base for "${query}"]`);
+                const res = await queryKnowledgeBase(query, 5);
+                log.dim(`[Tool: found ${res.hits.length} results]
+`);
+                return res;
+              }
+            })
+          }
+        });
+        let fullResponse = "";
+        for await (const chunk of result.textStream) {
+          process.stdout.write(log.fmt.green(chunk));
+          fullResponse += chunk;
+        }
+        process.stdout.write("\n\n");
+        messages.push({ role: "assistant", content: fullResponse });
+      } catch (e) {
+        log.error(`
+Chat error: ${e.message}`);
+        messages.pop();
+      }
+    }
+  });
+}
+
+// src/commands/settings.ts
+import * as p4 from "@clack/prompts";
+async function settingsCommand(options) {
+  await inServerScope(options.server, async () => {
+    await requireActive();
+    const config = await readConfig();
+    log.info(log.fmt.bold("\n--- CLI Settings ---"));
+    const providers = Array.from(new Set(CHAT_MODELS.map((m) => m.provider)));
+    const selectedProvider = await p4.select({
+      message: "Select AI Provider for Chat:",
+      initialValue: config.embeddingProvider,
+      options: providers.map((p5) => ({ label: p5, value: p5 }))
+    });
+    if (p4.isCancel(selectedProvider)) {
+      log.info("Cancelled.");
+      return;
+    }
+    const availableModels = CHAT_MODELS.filter((m) => m.provider === selectedProvider);
+    const selectedModel = await p4.select({
+      message: "Select Chat Model:",
+      initialValue: config.chatModelId || availableModels[0]?.id,
+      options: availableModels.map((m) => ({ label: m.label, value: m.id }))
+    });
+    if (p4.isCancel(selectedModel)) {
+      log.info("Cancelled.");
+      return;
+    }
+    await writeConfig({ ...config, chatModelId: selectedModel });
+    log.success(`Settings saved. Chat model set to ${selectedModel}.`);
+  });
+}
+
+// src/index.ts
+var program = new Command();
+program.name("larkup").description("Build, index, and serve a RAG pipeline from the terminal.").version("0.1.3");
+program.command("init [name]").description("Create a new RAG server (workspace project)").action(async (name) => {
+  prompts.intro(log.fmt.bold("larkup init"));
+  await initCommand(name);
+  prompts.outro("Done!");
+});
+program.command("servers").alias("list").description("List all servers (\u25CF = active)").action(async () => {
+  await listServersCommand();
+});
+program.command("use <serverId>").description("Switch the active server").action(async (serverId) => {
+  await useServerCommand(serverId);
+});
+program.command("config").description("Show the active server's configuration + status").option("--server <id>", "Target a specific server instead of the active one").action(async (options) => {
+  await configCommand(options);
+});
+program.command("add-doc").description("Add a document to the corpus").option("--file <path>", "Add a document from a file").option("--text <string>", "Add a document from inline text").option("--title <string>", "Document title").option("--url <string>", "Document URL").option("--server <id>", "Target a specific server instead of the active one").action(async (options) => {
+  await addDocCommand(options);
+});
+program.command("index").description("Chunk \u2192 embed \u2192 store the corpus").option("--server <id>", "Target a specific server instead of the active one").action(async (options) => {
+  await indexCommand(options);
+});
+program.command("generate").description("Emit the deployable RAG server to disk").option("--out <dir>", "Output directory").option("--server <id>", "Target a specific server instead of the active one").action(async (options) => {
+  await generateCommand(options);
+});
+program.command("serve").description("Run the generated server locally (foreground)").option("--server <id>", "Target a specific server instead of the active one").action(async (options) => {
+  await serveCommand(options);
+});
+program.command("query <question>").description("Retrieve top-k chunks").option("--topK <number>", "Number of results to return").option("--server <id>", "Target a specific server instead of the active one").action(async (question, options) => {
+  await queryCommand(question, options);
+});
+program.command("chat").description("Chat with your knowledge base in the terminal").option("--model <string>", "Specify the chat model ID").option("--server <id>", "Target a specific server instead of the active one").action(async (options) => {
+  await chatCommand(options);
+});
+program.command("settings").description("Configure CLI settings (e.g., chat models)").option("--server <id>", "Target a specific server instead of the active one").action(async (options) => {
+  await settingsCommand(options);
+});
+program.parseAsync(process.argv).catch((err) => {
+  log.error(err instanceof Error ? err.message : String(err));
+});