@usewhisper/mcp-server 0.1.0

package/dist/server.js

@@ -0,0 +1,1648 @@
+#\!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+// src/db/index.ts
+import { drizzle } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
+
+// src/db/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  apiKeys: () => apiKeys,
+  chunkTypeEnum: () => chunkTypeEnum,
+  chunks: () => chunks,
+  connectorTypeEnum: () => connectorTypeEnum,
+  conversations: () => conversations,
+  documents: () => documents,
+  entities: () => entities,
+  memories: () => memories,
+  memoryTypeEnum: () => memoryTypeEnum,
+  messages: () => messages,
+  organizations: () => organizations,
+  projects: () => projects,
+  queryCache: () => queryCache,
+  relationTypeEnum: () => relationTypeEnum,
+  relations: () => relations,
+  sourceStatusEnum: () => sourceStatusEnum,
+  sources: () => sources,
+  usageEvents: () => usageEvents,
+  webhooks: () => webhooks
+});
+import {
+  pgTable,
+  uuid,
+  text,
+  timestamp,
+  integer,
+  boolean,
+  jsonb,
+  vector,
+  index,
+  uniqueIndex,
+  pgEnum,
+  real,
+  serial
+} from "drizzle-orm/pg-core";
+var connectorTypeEnum = pgEnum("connector_type", [
+  "github",
+  "gitlab",
+  "url",
+  "sitemap",
+  "text",
+  "pdf",
+  "api_spec",
+  "database",
+  "confluence",
+  "notion",
+  "slack",
+  "discord",
+  "arxiv",
+  "huggingface",
+  "npm_package",
+  "pypi_package",
+  "custom"
+]);
+var sourceStatusEnum = pgEnum("source_status", [
+  "pending",
+  "indexing",
+  "ready",
+  "failed",
+  "stale",
+  "syncing"
+]);
+var chunkTypeEnum = pgEnum("chunk_type", [
+  "code",
+  "function",
+  "class",
+  "documentation",
+  "api_spec",
+  "schema",
+  "config",
+  "text",
+  "comment",
+  "readme",
+  "research",
+  "conversation",
+  "dataset"
+]);
+var memoryTypeEnum = pgEnum("memory_type", [
+  "factual",
+  // structured facts: "user prefers TypeScript"
+  "episodic",
+  // past interaction summaries
+  "semantic",
+  // general knowledge
+  "procedural"
+  // how-to knowledge
+]);
+var relationTypeEnum = pgEnum("relation_type", [
+  "imports",
+  "exports",
+  "calls",
+  "implements",
+  "extends",
+  "references",
+  "depends_on",
+  "related_to",
+  "part_of",
+  "contradicts",
+  "supersedes"
+]);
+var organizations = pgTable(
+  "organizations",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    whisperOrgId: text("whisper_org_id").unique(),
+    // link to main Whisper org
+    name: text("name").notNull(),
+    plan: text("plan").default("free").notNull(),
+    // free, pro, enterprise
+    settings: jsonb("settings").$type().default({}),
+    usageLimits: jsonb("usage_limits").$type().default({
+      queriesPerDay: 1e3,
+      documentsTotal: 1e4,
+      sourcesTotal: 50,
+      storageBytes: 1073741824
+      // 1GB
+    }),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull()
+  },
+  (t) => [
+    uniqueIndex("orgs_whisper_org_idx").on(t.whisperOrgId)
+  ]
+);
+var apiKeys = pgTable(
+  "api_keys",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    orgId: uuid("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    keyHash: text("key_hash").notNull(),
+    keyPrefix: text("key_prefix").notNull(),
+    // "wctx_xxxx" for identification
+    scopes: jsonb("scopes").$type().default(["read", "write"]),
+    rateLimit: integer("rate_limit").default(100),
+    // requests per minute
+    lastUsedAt: timestamp("last_used_at"),
+    expiresAt: timestamp("expires_at"),
+    isActive: boolean("is_active").default(true).notNull(),
+    createdAt: timestamp("created_at").defaultNow().notNull()
+  },
+  (t) => [
+    uniqueIndex("api_keys_hash_idx").on(t.keyHash),
+    index("api_keys_org_idx").on(t.orgId),
+    index("api_keys_prefix_idx").on(t.keyPrefix)
+  ]
+);
+var projects = pgTable(
+  "projects",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    orgId: uuid("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    slug: text("slug").notNull(),
+    description: text("description"),
+    settings: jsonb("settings").$type().default({
+      embeddingModel: "text-embedding-3-small",
+      embeddingDimensions: 1536,
+      chunkSize: 1e3,
+      chunkOverlap: 200,
+      defaultTopK: 10,
+      defaultThreshold: 0.3
+    }),
+    isPublic: boolean("is_public").default(false).notNull(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull()
+  },
+  (t) => [
+    uniqueIndex("projects_org_slug_idx").on(t.orgId, t.slug),
+    index("projects_org_idx").on(t.orgId),
+    index("projects_public_idx").on(t.isPublic)
+  ]
+);
+var sources = pgTable(
+  "sources",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    projectId: uuid("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    connectorType: connectorTypeEnum("connector_type").notNull(),
+    name: text("name").notNull(),
+    config: jsonb("config").$type().default({}),
+    status: sourceStatusEnum("status").default("pending").notNull(),
+    syncSchedule: text("sync_schedule"),
+    // cron expression for auto-sync
+    lastSyncAt: timestamp("last_sync_at"),
+    lastSyncDurationMs: integer("last_sync_duration_ms"),
+    syncError: text("sync_error"),
+    documentCount: integer("document_count").default(0),
+    chunkCount: integer("chunk_count").default(0),
+    contentHash: text("content_hash"),
+    // for change detection
+    metadata: jsonb("metadata").$type().default({}),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull()
+  },
+  (t) => [
+    index("sources_project_idx").on(t.projectId),
+    index("sources_status_idx").on(t.status),
+    index("sources_type_idx").on(t.connectorType)
+  ]
+);
+var documents = pgTable(
+  "documents",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    sourceId: uuid("source_id").notNull().references(() => sources.id, { onDelete: "cascade" }),
+    projectId: uuid("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    externalId: text("external_id"),
+    title: text("title"),
+    content: text("content"),
+    contentHash: text("content_hash"),
+    url: text("url"),
+    language: text("language"),
+    // programming language or natural language
+    metadata: jsonb("metadata").$type().default({}),
+    tokenCount: integer("token_count").default(0),
+    isActive: boolean("is_active").default(true).notNull(),
+    lastIndexedAt: timestamp("last_indexed_at"),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull()
+  },
+  (t) => [
+    index("documents_source_idx").on(t.sourceId),
+    index("documents_project_idx").on(t.projectId),
+    uniqueIndex("documents_source_external_idx").on(t.sourceId, t.externalId),
+    index("documents_hash_idx").on(t.contentHash),
+    index("documents_active_idx").on(t.projectId, t.isActive)
+  ]
+);
+var chunks = pgTable(
+  "chunks",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    documentId: uuid("document_id").notNull().references(() => documents.id, { onDelete: "cascade" }),
+    projectId: uuid("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    content: text("content").notNull(),
+    chunkType: chunkTypeEnum("chunk_type").default("text").notNull(),
+    chunkIndex: integer("chunk_index").default(0),
+    // Search
+    embedding: vector("embedding", { dimensions: 1536 }),
+    // Full-text search column (populated via trigger or app)
+    searchContent: text("search_content"),
+    // stripped/normalized for BM25
+    // Metadata
+    metadata: jsonb("metadata").$type().default({}),
+    tokenCount: integer("token_count").default(0),
+    createdAt: timestamp("created_at").defaultNow().notNull()
+  },
+  (t) => [
+    index("chunks_document_idx").on(t.documentId),
+    index("chunks_project_idx").on(t.projectId),
+    index("chunks_type_idx").on(t.chunkType),
+    index("chunks_project_type_idx").on(t.projectId, t.chunkType)
+  ]
+);
+var entities = pgTable(
+  "entities",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    projectId: uuid("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    name: text("name").notNull(),
+    entityType: text("entity_type").notNull(),
+    // function, class, module, concept, api_endpoint, etc.
+    description: text("description"),
+    metadata: jsonb("metadata").$type().default({}),
+    sourceChunkId: uuid("source_chunk_id").references(() => chunks.id, { onDelete: "set null" }),
+    embedding: vector("embedding", { dimensions: 1536 }),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull()
+  },
+  (t) => [
+    index("entities_project_idx").on(t.projectId),
+    index("entities_type_idx").on(t.projectId, t.entityType),
+    uniqueIndex("entities_project_name_type_idx").on(t.projectId, t.name, t.entityType)
+  ]
+);
+var relations = pgTable(
+  "relations",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    projectId: uuid("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    fromEntityId: uuid("from_entity_id").notNull().references(() => entities.id, { onDelete: "cascade" }),
+    toEntityId: uuid("to_entity_id").notNull().references(() => entities.id, { onDelete: "cascade" }),
+    relationType: relationTypeEnum("relation_type").notNull(),
+    weight: real("weight").default(1),
+    metadata: jsonb("metadata").$type().default({}),
+    createdAt: timestamp("created_at").defaultNow().notNull()
+  },
+  (t) => [
+    index("relations_project_idx").on(t.projectId),
+    index("relations_from_idx").on(t.fromEntityId),
+    index("relations_to_idx").on(t.toEntityId),
+    uniqueIndex("relations_unique_idx").on(t.fromEntityId, t.toEntityId, t.relationType)
+  ]
+);
+var memories = pgTable(
+  "memories",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    projectId: uuid("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    // Scoping
+    userId: text("user_id"),
+    // user-scoped memory
+    sessionId: text("session_id"),
+    // session-scoped memory
+    agentId: text("agent_id"),
+    // agent-scoped memory
+    // Memory content
+    memoryType: memoryTypeEnum("memory_type").default("factual").notNull(),
+    content: text("content").notNull(),
+    summary: text("summary"),
+    // LLM-generated summary
+    embedding: vector("embedding", { dimensions: 1536 }),
+    // Management
+    importance: real("importance").default(0.5),
+    // 0-1 how important is this
+    accessCount: integer("access_count").default(0),
+    lastAccessedAt: timestamp("last_accessed_at"),
+    expiresAt: timestamp("expires_at"),
+    // optional TTL
+    metadata: jsonb("metadata").$type().default({}),
+    isActive: boolean("is_active").default(true).notNull(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull()
+  },
+  (t) => [
+    index("memories_project_idx").on(t.projectId),
+    index("memories_user_idx").on(t.projectId, t.userId),
+    index("memories_session_idx").on(t.projectId, t.sessionId),
+    index("memories_agent_idx").on(t.projectId, t.agentId),
+    index("memories_type_idx").on(t.projectId, t.memoryType),
+    index("memories_active_idx").on(t.projectId, t.isActive),
+    index("memories_expires_idx").on(t.expiresAt)
+  ]
+);
+var conversations = pgTable(
+  "conversations",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    projectId: uuid("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    sessionId: text("session_id"),
+    userId: text("user_id"),
+    agentId: text("agent_id"),
+    title: text("title"),
+    summary: text("summary"),
+    embedding: vector("embedding", { dimensions: 1536 }),
+    metadata: jsonb("metadata").$type().default({}),
+    messageCount: integer("message_count").default(0),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull()
+  },
+  (t) => [
+    index("conversations_project_idx").on(t.projectId),
+    index("conversations_session_idx").on(t.sessionId),
+    index("conversations_user_idx").on(t.userId)
+  ]
+);
+var messages = pgTable(
+  "messages",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    conversationId: uuid("conversation_id").notNull().references(() => conversations.id, { onDelete: "cascade" }),
+    role: text("role").notNull(),
+    // user, assistant, system, tool
+    content: text("content").notNull(),
+    metadata: jsonb("metadata").$type().default({}),
+    createdAt: timestamp("created_at").defaultNow().notNull()
+  },
+  (t) => [
+    index("messages_conversation_idx").on(t.conversationId),
+    index("messages_created_idx").on(t.conversationId, t.createdAt)
+  ]
+);
+var webhooks = pgTable(
+  "webhooks",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    orgId: uuid("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
+    url: text("url").notNull(),
+    secret: text("secret").notNull(),
+    events: jsonb("events").$type().default([
+      "source.synced",
+      "document.indexed",
+      "memory.created"
+    ]),
+    isActive: boolean("is_active").default(true).notNull(),
+    lastDeliveredAt: timestamp("last_delivered_at"),
+    failureCount: integer("failure_count").default(0),
+    createdAt: timestamp("created_at").defaultNow().notNull()
+  },
+  (t) => [
+    index("webhooks_org_idx").on(t.orgId)
+  ]
+);
+var usageEvents = pgTable(
+  "usage_events",
+  {
+    id: serial("id").primaryKey(),
+    orgId: uuid("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
+    projectId: uuid("project_id"),
+    eventType: text("event_type").notNull(),
+    // query, ingest, sync, memory_add, memory_search
+    source: text("source").default("api"),
+    // api, mcp, sdk, webhook
+    tokensUsed: integer("tokens_used").default(0),
+    embeddingTokens: integer("embedding_tokens").default(0),
+    latencyMs: integer("latency_ms"),
+    metadata: jsonb("metadata").$type().default({}),
+    createdAt: timestamp("created_at").defaultNow().notNull()
+  },
+  (t) => [
+    index("usage_org_idx").on(t.orgId),
+    index("usage_project_idx").on(t.projectId),
+    index("usage_type_idx").on(t.eventType),
+    index("usage_created_idx").on(t.createdAt),
+    index("usage_org_created_idx").on(t.orgId, t.createdAt)
+  ]
+);
+var queryCache = pgTable(
+  "query_cache",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    projectId: uuid("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+    queryHash: text("query_hash").notNull(),
+    query: text("query").notNull(),
+    results: jsonb("results").$type().default([]),
+    hitCount: integer("hit_count").default(0),
+    expiresAt: timestamp("expires_at").notNull(),
+    createdAt: timestamp("created_at").defaultNow().notNull()
+  },
+  (t) => [
+    uniqueIndex("cache_project_query_idx").on(t.projectId, t.queryHash),
+    index("cache_expires_idx").on(t.expiresAt)
+  ]
+);
+
+// src/db/index.ts
+var connectionString = process.env.DATABASE_URL;
+var client = postgres(connectionString, { max: 10 });
+var db = drizzle(client, { schema: schema_exports });
+
+// src/mcp/server.ts
+import { eq as eq3, and as and2, sql as sql2 } from "drizzle-orm";
+
+// src/engine/retriever.ts
+import { eq, sql, and, inArray, or, isNull, gt } from "drizzle-orm";
+
+// src/engine/embeddings.ts
+import OpenAI from "openai";
+var openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+async function embed(texts) {
+  const res = await openai.embeddings.create({
+    model: "text-embedding-3-small",
+    input: texts,
+    dimensions: 1536
+  });
+  return res.data.map((d) => d.embedding);
+}
+async function embedSingle(text2) {
+  const [embedding] = await embed([text2]);
+  return embedding;
+}
+
+// src/engine/compressor.ts
+import OpenAI2 from "openai";
+import { createHash } from "crypto";
+var openai2 = new OpenAI2({ apiKey: process.env.OPENAI_API_KEY });
+var deltaCache = /* @__PURE__ */ new Map();
+var DELTA_CACHE_TTL = 6e5;
+function hashContext(text2) {
+  return createHash("sha256").update(text2).digest("hex").slice(0, 16);
+}
+async function compressContext(rawContext, opts = {}) {
+  const {
+    maxTokens = 4e3,
+    strategy = "adaptive",
+    previousContextHash,
+    previousContext,
+    targetReduction = 0.5
+  } = opts;
+  const originalTokens = estimateTokens(rawContext);
+  if (originalTokens <= maxTokens) {
+    return {
+      context: rawContext,
+      originalTokens,
+      compressedTokens: originalTokens,
+      reductionPercent: 0,
+      strategy: "none"
+    };
+  }
+  switch (strategy) {
+    case "delta":
+      return deltaCompress(rawContext, originalTokens, maxTokens, previousContextHash, previousContext);
+    case "summarize":
+      return summarizeCompress(rawContext, originalTokens, maxTokens);
+    case "extract":
+      return extractCompress(rawContext, originalTokens, maxTokens);
+    case "adaptive":
+    default:
+      return adaptiveCompress(rawContext, originalTokens, maxTokens, previousContextHash, previousContext);
+  }
+}
+async function adaptiveCompress(rawContext, originalTokens, maxTokens, previousHash, previousCtx) {
+  const ratio = originalTokens / maxTokens;
+  if (previousHash || previousCtx) {
+    const delta = await deltaCompress(rawContext, originalTokens, maxTokens, previousHash, previousCtx);
+    if (delta.compressedTokens <= maxTokens) return delta;
+  }
+  if (ratio < 2) {
+    return extractCompress(rawContext, originalTokens, maxTokens);
+  }
+  return summarizeCompress(rawContext, originalTokens, maxTokens);
+}
+async function deltaCompress(rawContext, originalTokens, maxTokens, previousHash, previousCtx) {
+  const currentHash = hashContext(rawContext);
+  if (previousHash && previousHash === currentHash) {
+    return {
+      context: "[No changes since last context]",
+      originalTokens,
+      compressedTokens: 8,
+      reductionPercent: 99,
+      strategy: "delta-identical"
+    };
+  }
+  let prevCtx = previousCtx;
+  if (!prevCtx && previousHash) {
+    const cached = deltaCache.get(previousHash);
+    if (cached && Date.now() - cached.timestamp < DELTA_CACHE_TTL) {
+      prevCtx = cached.context;
+    }
+  }
+  if (!prevCtx) {
+    return extractCompress(rawContext, originalTokens, maxTokens);
+  }
+  const prevBlocks = new Set(prevCtx.split("\n---\n").map((b) => b.trim()));
+  const currentBlocks = rawContext.split("\n---\n").map((b) => b.trim());
+  const newBlocks = [];
+  const unchangedCount = { count: 0 };
+  for (const block of currentBlocks) {
+    if (prevBlocks.has(block)) {
+      unchangedCount.count++;
+    } else {
+      newBlocks.push(block);
+    }
+  }
+  let deltaContext;
+  if (newBlocks.length === 0) {
+    deltaContext = "[No new information since last query]";
+  } else {
+    const header = `[${unchangedCount.count} unchanged results omitted, ${newBlocks.length} new/updated]
+
+`;
+    deltaContext = header + newBlocks.join("\n---\n");
+  }
+  const deltaTokens = estimateTokens(deltaContext);
+  if (deltaTokens > maxTokens) {
+    const truncated = truncateToTokens(deltaContext, maxTokens);
+    deltaCache.set(currentHash, { context: rawContext, hash: currentHash, timestamp: Date.now() });
+    return {
+      context: truncated,
+      originalTokens,
+      compressedTokens: estimateTokens(truncated),
+      reductionPercent: Math.round((1 - estimateTokens(truncated) / originalTokens) * 100),
+      strategy: "delta-truncated"
+    };
+  }
+  deltaCache.set(currentHash, { context: rawContext, hash: currentHash, timestamp: Date.now() });
+  return {
+    context: deltaContext,
+    originalTokens,
+    compressedTokens: estimateTokens(deltaContext),
+    reductionPercent: Math.round((1 - estimateTokens(deltaContext) / originalTokens) * 100),
+    strategy: "delta"
+  };
+}
+async function extractCompress(rawContext, originalTokens, maxTokens) {
+  try {
+    const res = await openai2.chat.completions.create({
+      model: "gpt-4.1-nano",
+      messages: [
+        {
+          role: "system",
+          content: `You are a context compressor. Extract and preserve ONLY the most important information from the provided context. Remove redundancy, boilerplate, and low-value content. Keep code snippets, key facts, API signatures, and important relationships. Output should be ${maxTokens} tokens or less. Do NOT add commentary \u2014 just output the compressed context.`
+        },
+        { role: "user", content: rawContext }
+      ],
+      max_tokens: maxTokens,
+      temperature: 0
+    });
+    const compressed = res.choices[0]?.message?.content?.trim() || rawContext;
+    const compressedTokens = estimateTokens(compressed);
+    return {
+      context: compressed,
+      originalTokens,
+      compressedTokens,
+      reductionPercent: Math.round((1 - compressedTokens / originalTokens) * 100),
+      strategy: "extract"
+    };
+  } catch {
+    const truncated = truncateToTokens(rawContext, maxTokens);
+    return {
+      context: truncated,
+      originalTokens,
+      compressedTokens: estimateTokens(truncated),
+      reductionPercent: Math.round((1 - estimateTokens(truncated) / originalTokens) * 100),
+      strategy: "truncate-fallback"
+    };
+  }
+}
+async function summarizeCompress(rawContext, originalTokens, maxTokens) {
+  const blocks = rawContext.split("\n---\n").filter((b) => b.trim());
+  if (blocks.length <= 3) {
+    return extractCompress(rawContext, originalTokens, maxTokens);
+  }
+  const budgetPerBlock = Math.floor(maxTokens / blocks.length);
+  try {
+    const summaries = await Promise.all(
+      blocks.map(async (block) => {
+        if (estimateTokens(block) <= budgetPerBlock) return block;
+        const res = await openai2.chat.completions.create({
+          model: "gpt-4.1-nano",
+          messages: [
+            {
+              role: "system",
+              content: `Summarize this context block in ${budgetPerBlock} tokens or less. Preserve code signatures, key facts, and important details. Output only the summary.`
+            },
+            { role: "user", content: block }
+          ],
+          max_tokens: budgetPerBlock,
+          temperature: 0
+        });
+        return res.choices[0]?.message?.content?.trim() || block.slice(0, budgetPerBlock * 4);
+      })
+    );
+    const compressed = summaries.join("\n\n---\n\n");
+    let compressedTokens = estimateTokens(compressed);
+    let finalContext = compressed;
+    if (compressedTokens > maxTokens) {
+      finalContext = truncateToTokens(compressed, maxTokens);
+      compressedTokens = estimateTokens(finalContext);
+    }
+    return {
+      context: finalContext,
+      originalTokens,
+      compressedTokens,
+      reductionPercent: Math.round((1 - compressedTokens / originalTokens) * 100),
+      strategy: "summarize"
+    };
+  } catch {
+    const truncated = truncateToTokens(rawContext, maxTokens);
+    return {
+      context: truncated,
+      originalTokens,
+      compressedTokens: estimateTokens(truncated),
+      reductionPercent: Math.round((1 - estimateTokens(truncated) / originalTokens) * 100),
+      strategy: "truncate-fallback"
+    };
+  }
+}
+function estimateTokens(text2) {
+  return Math.ceil(text2.length / 4);
+}
+function truncateToTokens(text2, maxTokens) {
+  const maxChars = maxTokens * 4;
+  if (text2.length <= maxChars) return text2;
+  return text2.slice(0, maxChars) + "\n\n[...truncated]";
+}
+setInterval(() => {
+  const now = Date.now();
+  for (const [key, val] of deltaCache) {
+    if (now - val.timestamp > DELTA_CACHE_TTL) deltaCache.delete(key);
+  }
+}, 6e4);
+
+// src/engine/retriever.ts
+import { createHash as createHash2 } from "crypto";
+import OpenAI3 from "openai";
+var openai3 = new OpenAI3({ apiKey: process.env.OPENAI_API_KEY });
+async function retrieve(opts) {
+  const {
+    projectId,
+    query,
+    topK = 10,
+    threshold = 0.3,
+    chunkTypes,
+    hybridSearch = true,
+    vectorWeight = 0.7,
+    bm25Weight = 0.3,
+    rerank = true,
+    rerankTopK,
+    includeMemories = false,
+    userId,
+    sessionId,
+    agentId,
+    includeGraph = false,
+    graphDepth = 1,
+    maxTokens,
+    compress = false,
+    compressionStrategy = "adaptive",
+    previousContextHash,
+    useCache = true,
+    cacheTtlSeconds = 300
+  } = opts;
+  const startTime = Date.now();
+  if (useCache) {
+    const cached = await checkCache(projectId, query);
+    if (cached) {
+      return {
+        results: cached,
+        context: packContext(cached, maxTokens),
+        meta: {
+          totalResults: cached.length,
+          latencyMs: Date.now() - startTime,
+          cacheHit: true,
+          tokensUsed: 0
+        }
+      };
+    }
+  }
+  const queryEmbedding = await embedSingle(query);
+  let allResults = [];
+  const vectorResults = await vectorSearch(projectId, queryEmbedding, topK * 2, chunkTypes);
+  allResults.push(...vectorResults);
+  if (hybridSearch) {
+    const bm25Results = await fullTextSearch(projectId, query, topK * 2, chunkTypes);
+    allResults.push(...bm25Results);
+  }
+  if (includeMemories) {
+    const memoryResults = await memorySearch(projectId, queryEmbedding, {
+      userId,
+      sessionId,
+      agentId,
+      topK: Math.ceil(topK / 3)
+    });
+    allResults.push(...memoryResults);
+  }
+  if (includeGraph) {
+    const graphResults = await graphSearch(projectId, queryEmbedding, {
+      depth: graphDepth,
+      topK: Math.ceil(topK / 3)
+    });
+    allResults.push(...graphResults);
+  }
+  allResults = deduplicateResults(allResults);
+  if (hybridSearch) {
+    allResults = reciprocalRankFusion(allResults, vectorWeight, bm25Weight);
+  }
+  allResults = allResults.filter((r) => r.score >= threshold);
+  if (rerank && allResults.length > 0) {
+    const reranked = await rerankResults(query, allResults, rerankTopK || topK);
+    allResults = reranked;
+  }
+  allResults = allResults.slice(0, topK);
+  allResults = await enrichResults(allResults);
+  let context = packContext(allResults, maxTokens);
+  const contextHash = createHash2("sha256").update(context).digest("hex").slice(0, 16);
+  let compressionMeta;
+  if (compress && context.length > 0) {
+    const compressed = await compressContext(context, {
+      maxTokens: maxTokens || 4e3,
+      strategy: compressionStrategy,
+      previousContextHash
+    });
+    context = compressed.context;
+    compressionMeta = {
+      originalTokens: compressed.originalTokens,
+      compressedTokens: compressed.compressedTokens,
+      reductionPercent: compressed.reductionPercent,
+      strategy: compressed.strategy
+    };
+  }
+  if (useCache && allResults.length > 0) {
+    await setCache(projectId, query, allResults, cacheTtlSeconds);
+  }
+  const latencyMs = Date.now() - startTime;
+  return {
+    results: allResults,
+    context,
+    meta: {
+      totalResults: allResults.length,
+      latencyMs,
+      cacheHit: false,
+      tokensUsed: estimateTokens2(context),
+      contextHash,
+      compression: compressionMeta
+    }
+  };
+}
+async function vectorSearch(projectId, queryEmbedding, limit, chunkTypes) {
+  const conditions = [eq(chunks.projectId, projectId)];
+  if (chunkTypes && chunkTypes.length > 0) {
+    conditions.push(inArray(chunks.chunkType, chunkTypes));
+  }
+  const results = await db.select({
+    id: chunks.id,
+    content: chunks.content,
+    chunkType: chunks.chunkType,
+    metadata: chunks.metadata,
+    documentId: chunks.documentId,
+    similarity: sql`1 - (${chunks.embedding} <=> ${JSON.stringify(queryEmbedding)}::vector)`
+  }).from(chunks).where(and(...conditions)).orderBy(sql`${chunks.embedding} <=> ${JSON.stringify(queryEmbedding)}::vector`).limit(limit);
+  return results.map((r) => ({
+    id: r.id,
+    content: r.content,
+    score: r.similarity,
+    metadata: r.metadata || {},
+    chunkType: r.chunkType,
+    source: "vector"
+  }));
+}
+async function fullTextSearch(projectId, query, limit, chunkTypes) {
+  const tsQuery = query.replace(/[^\w\s]/g, " ").trim().split(/\s+/).filter((w) => w.length > 1).join(" & ");
+  if (!tsQuery) return [];
+  const conditions = [eq(chunks.projectId, projectId)];
+  if (chunkTypes && chunkTypes.length > 0) {
+    conditions.push(inArray(chunks.chunkType, chunkTypes));
+  }
+  const results = await db.select({
+    id: chunks.id,
+    content: chunks.content,
+    chunkType: chunks.chunkType,
+    metadata: chunks.metadata,
+    documentId: chunks.documentId,
+    rank: sql`ts_rank(to_tsvector('english', coalesce(${chunks.searchContent}, ${chunks.content})), to_tsquery('english', ${tsQuery}))`
+  }).from(chunks).where(
+    and(
+      ...conditions,
+      sql`to_tsvector('english', coalesce(${chunks.searchContent}, ${chunks.content})) @@ to_tsquery('english', ${tsQuery})`
+    )
+  ).orderBy(sql`ts_rank(to_tsvector('english', coalesce(${chunks.searchContent}, ${chunks.content})), to_tsquery('english', ${tsQuery})) DESC`).limit(limit);
+  const maxRank = results.length > 0 ? Math.max(...results.map((r) => r.rank)) : 1;
+  return results.map((r) => ({
+    id: r.id,
+    content: r.content,
+    score: maxRank > 0 ? r.rank / maxRank : 0,
+    metadata: r.metadata || {},
+    chunkType: r.chunkType,
+    source: "bm25"
+  }));
+}
+async function memorySearch(projectId, queryEmbedding, opts) {
+  const conditions = [
+    eq(memories.projectId, projectId),
+    eq(memories.isActive, true),
+    or(isNull(memories.expiresAt), gt(memories.expiresAt, /* @__PURE__ */ new Date()))
+  ];
+  if (opts.userId) conditions.push(eq(memories.userId, opts.userId));
+  if (opts.sessionId) conditions.push(eq(memories.sessionId, opts.sessionId));
+  if (opts.agentId) conditions.push(eq(memories.agentId, opts.agentId));
+  const results = await db.select({
+    id: memories.id,
+    content: memories.content,
+    memoryType: memories.memoryType,
+    metadata: memories.metadata,
+    importance: memories.importance,
+    similarity: sql`1 - (${memories.embedding} <=> ${JSON.stringify(queryEmbedding)}::vector)`
+  }).from(memories).where(and(...conditions)).orderBy(sql`${memories.embedding} <=> ${JSON.stringify(queryEmbedding)}::vector`).limit(opts.topK);
+  if (results.length > 0) {
+    const ids = results.map((r) => r.id);
+    await db.update(memories).set({
+      accessCount: sql`${memories.accessCount} + 1`,
+      lastAccessedAt: /* @__PURE__ */ new Date()
+    }).where(inArray(memories.id, ids));
+  }
+  return results.map((r) => ({
+    id: r.id,
+    content: r.content,
+    score: r.similarity * (r.importance || 0.5),
+    metadata: { ...r.metadata, memoryType: r.memoryType },
+    chunkType: "memory",
+    source: "memory"
+  }));
+}
+async function graphSearch(projectId, queryEmbedding, opts) {
+  const relevantEntities = await db.select({
+    id: entities.id,
+    name: entities.name,
+    entityType: entities.entityType,
+    description: entities.description,
+    metadata: entities.metadata,
+    sourceChunkId: entities.sourceChunkId,
+    similarity: sql`1 - (${entities.embedding} <=> ${JSON.stringify(queryEmbedding)}::vector)`
+  }).from(entities).where(eq(entities.projectId, projectId)).orderBy(sql`${entities.embedding} <=> ${JSON.stringify(queryEmbedding)}::vector`).limit(5);
+  if (relevantEntities.length === 0) return [];
+  const entityIds = relevantEntities.map((e) => e.id);
+  const relatedEntities = await db.select({
+    id: entities.id,
+    name: entities.name,
+    entityType: entities.entityType,
+    description: entities.description,
+    metadata: entities.metadata,
+    sourceChunkId: entities.sourceChunkId,
+    relationType: relations.relationType,
+    weight: relations.weight
+  }).from(relations).innerJoin(entities, eq(relations.toEntityId, entities.id)).where(
+    and(
+      eq(relations.projectId, projectId),
+      inArray(relations.fromEntityId, entityIds)
+    )
+  ).limit(opts.topK);
+  const chunkIds = [
+    ...relevantEntities.map((e) => e.sourceChunkId).filter(Boolean),
+    ...relatedEntities.map((e) => e.sourceChunkId).filter(Boolean)
+  ];
+  if (chunkIds.length === 0) return [];
+  const relatedChunks = await db.select().from(chunks).where(inArray(chunks.id, chunkIds));
+  return relatedChunks.map((c) => {
+    const entity = relevantEntities.find((e) => e.sourceChunkId === c.id);
+    return {
+      id: c.id,
+      content: c.content,
+      score: entity ? entity.similarity * 0.8 : 0.5,
+      metadata: {
+        ...c.metadata,
+        entityName: entity?.name,
+        entityType: entity?.entityType
+      },
+      chunkType: c.chunkType,
+      source: "graph"
+    };
+  });
+}
+function reciprocalRankFusion(results, vectorWeight, bm25Weight, k = 60) {
+  const scoreMap = /* @__PURE__ */ new Map();
+  const vectorResults = results.filter((r) => r.source === "vector");
+  const bm25Results = results.filter((r) => r.source === "bm25");
+  const otherResults = results.filter((r) => r.source !== "vector" && r.source !== "bm25");
+  vectorResults.forEach((r, rank) => {
+    const existing = scoreMap.get(r.id);
+    const rrfScore = vectorWeight / (k + rank + 1);
+    if (existing) {
+      existing.score += rrfScore;
+    } else {
+      scoreMap.set(r.id, { result: r, score: rrfScore });
+    }
+  });
+  bm25Results.forEach((r, rank) => {
+    const existing = scoreMap.get(r.id);
+    const rrfScore = bm25Weight / (k + rank + 1);
+    if (existing) {
+      existing.score += rrfScore;
+      existing.result.source = "hybrid";
+    } else {
+      scoreMap.set(r.id, { result: { ...r, source: "hybrid" }, score: rrfScore });
+    }
+  });
+  otherResults.forEach((r) => {
+    if (!scoreMap.has(r.id)) {
+      scoreMap.set(r.id, { result: r, score: r.score * 0.5 });
+    }
+  });
+  return Array.from(scoreMap.values()).sort((a, b) => b.score - a.score).map((entry) => ({ ...entry.result, score: entry.score }));
+}
+async function rerankResults(query, results, topK) {
+  if (results.length <= 3) return results;
+  const candidates = results.slice(0, Math.min(results.length, topK * 3));
+  const prompt = `Given the query: "${query}"
+
+Rank these ${candidates.length} text passages by relevance (most relevant first). Return ONLY a JSON array of indices (0-based), e.g. [2, 0, 4, 1, 3].
+
+${candidates.map((r, i) => `[${i}] ${r.content.slice(0, 300)}`).join("\n\n")}`;
+  try {
+    const res = await openai3.chat.completions.create({
+      model: "gpt-4.1-nano",
+      messages: [{ role: "user", content: prompt }],
+      temperature: 0,
+      max_tokens: 200
+    });
+    const text2 = res.choices[0]?.message?.content?.trim() || "";
+    const match = text2.match(/\[[\d,\s]+\]/);
+    if (!match) return results;
+    const indices = JSON.parse(match[0]);
+    const reranked = [];
+    for (const idx of indices) {
+      if (idx >= 0 && idx < candidates.length) {
+        reranked.push({
+          ...candidates[idx],
+          score: 1 - reranked.length * (1 / indices.length)
+          // normalize
+        });
+      }
+    }
+    for (const r of results) {
+      if (!reranked.find((rr) => rr.id === r.id)) {
+        reranked.push(r);
+      }
+    }
+    return reranked.slice(0, topK);
+  } catch {
+    return results.slice(0, topK);
+  }
+}
+function deduplicateResults(results) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const r of results) {
+    const existing = seen.get(r.id);
+    if (!existing || r.score > existing.score) {
+      seen.set(r.id, r);
+    }
+  }
+  return Array.from(seen.values());
+}
+function packContext(results, maxTokens) {
+  if (results.length === 0) return "";
+  const limit = maxTokens || 8e3;
+  let totalTokens = 0;
+  const packed = [];
+  for (const r of results) {
+    const header = buildChunkHeader(r);
+    const block = `${header}
+${r.content}
+`;
+    const tokens = estimateTokens2(block);
+    if (totalTokens + tokens > limit) break;
+    packed.push(block);
+    totalTokens += tokens;
+  }
+  return packed.join("\n---\n\n");
+}
+function buildChunkHeader(r) {
+  const parts = [];
+  if (r.sourceName) parts.push(`Source: ${r.sourceName}`);
+  if (r.documentTitle) parts.push(`Document: ${r.documentTitle}`);
+  if (r.metadata?.filePath) parts.push(`File: ${r.metadata.filePath}`);
+  if (r.metadata?.startLine) parts.push(`Lines: ${r.metadata.startLine}-${r.metadata.endLine || "?"}`);
+  if (r.chunkType && r.chunkType !== "text") parts.push(`Type: ${r.chunkType}`);
+  return parts.length > 0 ? `[${parts.join(" | ")}]` : "";
+}
+function estimateTokens2(text2) {
+  return Math.ceil(text2.length / 4);
+}
+async function enrichResults(results) {
+  const chunkResults = results.filter((r) => r.source !== "memory");
+  if (chunkResults.length === 0) return results;
+  const chunkIds = chunkResults.map((r) => r.id);
+  const chunkDocs = await db.select({
+    chunkId: chunks.id,
+    docTitle: documents.title,
+    sourceName: sources.name,
+    docId: documents.id,
+    sourceId: sources.id
+  }).from(chunks).innerJoin(documents, eq(chunks.documentId, documents.id)).innerJoin(sources, eq(documents.sourceId, sources.id)).where(inArray(chunks.id, chunkIds));
+  const enrichMap = new Map(chunkDocs.map((d) => [d.chunkId, d]));
+  return results.map((r) => {
+    const enrichment = enrichMap.get(r.id);
+    if (enrichment) {
+      return {
+        ...r,
+        documentTitle: enrichment.docTitle || void 0,
+        sourceName: enrichment.sourceName || void 0
+      };
+    }
+    return r;
+  });
+}
+function hashQuery(query) {
+  return createHash2("sha256").update(query.toLowerCase().trim()).digest("hex");
+}
+async function checkCache(projectId, query) {
+  const hash = hashQuery(query);
+  const [cached] = await db.select().from(queryCache).where(
+    and(
+      eq(queryCache.projectId, projectId),
+      eq(queryCache.queryHash, hash),
+      gt(queryCache.expiresAt, /* @__PURE__ */ new Date())
+    )
+  ).limit(1);
+  if (cached) {
+    await db.update(queryCache).set({ hitCount: sql`${queryCache.hitCount} + 1` }).where(eq(queryCache.id, cached.id));
+    return cached.results;
+  }
+  return null;
+}
+async function setCache(projectId, query, results, ttlSeconds) {
+  const hash = hashQuery(query);
+  const expiresAt = new Date(Date.now() + ttlSeconds * 1e3);
+  await db.insert(queryCache).values({
+    projectId,
+    queryHash: hash,
+    query,
+    results,
+    expiresAt
+  }).onConflictDoUpdate({
+    target: [queryCache.projectId, queryCache.queryHash],
+    set: { results, expiresAt, hitCount: 0 }
+  });
+}
+
+// src/engine/ingest.ts
+import { eq as eq2 } from "drizzle-orm";
+
+// src/engine/chunker.ts
+var CODE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".py",
+  ".java",
+  ".go",
+  ".rb",
+  ".php",
+  ".cs",
+  ".rs",
+  ".swift",
+  ".kt",
+  ".scala",
+  ".c",
+  ".cpp",
+  ".h",
+  ".hpp",
+  ".sol",
+  ".vy"
+]);
+var CONFIG_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".json",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".ini",
+  ".env",
+  ".xml"
+]);
+function detectChunkType(filePath, content) {
+  if (!filePath) return "text";
+  const ext = "." + filePath.split(".").pop()?.toLowerCase();
+  if (CODE_EXTENSIONS.has(ext)) return "code";
+  if (CONFIG_EXTENSIONS.has(ext)) return "config";
+  if (filePath.includes("schema") || filePath.includes("migration")) return "schema";
+  if (filePath.endsWith(".md") || filePath.endsWith(".mdx") || filePath.endsWith(".rst")) return "documentation";
+  if (filePath.includes("openapi") || filePath.includes("swagger")) return "api_spec";
+  return "text";
+}
+function chunkText(content, opts = {}) {
+  const { chunkSize = 1e3, chunkOverlap = 200, filePath, metadata = {} } = opts;
+  const chunkType = detectChunkType(filePath, content);
+  if (chunkType === "code") {
+    return chunkCode(content, { chunkSize, filePath, metadata });
+  }
+  return chunkBySize(content, { chunkSize, chunkOverlap, chunkType, metadata });
+}
+function chunkCode(content, opts) {
+  const { chunkSize, filePath, metadata = {} } = opts;
+  const lines = content.split("\n");
+  const chunks2 = [];
+  const boundaries = [
+    /^(export\s+)?(async\s+)?function\s+/,
+    /^(export\s+)?(default\s+)?class\s+/,
+    /^(export\s+)?const\s+\w+\s*=\s*(async\s+)?\(/,
+    /^(export\s+)?const\s+\w+\s*=\s*\{/,
+    /^(export\s+)?interface\s+/,
+    /^(export\s+)?type\s+/,
+    /^(export\s+)?enum\s+/,
+    /^def\s+/,
+    // Python
+    /^class\s+/,
+    // Python/Java
+    /^func\s+/,
+    // Go
+    /^pub\s+(fn|struct|enum|impl)/
+    // Rust
+  ];
+  let currentChunk = [];
+  let currentStart = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trimStart();
+    const isBoundary = boundaries.some((b) => b.test(trimmed));
+    if (isBoundary && currentChunk.length > 0) {
+      const chunkContent = currentChunk.join("\n").trim();
+      if (chunkContent.length > 0) {
+        chunks2.push({
+          content: chunkContent,
+          chunkType: "code",
+          chunkIndex: chunks2.length,
+          metadata: {
+            ...metadata,
+            filePath,
+            startLine: currentStart + 1,
+            endLine: i
+          }
+        });
+      }
+      currentChunk = [lines[i]];
+      currentStart = i;
+    } else {
+      currentChunk.push(lines[i]);
+    }
+    if (currentChunk.join("\n").length > chunkSize * 1.5) {
+      const chunkContent = currentChunk.join("\n").trim();
+      if (chunkContent.length > 0) {
+        chunks2.push({
+          content: chunkContent,
+          chunkType: "code",
+          chunkIndex: chunks2.length,
+          metadata: {
+            ...metadata,
+            filePath,
+            startLine: currentStart + 1,
+            endLine: i + 1
+          }
+        });
+      }
+      currentChunk = [];
+      currentStart = i + 1;
+    }
+  }
+  if (currentChunk.length > 0) {
+    const chunkContent = currentChunk.join("\n").trim();
+    if (chunkContent.length > 0) {
+      chunks2.push({
+        content: chunkContent,
+        chunkType: "code",
+        chunkIndex: chunks2.length,
+        metadata: {
+          ...metadata,
+          filePath,
+          startLine: currentStart + 1,
+          endLine: lines.length
+        }
+      });
+    }
+  }
+  return chunks2;
+}
+function chunkBySize(content, opts) {
+  const { chunkSize, chunkOverlap, chunkType, metadata = {} } = opts;
+  const chunks2 = [];
+  const paragraphs = content.split(/\n\n+/);
+  let current = "";
+  for (const para of paragraphs) {
+    if ((current + "\n\n" + para).length > chunkSize && current.length > 0) {
+      chunks2.push({
+        content: current.trim(),
+        chunkType,
+        chunkIndex: chunks2.length,
+        metadata
+      });
+      const words = current.split(/\s+/);
+      const overlapWords = words.slice(-Math.floor(chunkOverlap / 5));
+      current = overlapWords.join(" ") + "\n\n" + para;
+    } else {
+      current = current ? current + "\n\n" + para : para;
+    }
+  }
+  if (current.trim().length > 0) {
+    chunks2.push({
+      content: current.trim(),
+      chunkType,
+      chunkIndex: chunks2.length,
+      metadata
+    });
+  }
+  return chunks2;
+}
+
+// src/engine/extractor.ts
+import OpenAI4 from "openai";
+var openai4 = new OpenAI4({ apiKey: process.env.OPENAI_API_KEY });
+async function extractEntities(projectId, content, chunkType, metadata = {}, chunkId) {
+  if (content.length < 100) return { entities: 0, relations: 0 };
+  const isCode = ["code", "function", "class"].includes(chunkType);
+  const prompt = isCode ? `Analyze this code and extract entities and relationships.
+
+Entities: functions, classes, interfaces, types, modules, variables, constants, API endpoints, services.
+Relations: imports, exports, calls, implements, extends, depends_on, references, part_of.
+
+Code:
+\`\`\`
+${content.slice(0, 3e3)}
+\`\`\`
+
+Respond with JSON only:
+{
+  "entities": [{"name": "...", "type": "function|class|interface|module|constant|api_endpoint|service", "description": "one line"}],
+  "relations": [{"from": "name", "fromType": "type", "to": "name", "toType": "type", "relation": "imports|calls|extends|implements|depends_on|references|part_of"}]
+}` : `Analyze this text and extract key entities (concepts, people, tools, services, APIs, technologies) and their relationships.
+
+Text:
+${content.slice(0, 3e3)}
+
+Respond with JSON only:
+{
+  "entities": [{"name": "...", "type": "concept|tool|service|api|technology|person|organization", "description": "one line"}],
+  "relations": [{"from": "name", "fromType": "type", "to": "name", "toType": "type", "relation": "references|depends_on|related_to|part_of|supersedes"}]
+}`;
+  try {
+    const res = await openai4.chat.completions.create({
+      model: "gpt-4.1-nano",
+      messages: [{ role: "user", content: prompt }],
+      temperature: 0,
+      max_tokens: 1e3,
+      response_format: { type: "json_object" }
+    });
+    const text2 = res.choices[0]?.message?.content?.trim() || "{}";
+    const parsed = JSON.parse(text2);
+    const extractedEntities = parsed.entities || [];
+    const extractedRelations = parsed.relations || [];
+    let entityCount = 0;
+    let relationCount = 0;
+    const entityMap = /* @__PURE__ */ new Map();
+    for (const ent of extractedEntities.slice(0, 20)) {
+      if (!ent.name || !ent.type) continue;
+      const embedding = await embedSingle(`${ent.type}: ${ent.name} - ${ent.description || ""}`);
+      const [entity] = await db.insert(entities).values({
+        projectId,
+        name: ent.name,
+        entityType: ent.type,
+        description: ent.description,
+        metadata: { ...metadata, autoExtracted: true },
+        sourceChunkId: chunkId,
+        embedding
+      }).onConflictDoUpdate({
+        target: [entities.projectId, entities.name, entities.entityType],
+        set: {
+          description: ent.description,
+          sourceChunkId: chunkId,
+          embedding,
+          updatedAt: /* @__PURE__ */ new Date()
+        }
+      }).returning();
+      entityMap.set(`${ent.name}:${ent.type}`, entity.id);
+      entityCount++;
+    }
+    for (const rel of extractedRelations.slice(0, 30)) {
+      if (!rel.from || !rel.to || !rel.relation) continue;
+      const fromId = entityMap.get(`${rel.from}:${rel.fromType}`);
+      const toId = entityMap.get(`${rel.to}:${rel.toType}`);
+      if (!fromId || !toId) continue;
+      const validRelations = [
+        "imports",
+        "exports",
+        "calls",
+        "implements",
+        "extends",
+        "references",
+        "depends_on",
+        "related_to",
+        "part_of",
+        "contradicts",
+        "supersedes"
+      ];
+      if (!validRelations.includes(rel.relation)) continue;
+      await db.insert(relations).values({
+        projectId,
+        fromEntityId: fromId,
+        toEntityId: toId,
+        relationType: rel.relation,
+        metadata: { autoExtracted: true }
+      }).onConflictDoUpdate({
+        target: [relations.fromEntityId, relations.toEntityId, relations.relationType],
+        set: { metadata: { autoExtracted: true } }
+      });
+      relationCount++;
+    }
+    return { entities: entityCount, relations: relationCount };
+  } catch {
+    return { entities: 0, relations: 0 };
+  }
+}
+
+// src/engine/ingest.ts
+import { createHash as createHash3 } from "crypto";
+import PQueue from "p-queue";
+var queue = new PQueue({ concurrency: 3 });
+var ENABLE_AUTO_EXTRACTION = process.env.DISABLE_AUTO_EXTRACTION !== "true";
+async function ingestDocument(input) {
+  const { sourceId, projectId, externalId, title, content, metadata = {}, filePath } = input;
+  const contentHash = createHash3("sha256").update(content).digest("hex");
+  const [doc] = await db.insert(documents).values({
+    sourceId,
+    projectId,
+    externalId,
+    title,
+    content,
+    metadata,
+    contentHash
+  }).onConflictDoUpdate({
+    target: [documents.sourceId, documents.externalId],
+    set: { title, content, metadata, contentHash, updatedAt: /* @__PURE__ */ new Date() }
+  }).returning();
+  await db.delete(chunks).where(eq2(chunks.documentId, doc.id));
+  const textChunks = chunkText(content, {
+    filePath: filePath || externalId,
+    metadata: { ...metadata, title }
+  });
+  if (textChunks.length === 0) return doc;
+  const batchSize = 50;
+  const insertedChunkIds = [];
+  for (let i = 0; i < textChunks.length; i += batchSize) {
+    const batch = textChunks.slice(i, i + batchSize);
+    const embeddings = await embed(batch.map((c) => c.content));
+    const inserted = await db.insert(chunks).values(
+      batch.map((chunk, j) => ({
+        documentId: doc.id,
+        projectId,
+        content: chunk.content,
+        chunkType: chunk.chunkType,
+        chunkIndex: chunk.chunkIndex,
+        metadata: chunk.metadata,
+        embedding: embeddings[j],
+        tokenCount: Math.ceil(chunk.content.length / 4)
+      }))
+    ).returning({ id: chunks.id });
+    insertedChunkIds.push(...inserted.map((c) => c.id));
+  }
+  if (ENABLE_AUTO_EXTRACTION && !input.skipEntityExtraction) {
+    const chunksToExtract = textChunks.filter((c) => c.content.length > 200).slice(0, 5);
+    for (let i = 0; i < chunksToExtract.length; i++) {
+      const chunk = chunksToExtract[i];
+      const chunkId = insertedChunkIds[textChunks.indexOf(chunk)];
+      extractEntities(projectId, chunk.content, chunk.chunkType, metadata, chunkId).catch(() => {
+      });
+    }
+  }
+  const docCount = await db.select({ count: db.$count(documents, eq2(documents.sourceId, sourceId)) }).from(documents);
+  const chunkCount = await db.select({ count: db.$count(chunks, eq2(chunks.documentId, doc.id)) }).from(chunks);
+  await db.update(sources).set({
+    documentCount: Number(docCount[0]?.count || 0),
+    chunkCount: Number(chunkCount[0]?.count || 0),
+    lastSyncAt: /* @__PURE__ */ new Date(),
+    status: "ready",
+    updatedAt: /* @__PURE__ */ new Date()
+  }).where(eq2(sources.id, sourceId));
+  return doc;
+}
+
+// src/mcp/server.ts
+var ORG_ID = process.env.WHISPER_ORG_ID || "";
+var server = new McpServer({
+  name: "whisper-context",
+  version: "0.1.0"
+});
+async function resolveProject(name) {
+  const [proj] = await db.select().from(projects).where(
+    and2(
+      eq3(projects.orgId, ORG_ID),
+      sql2`(${projects.name} = ${name} OR ${projects.slug} = ${name})`
+    )
+  ).limit(1);
+  return proj;
+}
+server.tool(
+  "query_context",
+  "Search your knowledge base for relevant context. Returns packed context ready for LLM consumption. Supports hybrid vector+keyword search, memory inclusion, and knowledge graph traversal.",
+  {
+    project: z.string().describe("Project name or slug"),
+    query: z.string().describe("What are you looking for?"),
+    top_k: z.number().optional().default(10).describe("Number of results"),
+    chunk_types: z.array(z.string()).optional().describe("Filter: code, function, class, documentation, api_spec, schema, config, text"),
+    include_memories: z.boolean().optional().default(false).describe("Include relevant memories"),
+    include_graph: z.boolean().optional().default(false).describe("Include knowledge graph traversal"),
+    user_id: z.string().optional().describe("User ID for memory scoping"),
+    session_id: z.string().optional().describe("Session ID for memory scoping"),
+    max_tokens: z.number().optional().describe("Max tokens for packed context")
+  },
+  async ({ project, query, top_k, chunk_types, include_memories, include_graph, user_id, session_id, max_tokens }) => {
+    const proj = await resolveProject(project);
+    if (!proj) return { content: [{ type: "text", text: `Project '${project}' not found.` }] };
+    const response = await retrieve({
+      projectId: proj.id,
+      query,
+      topK: top_k,
+      chunkTypes: chunk_types,
+      includeMemories: include_memories,
+      includeGraph: include_graph,
+      userId: user_id,
+      sessionId: session_id,
+      maxTokens: max_tokens
+    });
+    if (response.results.length === 0) {
+      return { content: [{ type: "text", text: "No relevant context found." }] };
+    }
+    const header = `Found ${response.meta.totalResults} results (${response.meta.latencyMs}ms${response.meta.cacheHit ? ", cached" : ""}):
+
+`;
+    return { content: [{ type: "text", text: header + response.context }] };
+  }
+);
+server.tool(
+  "add_memory",
+  "Store a memory (fact, preference, decision) that persists across conversations. Memories can be scoped to a user, session, or agent.",
+  {
+    project: z.string().describe("Project name or slug"),
+    content: z.string().describe("The memory content to store"),
+    memory_type: z.enum(["factual", "episodic", "semantic", "procedural"]).optional().default("factual"),
+    user_id: z.string().optional().describe("User this memory belongs to"),
+    session_id: z.string().optional().describe("Session scope"),
+    agent_id: z.string().optional().describe("Agent scope"),
+    importance: z.number().optional().default(0.5).describe("Importance 0-1")
+  },
+  async ({ project, content, memory_type, user_id, session_id, agent_id, importance }) => {
+    const proj = await resolveProject(project);
+    if (!proj) return { content: [{ type: "text", text: `Project '${project}' not found.` }] };
+    const embedding = await embedSingle(content);
+    const [memory] = await db.insert(memories).values({
+      projectId: proj.id,
+      content,
+      memoryType: memory_type,
+      userId: user_id,
+      sessionId: session_id,
+      agentId: agent_id,
+      importance,
+      embedding
+    }).returning();
+    return { content: [{ type: "text", text: `Memory stored (id: ${memory.id}, type: ${memory_type}).` }] };
+  }
+);
+server.tool(
+  "search_memories",
+  "Search stored memories by semantic similarity. Recall facts, preferences, past decisions from previous interactions.",
+  {
+    project: z.string().describe("Project name or slug"),
+    query: z.string().describe("What to search for"),
+    user_id: z.string().optional().describe("Filter by user"),
+    session_id: z.string().optional().describe("Filter by session"),
+    top_k: z.number().optional().default(10).describe("Number of results")
+  },
+  async ({ project, query, user_id, session_id, top_k }) => {
+    const proj = await resolveProject(project);
+    if (!proj) return { content: [{ type: "text", text: `Project '${project}' not found.` }] };
+    const queryEmbedding = await embedSingle(query);
+    const conditions = [
+      eq3(memories.projectId, proj.id),
+      eq3(memories.isActive, true),
+      sql2`(${memories.expiresAt} IS NULL OR ${memories.expiresAt} > NOW())`
+    ];
+    if (user_id) conditions.push(eq3(memories.userId, user_id));
+    if (session_id) conditions.push(eq3(memories.sessionId, session_id));
+    const results = await db.select({
+      id: memories.id,
+      content: memories.content,
+      memoryType: memories.memoryType,
+      importance: memories.importance,
+      similarity: sql2`1 - (${memories.embedding} <=> ${JSON.stringify(queryEmbedding)}::vector)`
+    }).from(memories).where(and2(...conditions)).orderBy(sql2`${memories.embedding} <=> ${JSON.stringify(queryEmbedding)}::vector`).limit(top_k);
+    if (results.length === 0) return { content: [{ type: "text", text: "No memories found." }] };
+    const text2 = results.map((r, i) => `${i + 1}. [${r.memoryType}, importance: ${r.importance}, score: ${r.similarity.toFixed(3)}]
+${r.content}`).join("\n\n");
+    return { content: [{ type: "text", text: text2 }] };
+  }
+);
+server.tool(
+  "list_projects",
+  "List all available context projects.",
+  {},
+  async () => {
+    const projs = await db.select().from(projects).where(eq3(projects.orgId, ORG_ID));
+    const text2 = projs.length === 0 ? "No projects found." : projs.map((p) => `- ${p.name} (${p.slug})${p.description ? `: ${p.description}` : ""}`).join("\n");
+    return { content: [{ type: "text", text: text2 }] };
+  }
+);
+server.tool(
+  "list_sources",
+  "List all data sources connected to a project.",
+  { project: z.string().describe("Project name or slug") },
+  async ({ project }) => {
+    const proj = await resolveProject(project);
+    if (!proj) return { content: [{ type: "text", text: `Project '${project}' not found.` }] };
+    const srcs = await db.select().from(sources).where(eq3(sources.projectId, proj.id));
+    const text2 = srcs.length === 0 ? "No sources connected." : srcs.map((s) => `- ${s.name} (${s.connectorType}) \u2014 ${s.status} | ${s.documentCount} docs, ${s.chunkCount} chunks`).join("\n");
+    return { content: [{ type: "text", text: text2 }] };
+  }
+);
+server.tool(
+  "add_context",
+  "Add text content to a project's knowledge base.",
+  {
+    project: z.string().describe("Project name or slug"),
+    title: z.string().describe("Title for this content"),
+    content: z.string().describe("The text content to index")
+  },
+  async ({ project, title, content }) => {
+    const proj = await resolveProject(project);
+    if (!proj) return { content: [{ type: "text", text: `Project '${project}' not found.` }] };
+    let [directSource] = await db.select().from(sources).where(and2(eq3(sources.projectId, proj.id), eq3(sources.connectorType, "custom"), eq3(sources.name, "mcp-ingest"))).limit(1);
+    if (!directSource) {
+      [directSource] = await db.insert(sources).values({ projectId: proj.id, name: "mcp-ingest", connectorType: "custom", config: {}, status: "ready" }).returning();
+    }
+    await ingestDocument({ sourceId: directSource.id, projectId: proj.id, externalId: `mcp-${title}`, title, content });
+    return { content: [{ type: "text", text: `Indexed "${title}" (${content.length} chars) into '${project}'.` }] };
+  }
+);
+server.tool(
+  "track_conversation",
+  "Add a message to a conversation. Creates the conversation if it doesn't exist.",
+  {
+    project: z.string().describe("Project name or slug"),
+    session_id: z.string().describe("Unique session identifier"),
+    role: z.enum(["user", "assistant", "system", "tool"]),
+    content: z.string().describe("Message content"),
+    user_id: z.string().optional().describe("User identifier")
+  },
+  async ({ project, session_id, role, content, user_id }) => {
+    const proj = await resolveProject(project);
+    if (!proj) return { content: [{ type: "text", text: `Project '${project}' not found.` }] };
+    let [conv] = await db.select().from(conversations).where(and2(eq3(conversations.projectId, proj.id), eq3(conversations.sessionId, session_id))).limit(1);
+    if (!conv) {
+      [conv] = await db.insert(conversations).values({ projectId: proj.id, sessionId: session_id, userId: user_id }).returning();
+    }
+    await db.insert(messages).values({ conversationId: conv.id, role, content });
+    await db.update(conversations).set({ messageCount: sql2`${conversations.messageCount} + 1`, updatedAt: /* @__PURE__ */ new Date() }).where(eq3(conversations.id, conv.id));
+    return { content: [{ type: "text", text: `Message added (session: ${session_id}).` }] };
+  }
+);
+server.tool(
+  "get_conversation",
+  "Retrieve conversation history for a session.",
+  {
+    project: z.string().describe("Project name or slug"),
+    session_id: z.string().describe("Session identifier"),
+    limit: z.number().optional().default(50)
+  },
+  async ({ project, session_id, limit }) => {
+    const proj = await resolveProject(project);
+    if (!proj) return { content: [{ type: "text", text: `Project '${project}' not found.` }] };
+    const [conv] = await db.select().from(conversations).where(and2(eq3(conversations.projectId, proj.id), eq3(conversations.sessionId, session_id))).limit(1);
+    if (!conv) return { content: [{ type: "text", text: "No conversation found for this session." }] };
+    const msgs = await db.select().from(messages).where(eq3(messages.conversationId, conv.id)).orderBy(messages.createdAt).limit(limit);
+    const text2 = msgs.map((m) => `[${m.role}]: ${m.content}`).join("\n\n");
+    return { content: [{ type: "text", text: text2 || "No messages yet." }] };
+  }
+);
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("Whisper Context MCP server running on stdio");
+}
+main().catch(console.error);
+//# sourceMappingURL=server.js.map