@jiangxiaosheng/digital-agent-platform 1.0.0

package/src/lib/agent-factory.ts

@@ -0,0 +1,200 @@
+// Core factory: dynamically builds a pi-coding-agent AgentSession
+// with per-agent persona, model, tools, workspace and RAG context.
+import type { DigitalAgent } from "@/types/agent";
+import { buildSystemPrompt } from "./system-prompt";
+import { buildToolConfig } from "./tool-builder";
+import { searchChunks } from "./knowledge/retriever";
+import { embedText } from "./knowledge/embedder";
+import path from "path";
+import os from "os";
+import fs from "fs";
+
+export function getAgentDir(): string {
+  return process.env.PI_AGENT_DIR ?? path.join(os.homedir(), ".pi", "agent");
+}
+
+export function getSessionDir(agentId: string): string {
+  return path.join(os.homedir(), ".pi", "agent", "sessions", `agent-${agentId}`);
+}
+
+/** 解析数字人工作区路径，空白时使用 agentDir */
+export function resolveWorkspace(agent: DigitalAgent): string {
+  const wp = agent.workspacePath?.trim();
+  if (wp) {
+    const expanded = wp.replace(/^~/, os.homedir());
+    // 目录不存在时自动创建，而不是静默回退
+    fs.mkdirSync(expanded, { recursive: true });
+    return expanded;
+  }
+  // 未配置时使用数字人专属默认目录
+  const agentWorkspace = path.join(getAgentDir(), "workspaces", `agent-${agent.id}`);
+  fs.mkdirSync(agentWorkspace, { recursive: true });
+  return agentWorkspace;
+}
+
+export async function buildRagContext(
+  agent: DigitalAgent,
+  userMessage: string
+): Promise<string> {
+  if (!agent.knowledgeBases.length) return "";
+  const queryVec = await embedText(userMessage);
+  const results = await searchChunks(agent.knowledgeBases, queryVec, 5);
+  if (!results.length) return "";
+  return results
+    .map((r, i) => `[${i + 1}] (来源: ${r.chunk.metadata.filename})\n${r.chunk.content}`)
+    .join("\n\n---\n\n");
+}
+
+// Returns a ready-to-use AgentSession — caller must call session.dispose() when done.
+export async function createSession(
+  agent: DigitalAgent,
+  userMessage: string,
+  existingSessionFile?: string
+) {
+  const {
+    createAgentSession,
+    ModelRuntime,
+    SessionManager,
+    DefaultResourceLoader,
+    defineTool,
+  } = await import("@earendil-works/pi-coding-agent");
+
+  // 1. RAG
+  const ragContext = await buildRagContext(agent, userMessage);
+
+  // 2. System prompt with agent identity
+  const systemPrompt = buildSystemPrompt(agent, ragContext);
+
+  // 3. Model runtime — load both auth.json (built-in keys) and models.json (custom providers)
+  const modelRuntime = await ModelRuntime.create({
+    authPath: path.join(getAgentDir(), "auth.json"),
+    modelsStorePath: path.join(getAgentDir(), "models.json"),
+  });
+
+  // Also inject keys saved via our settings page (SQLite store)
+  // This allows keys entered in Settings to override/supplement auth.json
+  const { getSettings } = await import("./settings");
+  const settings = getSettings();
+  const keyMap: Record<string, string | undefined> = {
+    anthropic: settings.apiKeys.anthropic,
+    openai: settings.apiKeys.openai,
+    google: settings.apiKeys.google,
+  };
+  for (const [provider, key] of Object.entries(keyMap)) {
+    if (key) await modelRuntime.setRuntimeApiKey(provider, key);
+  }
+
+  // Resolve model — throw with helpful message if not found
+  const model = modelRuntime.getModel(agent.model.provider, agent.model.modelId);
+  if (!model) {
+    const available = modelRuntime.getModels().slice(0, 5).map((m) => `${m.provider}/${m.id}`);
+    throw new Error(
+      `Model "${agent.model.provider}/${agent.model.modelId}" not found. ` +
+      `Check that the API key for "${agent.model.provider}" is configured in Settings. ` +
+      `Available models (first 5): ${available.join(", ")}`
+    );
+  }
+
+  // 4. Workspace (cwd) — use agent's own workspace, not process.cwd()
+  const cwd = resolveWorkspace(agent);
+
+  // 5. Load global env vars
+  const { readEnvVars } = await import("./env-vars");
+  const globalEnv = readEnvVars();
+
+  // Inject into process.env so ALL tools and skills can read them.
+  // spawnHook only covers the bash tool; skills (tavily-search, edge-tts, etc.)
+  // spawn subprocesses that inherit directly from process.env.
+  // These are user-configured API keys/config that are safe to set globally.
+  for (const [k, v] of Object.entries(globalEnv)) {
+    process.env[k] = v;
+  }
+
+  // 6. Tools
+  // env vars are already in process.env (injected above), so no need for spawnHook.
+  // Keep bash as a SDK builtin so the model recognises it correctly.
+  const { builtinNames, customTools: customToolDefs } = buildToolConfig(agent);
+  const customTools = [] as ReturnType<typeof defineTool>[];
+
+  // Calculator (custom tool)
+  if (customToolDefs.find((t) => t.name === "calculator")) {
+    const { Type } = await import("@sinclair/typebox");
+    customTools.push(
+      defineTool({
+        name: "calculator",
+        label: "Calculator",
+        description: "Evaluate a mathematical expression and return the result.",
+        parameters: Type.Object({ expression: Type.String({ description: "Math expression" }) }),
+        execute: async (_id: string, { expression }: { expression: string }) => {
+          try {
+            const result = Function(`"use strict"; return (${expression})`)();
+            return { content: [{ type: "text" as const, text: String(result) }], details: {} };
+          } catch (e) {
+            return { content: [{ type: "text" as const, text: `Error: ${String(e)}` }], details: {} };
+          }
+        },
+      })
+    );
+  }
+
+  // 6. Session manager — use agent-specific session directory
+  const sessionMgr = existingSessionFile
+    ? SessionManager.open(existingSessionFile)
+    : SessionManager.create(cwd, getSessionDir(agent.id));
+
+  // 7. Resource loader — two-phase: first discover filtered skills, then build final loader
+  // enabledSkills 为空 = 不限制（加载全部已安装 skills）
+  // enabledSkills 有值 = 白名单过滤
+  const enabledSkills = new Set(agent.enabledSkills ?? []);
+  const skillFilter = (base: { skills: { name: string }[]; diagnostics: unknown[] }) => ({
+    skills: enabledSkills.size > 0
+      ? base.skills.filter((s) => enabledSkills.has(s.name))
+      : base.skills,   // 空列表 = 不过滤，保留全部可用 skills
+    diagnostics: base.diagnostics,
+  });
+
+  // Phase 1: discover which skills are actually available after filter
+  const { formatSkillsForPrompt } = await import("@earendil-works/pi-coding-agent");
+  const discoveryLoader = new DefaultResourceLoader({
+    cwd,
+    agentDir: getAgentDir(),
+    skillsOverride: skillFilter as never,
+  });
+  await discoveryLoader.reload();
+  const { skills: filteredSkills } = discoveryLoader.getSkills();
+
+  // Phase 2: build final loader — systemPrompt + skills appended + skill filter
+  const skillsSection = filteredSkills.length > 0
+    ? formatSkillsForPrompt(filteredSkills)
+    : "";
+
+  const resourceLoader = new DefaultResourceLoader({
+    cwd,
+    agentDir: getAgentDir(),
+    systemPromptOverride: () => systemPrompt,
+    appendSystemPromptOverride: skillsSection ? () => [skillsSection] : undefined,
+    skillsOverride: skillFilter as never,
+  });
+
+  // ⚠️ REQUIRED: reload() initialises internal caches incl. systemPromptOverride
+  await resourceLoader.reload();
+
+  // 8. Create session
+  // bash is a SDK builtin — env vars flow via process.env set above
+  const allCustomTools = customTools.length > 0 ? customTools : undefined;
+  const hasAnyTools = builtinNames.length > 0 || (allCustomTools?.length ?? 0) > 0;
+
+  const { session } = await createAgentSession({
+    cwd,
+    modelRuntime,
+    model,
+    thinkingLevel: agent.model.thinkingLevel as Parameters<typeof createAgentSession>[0] extends { thinkingLevel?: infer T } ? T : never,
+    tools: builtinNames.length > 0 ? builtinNames : undefined,
+    noTools: !hasAnyTools ? "all" : undefined,
+    customTools: allCustomTools,
+    sessionManager: sessionMgr,
+    resourceLoader,
+  });
+
+  return session;
+}

package/src/lib/agents/store.ts

@@ -0,0 +1,95 @@
+import { getDb } from "../db/client";
+import type { DigitalAgent, CreateAgentInput, UpdateAgentInput } from "@/types/agent";
+import { v4 as uuidv4 } from "uuid";
+
+type AgentRow = { id: string; config: string; created_at: number; updated_at: number };
+
+function rowToAgent(row: AgentRow): DigitalAgent {
+  const cfg = JSON.parse(row.config);
+  return {
+    ...cfg,
+    id: row.id,
+    createdAt: new Date(row.created_at).toISOString(),
+    updatedAt: new Date(row.updated_at).toISOString(),
+  };
+}
+
+export const agentStore = {
+  list(): DigitalAgent[] {
+    const db = getDb();
+    const rows = db.prepare("SELECT * FROM agents ORDER BY created_at DESC").all() as AgentRow[];
+    return rows.map(rowToAgent);
+  },
+
+  getById(id: string): DigitalAgent | undefined {
+    const db = getDb();
+    const row = db.prepare("SELECT * FROM agents WHERE id = ?").get(id) as AgentRow | undefined;
+    return row ? rowToAgent(row) : undefined;
+  },
+
+  create(input: CreateAgentInput): DigitalAgent {
+    const db = getDb();
+    const id = uuidv4();
+    const now = Date.now();
+    const cfg = { ...input };
+    db.prepare("INSERT INTO agents (id, config, created_at, updated_at) VALUES (?, ?, ?, ?)").run(
+      id, JSON.stringify(cfg), now, now
+    );
+    return rowToAgent({ id, config: JSON.stringify(cfg), created_at: now, updated_at: now });
+  },
+
+  update(id: string, input: UpdateAgentInput): DigitalAgent | undefined {
+    const db = getDb();
+    const existing = this.getById(id);
+    if (!existing) return undefined;
+    const now = Date.now();
+    const merged = { ...existing, ...input, id: existing.id };
+    const { createdAt, updatedAt, ...cfg } = merged;
+    void createdAt; void updatedAt;
+    db.prepare("UPDATE agents SET config = ?, updated_at = ? WHERE id = ?").run(
+      JSON.stringify(cfg), now, id
+    );
+    return this.getById(id);
+  },
+
+  delete(id: string): boolean {
+    const db = getDb();
+    const result = db.prepare("DELETE FROM agents WHERE id = ?").run(id);
+    return result.changes > 0;
+  },
+};
+
+export const sessionStore = {
+  list(agentId: string) {
+    const db = getDb();
+    return db
+      .prepare("SELECT * FROM sessions WHERE agent_id = ? ORDER BY created_at DESC")
+      .all(agentId) as { id: string; agent_id: string; title: string; session_file: string; created_at: number }[];
+  },
+
+  create(agentId: string, sessionFile: string, title?: string): string {
+    const db = getDb();
+    const id = uuidv4();
+    db.prepare("INSERT INTO sessions (id, agent_id, title, session_file, created_at) VALUES (?, ?, ?, ?, ?)").run(
+      id, agentId, title ?? "New Session", sessionFile, Date.now()
+    );
+    return id;
+  },
+
+  updateFile(id: string, sessionFile: string): void {
+    const db = getDb();
+    db.prepare("UPDATE sessions SET session_file = ? WHERE id = ?").run(sessionFile, id);
+  },
+
+  delete(id: string): boolean {
+    const db = getDb();
+    const result = db.prepare("DELETE FROM sessions WHERE id = ?").run(id);
+    return result.changes > 0;
+  },
+
+  deleteByAgent(agentId: string): number {
+    const db = getDb();
+    const result = db.prepare("DELETE FROM sessions WHERE agent_id = ?").run(agentId);
+    return Number(result.changes);
+  },
+};

package/src/lib/db/client.ts

@@ -0,0 +1,25 @@
+import { DatabaseSync } from "node:sqlite";
+import path from "path";
+import os from "os";
+import fs from "fs";
+
+let _db: DatabaseSync | null = null;
+
+export function getStorageDir(): string {
+  const custom = process.env.STORAGE_PATH;
+  if (custom) return custom;
+  return path.join(os.homedir(), ".digital-agents");
+}
+
+export function getDb(): DatabaseSync {
+  if (_db) return _db;
+
+  const dir = getStorageDir();
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+
+  const dbPath = path.join(dir, "agents.db");
+  _db = new DatabaseSync(dbPath);
+  _db.exec("PRAGMA journal_mode = WAL");
+  _db.exec("PRAGMA foreign_keys = ON");
+  return _db;
+}

package/src/lib/db/schema.ts

@@ -0,0 +1,66 @@
+import { getDb } from "./client";
+
+export function initSchema(): void {
+  const db = getDb();
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS agents (
+      id TEXT PRIMARY KEY,
+      config TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      agent_id TEXT NOT NULL,
+      title TEXT,
+      session_file TEXT,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (agent_id) REFERENCES agents(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS knowledge_bases (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      description TEXT DEFAULT '',
+      embedding_model TEXT DEFAULT 'local',
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS kb_documents (
+      id TEXT PRIMARY KEY,
+      kb_id TEXT NOT NULL,
+      filename TEXT NOT NULL,
+      file_path TEXT,
+      mime_type TEXT,
+      chunk_count INTEGER DEFAULT 0,
+      status TEXT DEFAULT 'processing',
+      error TEXT,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (kb_id) REFERENCES knowledge_bases(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS kb_chunks (
+      id TEXT PRIMARY KEY,
+      kb_id TEXT NOT NULL,
+      doc_id TEXT NOT NULL,
+      content TEXT NOT NULL,
+      embedding BLOB,
+      metadata TEXT DEFAULT '{}',
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (kb_id) REFERENCES knowledge_bases(id) ON DELETE CASCADE,
+      FOREIGN KEY (doc_id) REFERENCES kb_documents(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS settings (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_sessions_agent_id ON sessions(agent_id);
+    CREATE INDEX IF NOT EXISTS idx_kb_chunks_kb_id ON kb_chunks(kb_id);
+    CREATE INDEX IF NOT EXISTS idx_kb_documents_kb_id ON kb_documents(kb_id);
+  `);
+}

package/src/lib/env-vars.ts

@@ -0,0 +1,33 @@
+import path from "path";
+import os from "os";
+import fs from "fs";
+
+function getEnvPath(): string {
+  const dir = path.join(os.homedir(), ".digital-agents");
+  fs.mkdirSync(dir, { recursive: true });
+  return path.join(dir, "env.json");
+}
+
+export function readEnvVars(): Record<string, string> {
+  const p = getEnvPath();
+  if (!fs.existsSync(p)) return {};
+  try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch { return {}; }
+}
+
+export function writeEnvVars(vars: Record<string, string>): void {
+  fs.writeFileSync(getEnvPath(), JSON.stringify(vars, null, 2), "utf8");
+}
+
+export function setEnvVar(key: string, value: string): void {
+  const vars = readEnvVars();
+  vars[key] = value;
+  writeEnvVars(vars);
+}
+
+export function deleteEnvVar(key: string): boolean {
+  const vars = readEnvVars();
+  if (!(key in vars)) return false;
+  delete vars[key];
+  writeEnvVars(vars);
+  return true;
+}

package/src/lib/knowledge/chunker.ts

@@ -0,0 +1,34 @@
+// Simple sentence/paragraph-based text chunker
+// Splits text into overlapping windows of ~512 tokens (≈ 1900 chars)
+
+const CHUNK_SIZE = 1900; // chars (~512 tokens)
+const OVERLAP = 200;     // chars overlap
+
+export function chunkText(
+  text: string,
+  metadata: { filename: string; pageNum?: number }
+): { content: string; metadata: object }[] {
+  const paragraphs = text.split(/\n{2,}/).map((p) => p.trim()).filter(Boolean);
+  const chunks: { content: string; metadata: object }[] = [];
+
+  let current = "";
+  let chunkIndex = 0;
+
+  for (const para of paragraphs) {
+    if ((current + "\n\n" + para).length > CHUNK_SIZE && current.length > 0) {
+      chunks.push({ content: current.trim(), metadata: { ...metadata, chunkIndex } });
+      chunkIndex++;
+      // Overlap: keep last portion of current chunk
+      const overlapText = current.slice(-OVERLAP);
+      current = overlapText + "\n\n" + para;
+    } else {
+      current = current ? current + "\n\n" + para : para;
+    }
+  }
+
+  if (current.trim()) {
+    chunks.push({ content: current.trim(), metadata: { ...metadata, chunkIndex } });
+  }
+
+  return chunks;
+}

package/src/lib/knowledge/embedder.ts

@@ -0,0 +1,48 @@
+// Embedding provider — uses OpenAI text-embedding-3-small if API key available,
+// otherwise falls back to a simple TF-IDF character n-gram hash embedding.
+import { getSettings } from "../settings";
+
+const VECTOR_DIM = 1536; // OpenAI text-embedding-3-small
+
+export async function embedText(text: string): Promise<number[]> {
+  const settings = getSettings();
+  if (settings.apiKeys.openai) {
+    return embedWithOpenAI(text, settings.apiKeys.openai);
+  }
+  return embedFallback(text);
+}
+
+export function getEmbeddingDim(): number {
+  const settings = getSettings();
+  return settings.apiKeys.openai ? VECTOR_DIM : 256;
+}
+
+async function embedWithOpenAI(text: string, apiKey: string): Promise<number[]> {
+  const res = await fetch("https://api.openai.com/v1/embeddings", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify({ model: "text-embedding-3-small", input: text }),
+  });
+  if (!res.ok) throw new Error(`OpenAI embedding error: ${res.statusText}`);
+  const data = (await res.json()) as { data: { embedding: number[] }[] };
+  return data.data[0].embedding;
+}
+
+// Lightweight 256-dim character n-gram hash embedding (no external deps)
+function embedFallback(text: string): number[] {
+  const dim = 256;
+  const vec = new Float32Array(dim);
+  const lower = text.toLowerCase();
+  for (let i = 0; i < lower.length - 1; i++) {
+    const bigram = lower.charCodeAt(i) * 31 + lower.charCodeAt(i + 1);
+    vec[bigram % dim] += 1;
+  }
+  // L2 normalize
+  let norm = 0;
+  for (let i = 0; i < dim; i++) norm += vec[i] * vec[i];
+  norm = Math.sqrt(norm) || 1;
+  return Array.from(vec).map((v) => v / norm);
+}

package/src/lib/knowledge/retriever.ts

@@ -0,0 +1,94 @@
+// Lightweight cosine-similarity vector search using plain SQLite BLOB storage.
+// Embeddings are stored as Float32Array serialized to Buffer.
+
+import { getDb } from "../db/client";
+import { v4 as uuidv4 } from "uuid";
+import type { SearchResult } from "@/types/knowledge";
+
+export async function searchChunks(
+  kbIds: string[],
+  queryEmbedding: number[],
+  topK = 5
+): Promise<SearchResult[]> {
+  const db = getDb();
+  if (kbIds.length === 0) return [];
+
+  const placeholders = kbIds.map(() => "?").join(",");
+  const rows = db
+    .prepare(`SELECT * FROM kb_chunks WHERE kb_id IN (${placeholders})`)
+    .all(...kbIds) as {
+    id: string;
+    kb_id: string;
+    doc_id: string;
+    content: string;
+    embedding: Buffer | null;
+    metadata: string;
+  }[];
+
+  const results: SearchResult[] = [];
+
+  for (const row of rows) {
+    if (!row.embedding) continue;
+    const docEmbedding = bufferToFloat32Array(row.embedding);
+    const score = cosineSimilarity(queryEmbedding, docEmbedding);
+    const meta = JSON.parse(row.metadata ?? "{}");
+    results.push({
+      chunk: {
+        id: row.id,
+        kbId: row.kb_id,
+        docId: row.doc_id,
+        content: row.content,
+        metadata: meta,
+      },
+      score,
+    });
+  }
+
+  results.sort((a, b) => b.score - a.score);
+  return results.slice(0, topK);
+}
+
+export function storeChunk(
+  kbId: string,
+  docId: string,
+  content: string,
+  embedding: number[],
+  metadata: object
+): void {
+  const db = getDb();
+  const id = uuidv4();
+  const embBuf = float32ArrayToBuffer(new Float32Array(embedding));
+  db.prepare(
+    "INSERT INTO kb_chunks (id, kb_id, doc_id, content, embedding, metadata, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)"
+  ).run(id, kbId, docId, content, embBuf, JSON.stringify(metadata), Date.now());
+}
+
+export function deleteChunksByDoc(docId: string): void {
+  getDb().prepare("DELETE FROM kb_chunks WHERE doc_id = ?").run(docId);
+}
+
+export function deleteChunksByKb(kbId: string): void {
+  getDb().prepare("DELETE FROM kb_chunks WHERE kb_id = ?").run(kbId);
+}
+
+// --- helpers ---
+
+function cosineSimilarity(a: number[], b: Float32Array): number {
+  if (a.length !== b.length) return 0;
+  let dot = 0, normA = 0, normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom === 0 ? 0 : dot / denom;
+}
+
+function float32ArrayToBuffer(arr: Float32Array): Buffer {
+  return Buffer.from(arr.buffer);
+}
+
+function bufferToFloat32Array(buf: Buffer): Float32Array {
+  return new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4);
+}

package/src/lib/knowledge/store.ts

@@ -0,0 +1,74 @@
+import { getDb } from "../db/client";
+import type { KnowledgeBase, KbDocument } from "@/types/knowledge";
+import { v4 as uuidv4 } from "uuid";
+
+type KbRow = {
+  id: string; name: string; description: string;
+  embedding_model: string; created_at: number; updated_at: number;
+};
+type DocRow = {
+  id: string; kb_id: string; filename: string; file_path: string;
+  mime_type: string; chunk_count: number; status: string; error: string | null;
+  created_at: number;
+};
+
+export const kbStore = {
+  list(): KnowledgeBase[] {
+    const db = getDb();
+    const rows = db.prepare("SELECT kb.*, (SELECT COUNT(*) FROM kb_documents d WHERE d.kb_id = kb.id) as doc_count, (SELECT COUNT(*) FROM kb_chunks c WHERE c.kb_id = kb.id) as chunk_count FROM knowledge_bases kb ORDER BY kb.created_at DESC").all() as (KbRow & { doc_count: number; chunk_count: number })[];
+    return rows.map((r) => ({
+      id: r.id, name: r.name, description: r.description,
+      embeddingModel: r.embedding_model,
+      documentCount: r.doc_count, chunkCount: r.chunk_count,
+      createdAt: new Date(r.created_at).toISOString(),
+      updatedAt: new Date(r.updated_at).toISOString(),
+    }));
+  },
+
+  getById(id: string): KnowledgeBase | undefined {
+    const db = getDb();
+    const r = db.prepare("SELECT kb.*, (SELECT COUNT(*) FROM kb_documents d WHERE d.kb_id = kb.id) as doc_count, (SELECT COUNT(*) FROM kb_chunks c WHERE c.kb_id = kb.id) as chunk_count FROM knowledge_bases kb WHERE kb.id = ?").get(id) as (KbRow & { doc_count: number; chunk_count: number }) | undefined;
+    if (!r) return undefined;
+    return { id: r.id, name: r.name, description: r.description, embeddingModel: r.embedding_model, documentCount: r.doc_count, chunkCount: r.chunk_count, createdAt: new Date(r.created_at).toISOString(), updatedAt: new Date(r.updated_at).toISOString() };
+  },
+
+  create(name: string, description = ""): KnowledgeBase {
+    const db = getDb();
+    const id = uuidv4();
+    const now = Date.now();
+    db.prepare("INSERT INTO knowledge_bases (id, name, description, embedding_model, created_at, updated_at) VALUES (?, ?, ?, 'auto', ?, ?)").run(id, name, description, now, now);
+    return this.getById(id)!;
+  },
+
+  delete(id: string): boolean {
+    const result = getDb().prepare("DELETE FROM knowledge_bases WHERE id = ?").run(id);
+    return result.changes > 0;
+  },
+
+  listDocuments(kbId: string): KbDocument[] {
+    const db = getDb();
+    const rows = db.prepare("SELECT * FROM kb_documents WHERE kb_id = ? ORDER BY created_at DESC").all(kbId) as DocRow[];
+    return rows.map((r) => ({
+      id: r.id, kbId: r.kb_id, filename: r.filename, filePath: r.file_path,
+      mimeType: r.mime_type, chunkCount: r.chunk_count,
+      status: r.status as KbDocument["status"], error: r.error ?? undefined,
+      createdAt: new Date(r.created_at).toISOString(),
+    }));
+  },
+
+  createDocument(kbId: string, filename: string, filePath: string, mimeType: string): string {
+    const db = getDb();
+    const id = uuidv4();
+    db.prepare("INSERT INTO kb_documents (id, kb_id, filename, file_path, mime_type, chunk_count, status, created_at) VALUES (?, ?, ?, ?, ?, 0, 'processing', ?)").run(id, kbId, filename, filePath, mimeType, Date.now());
+    return id;
+  },
+
+  updateDocumentStatus(id: string, status: string, chunkCount = 0, error?: string): void {
+    getDb().prepare("UPDATE kb_documents SET status = ?, chunk_count = ?, error = ? WHERE id = ?").run(status, chunkCount, error ?? null, id);
+  },
+
+  deleteDocument(id: string): boolean {
+    const result = getDb().prepare("DELETE FROM kb_documents WHERE id = ?").run(id);
+    return result.changes > 0;
+  },
+};