@cognistore/mcp-server 0.9.8

package/dist/index.js

@@ -0,0 +1,1757 @@
+#!/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/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// ../../packages/core/dist/db/client.js
+import BetterSqlite3 from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import * as sqliteVec from "sqlite-vec";
+
+// ../../packages/shared/dist/types/knowledge.js
+var KnowledgeType;
+(function(KnowledgeType2) {
+  KnowledgeType2["DECISION"] = "decision";
+  KnowledgeType2["PATTERN"] = "pattern";
+  KnowledgeType2["FIX"] = "fix";
+  KnowledgeType2["CONSTRAINT"] = "constraint";
+  KnowledgeType2["GOTCHA"] = "gotcha";
+})(KnowledgeType || (KnowledgeType = {}));
+var KnowledgeStatus;
+(function(KnowledgeStatus2) {
+  KnowledgeStatus2["DRAFT"] = "draft";
+  KnowledgeStatus2["ACTIVE"] = "active";
+  KnowledgeStatus2["COMPLETED"] = "completed";
+  KnowledgeStatus2["ARCHIVED"] = "archived";
+})(KnowledgeStatus || (KnowledgeStatus = {}));
+var TaskStatus;
+(function(TaskStatus2) {
+  TaskStatus2["PENDING"] = "pending";
+  TaskStatus2["IN_PROGRESS"] = "in_progress";
+  TaskStatus2["COMPLETED"] = "completed";
+})(TaskStatus || (TaskStatus = {}));
+var TaskPriority;
+(function(TaskPriority2) {
+  TaskPriority2["LOW"] = "low";
+  TaskPriority2["MEDIUM"] = "medium";
+  TaskPriority2["HIGH"] = "high";
+})(TaskPriority || (TaskPriority = {}));
+
+// ../../packages/shared/dist/constants/defaults.js
+var DEFAULT_EMBEDDING_MODEL = "all-minilm";
+var DEFAULT_EMBEDDING_DIMENSIONS = 384;
+var DEFAULT_SIMILARITY_THRESHOLD = 0.3;
+var DEFAULT_SEARCH_LIMIT = 10;
+var DEFAULT_OLLAMA_HOST = "http://localhost:11434";
+var DEFAULT_SQLITE_PATH = "~/.cognistore/knowledge.db";
+var KNOWLEDGE_TYPES = Object.values(KnowledgeType);
+
+// ../../packages/shared/dist/utils/validation.js
+import { z } from "zod";
+var knowledgeTypeSchema = z.nativeEnum(KnowledgeType);
+var knowledgeStatusSchema = z.nativeEnum(KnowledgeStatus);
+var taskStatusSchema = z.nativeEnum(TaskStatus);
+var taskPrioritySchema = z.nativeEnum(TaskPriority);
+var createKnowledgeSchema = z.object({
+  title: z.string().min(1, "Title is required"),
+  content: z.string().min(1, "Content is required"),
+  tags: z.array(z.string().min(1)).min(1, "At least one tag is required"),
+  type: knowledgeTypeSchema,
+  scope: z.string().min(1, "Scope is required"),
+  source: z.string().min(1, "Source is required"),
+  confidenceScore: z.number().min(0).max(1).optional().default(1),
+  expiresAt: z.date().nullable().optional().default(null),
+  relatedIds: z.array(z.string().uuid()).nullable().optional().default(null),
+  agentId: z.string().nullable().optional().default(null)
+});
+var updateKnowledgeSchema = z.object({
+  title: z.string().min(1).optional(),
+  content: z.string().min(1).optional(),
+  tags: z.array(z.string().min(1)).min(1).optional(),
+  type: knowledgeTypeSchema.optional(),
+  scope: z.string().min(1).optional(),
+  source: z.string().min(1).optional(),
+  confidenceScore: z.number().min(0).max(1).optional(),
+  expiresAt: z.date().nullable().optional(),
+  relatedIds: z.array(z.string().uuid()).nullable().optional(),
+  agentId: z.string().nullable().optional()
+});
+var searchOptionsSchema = z.object({
+  tags: z.array(z.string()).optional(),
+  type: knowledgeTypeSchema.optional(),
+  scope: z.string().optional(),
+  limit: z.number().int().min(1).max(100).optional().default(DEFAULT_SEARCH_LIMIT),
+  threshold: z.number().min(0).max(1).optional().default(DEFAULT_SIMILARITY_THRESHOLD)
+});
+var createPlanSchema = z.object({
+  title: z.string().min(1, "Title is required"),
+  content: z.string().min(1, "Content is required"),
+  tags: z.array(z.string().min(1)).min(1, "At least one tag is required"),
+  scope: z.string().min(1, "Scope is required"),
+  source: z.string().min(1, "Source is required"),
+  status: knowledgeStatusSchema.optional().default(KnowledgeStatus.DRAFT)
+});
+var updatePlanSchema = z.object({
+  title: z.string().min(1).optional(),
+  content: z.string().min(1).optional(),
+  tags: z.array(z.string().min(1)).min(1).optional(),
+  scope: z.string().min(1).optional(),
+  status: knowledgeStatusSchema.optional(),
+  source: z.string().min(1).optional()
+});
+var createPlanTaskSchema = z.object({
+  planId: z.string().min(1),
+  description: z.string().min(1, "Description is required"),
+  status: taskStatusSchema.optional().default(TaskStatus.PENDING),
+  priority: taskPrioritySchema.optional().default(TaskPriority.MEDIUM),
+  notes: z.string().nullable().optional().default(null),
+  position: z.number().int().min(0).optional()
+});
+var updatePlanTaskSchema = z.object({
+  description: z.string().min(1).optional(),
+  status: taskStatusSchema.optional(),
+  priority: taskPrioritySchema.optional(),
+  notes: z.string().nullable().optional(),
+  position: z.number().int().min(0).optional()
+});
+
+// ../../packages/core/dist/db/schema/index.js
+var schema_exports = {};
+__export(schema_exports, {
+  createEmbeddingsTable: () => createEmbeddingsTable,
+  deleteEmbedding: () => deleteEmbedding,
+  insertEmbedding: () => insertEmbedding,
+  knowledgeEntries: () => knowledgeEntries,
+  knowledgeTypeEnum: () => knowledgeTypeEnum,
+  searchKnn: () => searchKnn,
+  updateEmbedding: () => updateEmbedding
+});
+
+// ../../packages/core/dist/db/schema/knowledge.js
+import { sqliteTable, text, integer, real, index } from "drizzle-orm/sqlite-core";
+var knowledgeTypeEnum = ["decision", "pattern", "fix", "constraint", "gotcha"];
+var knowledgeEntries = sqliteTable("knowledge_entries", {
+  id: text("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+  title: text("title").notNull().default(""),
+  content: text("content").notNull(),
+  tags: text("tags", { mode: "json" }).notNull().$type().default([]),
+  type: text("type").notNull(),
+  scope: text("scope").notNull(),
+  source: text("source").notNull(),
+  version: integer("version").notNull().default(1),
+  expiresAt: text("expires_at"),
+  confidenceScore: real("confidence_score").notNull().default(1),
+  relatedIds: text("related_ids", { mode: "json" }).$type(),
+  agentId: text("agent_id"),
+  createdAt: text("created_at").notNull().$defaultFn(() => (/* @__PURE__ */ new Date()).toISOString()),
+  updatedAt: text("updated_at").notNull().$defaultFn(() => (/* @__PURE__ */ new Date()).toISOString())
+}, (table) => [
+  index("idx_type").on(table.type),
+  index("idx_scope").on(table.scope)
+]);
+
+// ../../packages/core/dist/db/schema/sqlite-vec.js
+var VIRTUAL_TABLE_NAME = "knowledge_embeddings";
+function createEmbeddingsTable(sqlite, dimensions = 384) {
+  sqlite.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS ${VIRTUAL_TABLE_NAME} USING vec0(
+      id TEXT PRIMARY KEY,
+      embedding float[${dimensions}] distance_metric=cosine
+    )
+  `);
+}
+function insertEmbedding(sqlite, id, embedding) {
+  const stmt = sqlite.prepare(`INSERT INTO ${VIRTUAL_TABLE_NAME}(id, embedding) VALUES (?, ?)`);
+  stmt.run(id, Buffer.from(new Float32Array(embedding).buffer));
+}
+function updateEmbedding(sqlite, id, embedding) {
+  const stmt = sqlite.prepare(`UPDATE ${VIRTUAL_TABLE_NAME} SET embedding = ? WHERE id = ?`);
+  stmt.run(Buffer.from(new Float32Array(embedding).buffer), id);
+}
+function deleteEmbedding(sqlite, id) {
+  const stmt = sqlite.prepare(`DELETE FROM ${VIRTUAL_TABLE_NAME} WHERE id = ?`);
+  stmt.run(id);
+}
+function searchKnn(sqlite, queryEmbedding, k) {
+  const stmt = sqlite.prepare(`
+    SELECT id, distance
+    FROM ${VIRTUAL_TABLE_NAME}
+    WHERE embedding MATCH ?
+      AND k = ?
+  `);
+  return stmt.all(Buffer.from(new Float32Array(queryEmbedding).buffer), k);
+}
+
+// ../../packages/core/dist/db/migrate.js
+import { readdirSync, readFileSync, existsSync } from "fs";
+import { resolve } from "path";
+var EMBEDDED_MIGRATIONS = {
+  "0.8.0": `
+CREATE TABLE IF NOT EXISTS knowledge_entries (
+  id TEXT PRIMARY KEY,
+  content TEXT NOT NULL,
+  tags TEXT NOT NULL DEFAULT '[]',
+  type TEXT NOT NULL,
+  scope TEXT NOT NULL,
+  source TEXT NOT NULL,
+  version INTEGER NOT NULL DEFAULT 1,
+  expires_at TEXT,
+  confidence_score REAL NOT NULL DEFAULT 1.0,
+  related_ids TEXT,
+  agent_id TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_type ON knowledge_entries(type);
+CREATE INDEX IF NOT EXISTS idx_scope ON knowledge_entries(scope);
+
+CREATE TABLE IF NOT EXISTS operations_log (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  operation TEXT NOT NULL CHECK(operation IN ('read', 'write')),
+  created_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_ops_created_at ON operations_log(created_at);
+CREATE INDEX IF NOT EXISTS idx_ops_operation ON operations_log(operation);
+`,
+  "0.9.0": `
+ALTER TABLE knowledge_entries ADD COLUMN title TEXT NOT NULL DEFAULT '';
+
+CREATE TABLE IF NOT EXISTS plans (
+  id TEXT PRIMARY KEY,
+  title TEXT NOT NULL,
+  content TEXT NOT NULL,
+  tags TEXT NOT NULL DEFAULT '[]',
+  scope TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'draft' CHECK(status IN ('draft', 'active', 'completed', 'archived')),
+  source TEXT NOT NULL DEFAULT '',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_plans_status ON plans(status);
+CREATE INDEX IF NOT EXISTS idx_plans_scope ON plans(scope);
+
+CREATE TABLE IF NOT EXISTS plan_relations (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  plan_id TEXT NOT NULL REFERENCES plans(id) ON DELETE CASCADE,
+  knowledge_id TEXT NOT NULL REFERENCES knowledge_entries(id) ON DELETE CASCADE,
+  relation_type TEXT NOT NULL CHECK(relation_type IN ('input', 'output')),
+  created_at TEXT NOT NULL,
+  UNIQUE(plan_id, knowledge_id, relation_type)
+);
+CREATE INDEX IF NOT EXISTS idx_plan_relations_plan ON plan_relations(plan_id);
+CREATE INDEX IF NOT EXISTS idx_plan_relations_knowledge ON plan_relations(knowledge_id);
+
+CREATE TABLE IF NOT EXISTS plan_tasks (
+  id TEXT PRIMARY KEY,
+  plan_id TEXT NOT NULL REFERENCES plans(id) ON DELETE CASCADE,
+  description TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending', 'in_progress', 'completed')),
+  priority TEXT NOT NULL DEFAULT 'medium' CHECK(priority IN ('low', 'medium', 'high')),
+  notes TEXT,
+  position INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_plan_tasks_plan ON plan_tasks(plan_id);
+CREATE INDEX IF NOT EXISTS idx_plan_tasks_status ON plan_tasks(status);
+`
+};
+function runMigrations(sqlite, migrationsDir) {
+  sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS schema_version (
+      version TEXT PRIMARY KEY,
+      applied_at TEXT NOT NULL
+    );
+  `);
+  const applied = new Set(sqlite.prepare("SELECT version FROM schema_version").all().map((r) => r.version));
+  if (applied.size === 0) {
+    const tableExists = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='knowledge_entries'").get();
+    if (tableExists) {
+      sqlite.prepare("INSERT INTO schema_version (version, applied_at) VALUES (?, ?)").run("0.8.0", (/* @__PURE__ */ new Date()).toISOString());
+      applied.add("0.8.0");
+      console.log("Migration: bootstrapped existing DB as v0.8.0");
+    }
+  }
+  let migrations;
+  if (existsSync(migrationsDir)) {
+    const files = readdirSync(migrationsDir).filter((f) => f.endsWith(".sql")).sort((a, b) => compareSemver(a.replace(".sql", ""), b.replace(".sql", "")));
+    migrations = files.map((f) => ({
+      version: f.replace(".sql", ""),
+      sql: readFileSync(resolve(migrationsDir, f), "utf-8")
+    }));
+  } else {
+    migrations = Object.entries(EMBEDDED_MIGRATIONS).map(([version, sql2]) => ({ version, sql: sql2 })).sort((a, b) => compareSemver(a.version, b.version));
+    console.log("Migration: using embedded migrations (bundled mode)");
+  }
+  for (const { version, sql: sql2 } of migrations) {
+    if (applied.has(version))
+      continue;
+    const cleanedSql = sql2.split("\n").filter((line) => !line.trim().startsWith("--")).join("\n");
+    const statements = cleanedSql.split(";").map((s) => s.trim()).filter((s) => s.length > 0);
+    for (const stmt of statements) {
+      try {
+        sqlite.exec(stmt + ";");
+      } catch (err) {
+        if (err?.message?.includes("duplicate column"))
+          continue;
+        if (err?.message?.includes("already exists"))
+          continue;
+        throw err;
+      }
+    }
+    sqlite.prepare("INSERT INTO schema_version (version, applied_at) VALUES (?, ?)").run(version, (/* @__PURE__ */ new Date()).toISOString());
+    console.log(`Migration: ${version} applied`);
+  }
+}
+function runSeeds(sqlite, seedsDir, isFreshInstall) {
+  if (!isFreshInstall)
+    return;
+  if (!existsSync(seedsDir))
+    return;
+  const files = readdirSync(seedsDir).filter((f) => f.endsWith(".sql")).sort();
+  for (const file of files) {
+    const sqlPath = resolve(seedsDir, file);
+    const sqlContent = readFileSync(sqlPath, "utf-8");
+    sqlite.exec(sqlContent);
+    console.log(`Seed: ${file} applied`);
+  }
+}
+function compareSemver(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] ?? 0) !== (pb[i] ?? 0))
+      return (pa[i] ?? 0) - (pb[i] ?? 0);
+  }
+  return 0;
+}
+
+// ../../packages/core/dist/db/client.js
+import { homedir } from "os";
+import { mkdirSync } from "fs";
+import { dirname, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+function resolvePath(path) {
+  if (path.startsWith("~")) {
+    return path.replace("~", homedir());
+  }
+  return path;
+}
+function createDbClient(dbPath) {
+  const resolvedPath = resolvePath(dbPath ?? process.env.SQLITE_PATH ?? DEFAULT_SQLITE_PATH);
+  mkdirSync(dirname(resolvedPath), { recursive: true });
+  const sqlite = new BetterSqlite3(resolvedPath);
+  sqlite.pragma("journal_mode = WAL");
+  sqlite.pragma("busy_timeout = 5000");
+  sqlite.pragma("foreign_keys = ON");
+  sqliteVec.load(sqlite);
+  const hasSchemaVersion = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='schema_version'").get();
+  const hasKnowledgeEntries = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='knowledge_entries'").get();
+  const isFreshInstall = !hasSchemaVersion && !hasKnowledgeEntries;
+  const migrationsDir = resolve2(__dirname, "migrations");
+  const seedsDir = resolve2(__dirname, "seeds");
+  runMigrations(sqlite, migrationsDir);
+  runSeeds(sqlite, seedsDir, isFreshInstall);
+  createEmbeddingsTable(sqlite);
+  createPlansEmbeddingsTable(sqlite);
+  const db = drizzle(sqlite, { schema: schema_exports });
+  return { db, sqlite };
+}
+function createPlansEmbeddingsTable(sqlite) {
+  try {
+    sqlite.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS plans_embeddings USING vec0(
+        id TEXT PRIMARY KEY,
+        embedding float[384] distance_metric=cosine
+      );
+    `);
+  } catch {
+  }
+}
+
+// ../../packages/core/dist/repositories/knowledge.repository.js
+import { eq, sql, and, or, isNull } from "drizzle-orm";
+var KnowledgeRepository = class {
+  db;
+  sqlite;
+  constructor(db, sqlite) {
+    this.db = db;
+    this.sqlite = sqlite;
+  }
+  async create(input) {
+    const id = crypto.randomUUID();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const [entry] = await this.db.insert(knowledgeEntries).values({
+      id,
+      title: input.title,
+      content: input.content,
+      tags: input.tags,
+      type: input.type,
+      scope: input.scope,
+      source: input.source,
+      confidenceScore: input.confidenceScore ?? 1,
+      expiresAt: input.expiresAt ? input.expiresAt.toISOString() : null,
+      relatedIds: input.relatedIds ?? null,
+      agentId: input.agentId ?? null,
+      createdAt: now,
+      updatedAt: now
+    }).returning();
+    insertEmbedding(this.sqlite, id, input.embedding);
+    return entry;
+  }
+  async findById(id) {
+    const [entry] = await this.db.select().from(knowledgeEntries).where(eq(knowledgeEntries.id, id));
+    return entry ?? null;
+  }
+  async update(id, updates) {
+    const { embedding, ...rest } = updates;
+    const values = {
+      ...rest,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (rest.expiresAt !== void 0) {
+      values.expiresAt = rest.expiresAt ? rest.expiresAt.toISOString() : null;
+    }
+    const [entry] = await this.db.update(knowledgeEntries).set({
+      ...values,
+      version: sql`${knowledgeEntries.version} + 1`
+    }).where(eq(knowledgeEntries.id, id)).returning();
+    if (embedding) {
+      updateEmbedding(this.sqlite, id, embedding);
+    }
+    return entry ?? null;
+  }
+  async delete(id) {
+    const [entry] = await this.db.delete(knowledgeEntries).where(eq(knowledgeEntries.id, id)).returning();
+    if (entry) {
+      deleteEmbedding(this.sqlite, id);
+    }
+    return entry ?? null;
+  }
+  /**
+   * Semantic search using cosine similarity on embeddings.
+   * Uses sqlite-vec KNN search on the virtual table, then filters by metadata.
+   * IMPORTANT: When a specific scope is provided, global knowledge is ALWAYS included.
+   */
+  async searchBySimilarity(queryEmbedding, options) {
+    const limit = options?.limit ?? DEFAULT_SEARCH_LIMIT;
+    const threshold = options?.threshold ?? DEFAULT_SIMILARITY_THRESHOLD;
+    const candidateLimit = limit * 5;
+    const knnResults = searchKnn(this.sqlite, queryEmbedding, candidateLimit);
+    if (knnResults.length === 0) {
+      return [];
+    }
+    const candidateIds = knnResults.map((r) => r.id);
+    const distanceMap = new Map(knnResults.map((r) => [r.id, r.distance]));
+    const conditions = [];
+    conditions.push(sql`${knowledgeEntries.id} IN (${sql.join(candidateIds.map((id) => sql`${id}`), sql`, `)})`);
+    if (options?.scope) {
+      conditions.push(or(eq(knowledgeEntries.scope, "global"), eq(knowledgeEntries.scope, options.scope)));
+    }
+    if (options?.tags && options.tags.length > 0) {
+      const tagConditions = options.tags.map((tag) => sql`EXISTS (SELECT 1 FROM json_each(${knowledgeEntries.tags}) WHERE value = ${tag})`);
+      conditions.push(or(...tagConditions));
+    }
+    if (options?.type) {
+      conditions.push(eq(knowledgeEntries.type, options.type));
+    }
+    conditions.push(or(isNull(knowledgeEntries.expiresAt), sql`${knowledgeEntries.expiresAt} > ${(/* @__PURE__ */ new Date()).toISOString()}`));
+    const whereClause = and(...conditions);
+    const entries = await this.db.select().from(knowledgeEntries).where(whereClause);
+    return entries.map((entry) => ({
+      entry,
+      similarity: 1 - (distanceMap.get(entry.id) ?? 1)
+    })).filter((r) => r.similarity >= threshold).sort((a, b) => b.similarity - a.similarity).slice(0, limit);
+  }
+  async listRecent(limit = 20, filters) {
+    const conditions = [];
+    if (filters?.type)
+      conditions.push(sql`${knowledgeEntries.type} = ${filters.type}`);
+    if (filters?.scope)
+      conditions.push(sql`${knowledgeEntries.scope} = ${filters.scope}`);
+    if (conditions.length === 0) {
+      return this.db.select().from(knowledgeEntries).orderBy(sql`${knowledgeEntries.createdAt} DESC`).limit(limit);
+    }
+    const where = conditions.length === 1 ? conditions[0] : sql`${conditions[0]} AND ${conditions[1]}`;
+    return this.db.select().from(knowledgeEntries).where(where).orderBy(sql`${knowledgeEntries.createdAt} DESC`).limit(limit);
+  }
+  async listTags() {
+    const result = await this.db.all(sql`SELECT DISTINCT value FROM knowledge_entries, json_each(knowledge_entries.tags)`);
+    return result.map((r) => r.value);
+  }
+  async topTags(limit = 10) {
+    const result = await this.db.all(sql`SELECT value as tag, COUNT(*) as count FROM knowledge_entries, json_each(knowledge_entries.tags) GROUP BY value ORDER BY count DESC LIMIT ${limit}`);
+    return result;
+  }
+  async count() {
+    const [result] = await this.db.select({ count: sql`count(*)` }).from(knowledgeEntries);
+    return Number(result.count);
+  }
+  async lastUpdatedAt() {
+    const result = await this.db.all(sql`SELECT MAX(updated_at) as latest FROM knowledge_entries`);
+    return result[0]?.latest ?? null;
+  }
+  async countByType() {
+    const results = await this.db.select({
+      type: knowledgeEntries.type,
+      count: sql`count(*)`
+    }).from(knowledgeEntries).groupBy(knowledgeEntries.type);
+    return results.map((r) => ({ type: r.type, count: Number(r.count) }));
+  }
+  async countByScope() {
+    const results = await this.db.select({
+      scope: knowledgeEntries.scope,
+      count: sql`count(*)`
+    }).from(knowledgeEntries).groupBy(knowledgeEntries.scope);
+    return results.map((r) => ({ scope: r.scope, count: Number(r.count) }));
+  }
+  async listAll() {
+    return this.db.select().from(knowledgeEntries).orderBy(sql`${knowledgeEntries.createdAt} DESC`);
+  }
+  async listScopes() {
+    const rows = this.sqlite.prepare(`SELECT DISTINCT scope FROM knowledge_entries
+       UNION
+       SELECT DISTINCT scope FROM plans
+       ORDER BY scope`).all();
+    return rows.map((r) => r.scope);
+  }
+  // ─── Plans (separate table) ──────────────────────────────────
+  createPlan(input) {
+    const id = crypto.randomUUID();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.sqlite.prepare("INSERT INTO plans (id, title, content, tags, scope, status, source, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)").run(id, input.title, input.content, JSON.stringify(input.tags), input.scope, input.status ?? "draft", input.source, now, now);
+    try {
+      this.sqlite.prepare("INSERT INTO plans_embeddings (id, embedding) VALUES (?, ?)").run(id, new Float32Array(input.embedding).buffer);
+    } catch {
+    }
+    return this.getPlanById(id);
+  }
+  getPlanById(id) {
+    return this.sqlite.prepare("SELECT * FROM plans WHERE id = ?").get(id) ?? null;
+  }
+  updatePlan(id, updates) {
+    const setClauses = [];
+    const values = [];
+    for (const [key, value] of Object.entries(updates)) {
+      if (value === void 0)
+        continue;
+      const col = key === "tags" ? "tags" : key.replace(/[A-Z]/g, (c) => "_" + c.toLowerCase());
+      setClauses.push(`${col} = ?`);
+      values.push(key === "tags" ? JSON.stringify(value) : value);
+    }
+    if (setClauses.length === 0)
+      return this.getPlanById(id);
+    setClauses.push("updated_at = ?");
+    values.push((/* @__PURE__ */ new Date()).toISOString());
+    values.push(id);
+    this.sqlite.prepare(`UPDATE plans SET ${setClauses.join(", ")} WHERE id = ?`).run(...values);
+    return this.getPlanById(id);
+  }
+  deletePlan(id) {
+    const result = this.sqlite.prepare("DELETE FROM plans WHERE id = ?").run(id);
+    try {
+      this.sqlite.prepare("DELETE FROM plans_embeddings WHERE id = ?").run(id);
+    } catch {
+    }
+    return result.changes > 0;
+  }
+  listAllPlans() {
+    return this.sqlite.prepare("SELECT * FROM plans ORDER BY created_at DESC").all();
+  }
+  listPlans(limit = 20, status) {
+    if (status) {
+      return this.sqlite.prepare("SELECT * FROM plans WHERE status = ? ORDER BY created_at DESC LIMIT ?").all(status, limit);
+    }
+    return this.sqlite.prepare("SELECT * FROM plans ORDER BY created_at DESC LIMIT ?").all(limit);
+  }
+  // ─── Plan Relations ─────────────────────────────────────────
+  addPlanRelation(planId, knowledgeId, relationType) {
+    this.sqlite.prepare("INSERT OR IGNORE INTO plan_relations (plan_id, knowledge_id, relation_type, created_at) VALUES (?, ?, ?, ?)").run(planId, knowledgeId, relationType, (/* @__PURE__ */ new Date()).toISOString());
+  }
+  getPlanRelations(planId) {
+    return this.sqlite.prepare("SELECT knowledge_id as id, relation_type as relationType FROM plan_relations WHERE plan_id = ? ORDER BY created_at").all(planId);
+  }
+  deletePlanRelations(planId) {
+    return this.sqlite.prepare("DELETE FROM plan_relations WHERE plan_id = ?").run(planId).changes;
+  }
+  getPlansForKnowledge(knowledgeId) {
+    return this.sqlite.prepare(`
+        SELECT pr.plan_id as planId, pr.relation_type as relationType, p.title, p.status
+        FROM plan_relations pr
+        JOIN plans p ON p.id = pr.plan_id
+        WHERE pr.knowledge_id = ?
+        ORDER BY pr.created_at
+      `).all(knowledgeId);
+  }
+  // ─── Plan Tasks ─────────────────────────────────────────────
+  createPlanTask(input) {
+    const id = crypto.randomUUID();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const maxPos = this.sqlite.prepare("SELECT MAX(position) as max FROM plan_tasks WHERE plan_id = ?").get(input.planId);
+    const position = input.position ?? (maxPos?.max ?? -1) + 1;
+    this.sqlite.prepare("INSERT INTO plan_tasks (id, plan_id, description, status, priority, notes, position, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)").run(id, input.planId, input.description, input.status ?? "pending", input.priority ?? "medium", input.notes ?? null, position, now, now);
+    return this.getPlanTaskById(id);
+  }
+  updatePlanTask(id, updates) {
+    const setClauses = [];
+    const values = [];
+    if (updates.description !== void 0) {
+      setClauses.push("description = ?");
+      values.push(updates.description);
+    }
+    if (updates.status !== void 0) {
+      setClauses.push("status = ?");
+      values.push(updates.status);
+    }
+    if (updates.priority !== void 0) {
+      setClauses.push("priority = ?");
+      values.push(updates.priority);
+    }
+    if (updates.notes !== void 0) {
+      setClauses.push("notes = ?");
+      values.push(updates.notes);
+    }
+    if (updates.position !== void 0) {
+      setClauses.push("position = ?");
+      values.push(updates.position);
+    }
+    if (setClauses.length === 0)
+      return this.getPlanTaskById(id);
+    setClauses.push("updated_at = ?");
+    values.push((/* @__PURE__ */ new Date()).toISOString());
+    values.push(id);
+    this.sqlite.prepare(`UPDATE plan_tasks SET ${setClauses.join(", ")} WHERE id = ?`).run(...values);
+    return this.getPlanTaskById(id);
+  }
+  deletePlanTask(id) {
+    return this.sqlite.prepare("DELETE FROM plan_tasks WHERE id = ?").run(id).changes > 0;
+  }
+  listPlanTasks(planId) {
+    return this.sqlite.prepare("SELECT * FROM plan_tasks WHERE plan_id = ? ORDER BY position ASC").all(planId);
+  }
+  getPlanTaskById(id) {
+    return this.sqlite.prepare("SELECT * FROM plan_tasks WHERE id = ?").get(id) ?? null;
+  }
+  getPlanTaskStats() {
+    const result = this.sqlite.prepare(`
+      SELECT
+        COUNT(*) as total,
+        SUM(CASE WHEN status = 'pending' THEN 1 ELSE 0 END) as pending,
+        SUM(CASE WHEN status = 'in_progress' THEN 1 ELSE 0 END) as in_progress,
+        SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END) as completed
+      FROM plan_tasks
+    `).get();
+    return { total: result?.total ?? 0, pending: result?.pending ?? 0, inProgress: result?.in_progress ?? 0, completed: result?.completed ?? 0 };
+  }
+  // ─── Operations Log ────────────────────────────────────────────
+  logOperation(operation) {
+    this.sqlite.prepare("INSERT INTO operations_log (operation, created_at) VALUES (?, ?)").run(operation, (/* @__PURE__ */ new Date()).toISOString());
+  }
+  getOperationCounts() {
+    const now = /* @__PURE__ */ new Date();
+    const oneHourAgo = new Date(now.getTime() - 60 * 60 * 1e3).toISOString();
+    const oneDayAgo = new Date(now.getTime() - 24 * 60 * 60 * 1e3).toISOString();
+    const result = this.sqlite.prepare(`SELECT
+          SUM(CASE WHEN operation = 'read'  AND created_at >= ? THEN 1 ELSE 0 END) as reads_1h,
+          SUM(CASE WHEN operation = 'read'  AND created_at >= ? THEN 1 ELSE 0 END) as reads_24h,
+          SUM(CASE WHEN operation = 'write' AND created_at >= ? THEN 1 ELSE 0 END) as writes_1h,
+          SUM(CASE WHEN operation = 'write' AND created_at >= ? THEN 1 ELSE 0 END) as writes_24h
+        FROM operations_log
+        WHERE created_at >= ?`).get(oneHourAgo, oneDayAgo, oneHourAgo, oneDayAgo, oneDayAgo);
+    return {
+      readsLastHour: result?.reads_1h ?? 0,
+      readsLastDay: result?.reads_24h ?? 0,
+      writesLastHour: result?.writes_1h ?? 0,
+      writesLastDay: result?.writes_24h ?? 0
+    };
+  }
+  getOperationsByDay(days = 15) {
+    const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1e3).toISOString();
+    const rows = this.sqlite.prepare(`
+      SELECT date(created_at) as date, operation, COUNT(*) as count
+      FROM operations_log
+      WHERE created_at >= ?
+      GROUP BY date(created_at), operation
+      ORDER BY date(created_at)
+    `).all(cutoff);
+    const map = {};
+    const now = /* @__PURE__ */ new Date();
+    for (let i = days - 1; i >= 0; i--) {
+      const d = new Date(now);
+      d.setDate(d.getDate() - i);
+      const dateStr = d.toISOString().split("T")[0];
+      map[dateStr] = { reads: 0, writes: 0 };
+    }
+    for (const row of rows) {
+      if (!map[row.date])
+        map[row.date] = { reads: 0, writes: 0 };
+      if (row.operation === "read")
+        map[row.date].reads = row.count;
+      else if (row.operation === "write")
+        map[row.date].writes = row.count;
+    }
+    return Object.entries(map).map(([date, counts]) => ({ date, ...counts }));
+  }
+  cleanupOldOperations() {
+    const cutoff = new Date(Date.now() - 7 * 24 * 60 * 60 * 1e3).toISOString();
+    return this.sqlite.prepare("DELETE FROM operations_log WHERE created_at < ?").run(cutoff).changes;
+  }
+};
+
+// ../../packages/core/dist/services/knowledge.service.js
+var KnowledgeService = class {
+  repository;
+  embeddingProvider;
+  constructor(repository, embeddingProvider) {
+    this.repository = repository;
+    this.embeddingProvider = embeddingProvider;
+  }
+  logOp(op) {
+    try {
+      this.repository.logOperation(op);
+    } catch {
+    }
+  }
+  async add(input) {
+    const tagsText = input.tags.join(" ");
+    const embedding = await this.embeddingProvider.embed(tagsText);
+    const entry = await this.repository.create({ ...input, embedding });
+    this.logOp("write");
+    return this.toKnowledgeEntry(entry);
+  }
+  async search(query, options) {
+    const queryEmbedding = await this.embeddingProvider.embed(query);
+    const results = await this.repository.searchBySimilarity(queryEmbedding, options);
+    this.logOp("read");
+    return results.map((r) => ({
+      entry: this.toKnowledgeEntry(r.entry),
+      similarity: r.similarity
+    }));
+  }
+  async getById(id) {
+    const entry = await this.repository.findById(id);
+    return entry ? this.toKnowledgeEntry(entry) : null;
+  }
+  async update(id, updates) {
+    let embedding;
+    if (updates.tags && updates.tags.length > 0) {
+      embedding = await this.embeddingProvider.embed(updates.tags.join(" "));
+    }
+    const entry = await this.repository.update(id, { ...updates, embedding });
+    if (entry)
+      this.logOp("write");
+    return entry ? this.toKnowledgeEntry(entry) : null;
+  }
+  async delete(id) {
+    const entry = await this.repository.delete(id);
+    if (entry)
+      this.logOp("write");
+    return entry !== null;
+  }
+  async listAll() {
+    const entries = await this.repository.listAll();
+    return entries.map((e) => this.toKnowledgeEntry(e));
+  }
+  async listScopes() {
+    return this.repository.listScopes();
+  }
+  async bulkDelete(ids) {
+    let deleted = 0;
+    const errors = [];
+    for (const id of ids) {
+      try {
+        const result = await this.repository.delete(id);
+        if (result) {
+          deleted++;
+          this.logOp("write");
+        }
+      } catch (err) {
+        errors.push(`Failed to delete ${id}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    return { deleted, errors };
+  }
+  async importKnowledge(entries) {
+    let imported = 0;
+    let skipped = 0;
+    const errors = [];
+    const existing = await this.repository.listAll();
+    const existingHashes = /* @__PURE__ */ new Set();
+    for (const e of existing) {
+      const hash = this.hashContent((e.title ?? "") + e.content);
+      existingHashes.add(hash);
+    }
+    for (const entry of entries) {
+      try {
+        const hash = this.hashContent((entry.title ?? "") + entry.content);
+        if (existingHashes.has(hash)) {
+          skipped++;
+          continue;
+        }
+        const tagsText = entry.tags.join(" ");
+        const embedding = await this.embeddingProvider.embed(tagsText);
+        await this.repository.create({ ...entry, embedding });
+        existingHashes.add(hash);
+        imported++;
+        this.logOp("write");
+      } catch (err) {
+        errors.push(`Failed to import "${entry.title}": ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    return { imported, skipped, errors };
+  }
+  hashContent(text2) {
+    let hash = 0;
+    for (let i = 0; i < text2.length; i++) {
+      const char = text2.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash |= 0;
+    }
+    return hash.toString(36);
+  }
+  async listRecent(limit = 20, filters) {
+    const entries = await this.repository.listRecent(limit, filters);
+    return entries.map((e) => this.toKnowledgeEntry(e));
+  }
+  async topTags(limit = 10) {
+    return this.repository.topTags(limit);
+  }
+  async listTags() {
+    return this.repository.listTags();
+  }
+  async getStats() {
+    const [count, byType, byScope, lastUpdatedAt] = await Promise.all([
+      this.repository.count(),
+      this.repository.countByType(),
+      this.repository.countByScope(),
+      this.repository.lastUpdatedAt()
+    ]);
+    return { total: count, byType, byScope, lastUpdatedAt };
+  }
+  // ─── Plans (separate entity) ────────────────────────────────
+  async createPlan(input) {
+    const { tasks, ...planInput } = input;
+    const embedding = await this.embeddingProvider.embed(input.tags.join(" "));
+    const row = this.repository.createPlan({ ...planInput, embedding });
+    const plan = this.toPlan(row);
+    if (tasks && tasks.length > 0) {
+      try {
+        for (let i = 0; i < tasks.length; i++) {
+          this.repository.createPlanTask({ planId: plan.id, description: tasks[i].description, priority: tasks[i].priority, position: i });
+        }
+      } catch (err) {
+        this.repository.deletePlan(plan.id);
+        throw err;
+      }
+    }
+    return plan;
+  }
+  getPlanById(id) {
+    const row = this.repository.getPlanById(id);
+    return row ? this.toPlan(row) : null;
+  }
+  updatePlan(id, updates) {
+    const row = this.repository.updatePlan(id, updates);
+    return row ? this.toPlan(row) : null;
+  }
+  deletePlan(id) {
+    return this.repository.deletePlan(id);
+  }
+  listAllPlans() {
+    const rows = this.repository.listAllPlans();
+    return rows.map((r) => this.toPlan(r));
+  }
+  listPlans(limit = 20, status) {
+    const rows = this.repository.listPlans(limit, status);
+    return rows.map((r) => this.toPlan(r));
+  }
+  async importPlans(plans) {
+    let imported = 0;
+    let skipped = 0;
+    const errors = [];
+    const existing = this.repository.listAllPlans();
+    const existingHashes = /* @__PURE__ */ new Set();
+    for (const p of existing) {
+      existingHashes.add(this.hashContent(p.title + p.content));
+    }
+    for (const plan of plans) {
+      try {
+        const hash = this.hashContent(plan.title + plan.content);
+        if (existingHashes.has(hash)) {
+          skipped++;
+          continue;
+        }
+        const { tasks, ...planInput } = plan;
+        const embedding = await this.embeddingProvider.embed(planInput.tags.join(" "));
+        const row = this.repository.createPlan({ ...planInput, embedding });
+        const createdPlan = this.toPlan(row);
+        if (tasks && tasks.length > 0) {
+          for (let i = 0; i < tasks.length; i++) {
+            this.repository.createPlanTask({
+              planId: createdPlan.id,
+              description: tasks[i].description,
+              status: tasks[i].status,
+              priority: tasks[i].priority,
+              notes: tasks[i].notes,
+              position: i
+            });
+          }
+        }
+        existingHashes.add(hash);
+        imported++;
+      } catch (err) {
+        errors.push(`Failed to import plan "${plan.title}": ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    return { imported, skipped, errors };
+  }
+  // ─── Plan Relations ─────────────────────────────────────────
+  addPlanRelation(planId, knowledgeId, relationType) {
+    this.repository.addPlanRelation(planId, knowledgeId, relationType);
+  }
+  async getPlanRelations(planId) {
+    const relations = this.repository.getPlanRelations(planId);
+    const results = [];
+    for (const rel of relations) {
+      const entry = await this.repository.findById(rel.id);
+      if (entry)
+        results.push({ entry: this.toKnowledgeEntry(entry), relationType: rel.relationType });
+    }
+    return results;
+  }
+  getPlansForKnowledge(knowledgeId) {
+    return this.repository.getPlansForKnowledge(knowledgeId);
+  }
+  // ─── Plan Tasks ─────────────────────────────────────────────
+  createPlanTask(input) {
+    return this.toPlanTask(this.repository.createPlanTask(input));
+  }
+  updatePlanTask(id, updates) {
+    const row = this.repository.updatePlanTask(id, updates);
+    return row ? this.toPlanTask(row) : null;
+  }
+  deletePlanTask(id) {
+    return this.repository.deletePlanTask(id);
+  }
+  listPlanTasks(planId) {
+    return this.repository.listPlanTasks(planId).map((r) => this.toPlanTask(r));
+  }
+  getPlanTaskStats() {
+    return this.repository.getPlanTaskStats();
+  }
+  // ─── Operations ─────────────────────────────────────────────
+  getOperationCounts() {
+    return this.repository.getOperationCounts();
+  }
+  getOperationsByDay(days = 15) {
+    return this.repository.getOperationsByDay(days);
+  }
+  cleanupOldOperations() {
+    return this.repository.cleanupOldOperations();
+  }
+  // ─── Converters ─────────────────────────────────────────────
+  toKnowledgeEntry(row) {
+    return {
+      id: row.id,
+      title: row.title ?? "",
+      content: row.content,
+      embedding: [],
+      tags: Array.isArray(row.tags) ? row.tags : JSON.parse(row.tags ?? "[]"),
+      type: row.type,
+      scope: row.scope,
+      source: row.source,
+      version: row.version,
+      expiresAt: row.expiresAt ? new Date(row.expiresAt) : null,
+      confidenceScore: row.confidenceScore,
+      relatedIds: row.relatedIds ? Array.isArray(row.relatedIds) ? row.relatedIds : JSON.parse(row.relatedIds) : null,
+      agentId: row.agentId,
+      createdAt: new Date(row.createdAt ?? row.created_at),
+      updatedAt: new Date(row.updatedAt ?? row.updated_at)
+    };
+  }
+  toPlan(row) {
+    return {
+      id: row.id,
+      title: row.title,
+      content: row.content,
+      tags: Array.isArray(row.tags) ? row.tags : JSON.parse(row.tags ?? "[]"),
+      scope: row.scope,
+      status: row.status,
+      source: row.source ?? "",
+      createdAt: new Date(row.created_at ?? row.createdAt),
+      updatedAt: new Date(row.updated_at ?? row.updatedAt)
+    };
+  }
+  toPlanTask(row) {
+    return {
+      id: row.id,
+      planId: row.plan_id ?? row.planId,
+      description: row.description,
+      status: row.status,
+      priority: row.priority,
+      notes: row.notes ?? null,
+      position: row.position,
+      createdAt: new Date(row.created_at ?? row.createdAt),
+      updatedAt: new Date(row.updated_at ?? row.updatedAt)
+    };
+  }
+};
+
+// ../../packages/embeddings/dist/client.js
+var OllamaEmbeddingClient = class {
+  host;
+  model;
+  dimensions;
+  maxRetries;
+  constructor(config) {
+    this.host = config?.host ?? (process.env.OLLAMA_HOST ?? DEFAULT_OLLAMA_HOST);
+    this.model = config?.model ?? (process.env.OLLAMA_MODEL ?? DEFAULT_EMBEDDING_MODEL);
+    this.dimensions = config?.dimensions ?? (Number(process.env.EMBEDDING_DIMENSIONS) || DEFAULT_EMBEDDING_DIMENSIONS);
+    this.maxRetries = config?.maxRetries ?? 3;
+  }
+  async embed(text2) {
+    const body = {
+      model: this.model,
+      prompt: text2
+    };
+    const response = await this.fetchWithRetry(`${this.host}/api/embeddings`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Ollama embedding failed (${response.status}): ${errorText}`);
+    }
+    const data = await response.json();
+    if (!data.embedding || !Array.isArray(data.embedding)) {
+      throw new Error("Invalid embedding response from Ollama");
+    }
+    if (data.embedding.length !== this.dimensions) {
+      throw new Error(`Embedding dimension mismatch: expected ${this.dimensions}, got ${data.embedding.length}. Check that OLLAMA_MODEL and EMBEDDING_DIMENSIONS are compatible.`);
+    }
+    return data.embedding;
+  }
+  async embedBatch(texts, concurrency = 3) {
+    const results = [];
+    for (let i = 0; i < texts.length; i += concurrency) {
+      const batch = texts.slice(i, i + concurrency);
+      const batchResults = await Promise.all(batch.map((text2) => this.embed(text2)));
+      results.push(...batchResults);
+    }
+    return results;
+  }
+  async isHealthy() {
+    try {
+      const response = await fetch(`${this.host}/api/tags`);
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  async isModelAvailable() {
+    try {
+      const response = await fetch(`${this.host}/api/tags`);
+      if (!response.ok)
+        return false;
+      const data = await response.json();
+      return data.models.some((m) => m.name === this.model || m.name.startsWith(`${this.model}:`));
+    } catch {
+      return false;
+    }
+  }
+  async pullModel() {
+    const response = await fetch(`${this.host}/api/pull`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name: this.model })
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to pull model ${this.model}: ${response.statusText}`);
+    }
+    const reader = response.body?.getReader();
+    if (reader) {
+      while (true) {
+        const { done } = await reader.read();
+        if (done)
+          break;
+      }
+    }
+  }
+  async ensureModel() {
+    const available = await this.isModelAvailable();
+    if (!available) {
+      await this.pullModel();
+    }
+  }
+  getConfig() {
+    return {
+      host: this.host,
+      model: this.model,
+      dimensions: this.dimensions
+    };
+  }
+  async fetchWithRetry(url, init) {
+    let lastError;
+    for (let attempt = 0; attempt < this.maxRetries; attempt++) {
+      try {
+        return await fetch(url, init);
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (attempt < this.maxRetries - 1) {
+          const delay = Math.pow(2, attempt) * 500;
+          await new Promise((r) => setTimeout(r, delay));
+        }
+      }
+    }
+    throw new Error(`Failed after ${this.maxRetries} retries: ${lastError?.message}`);
+  }
+};
+
+// ../../packages/embeddings/dist/health.js
+async function checkOllamaHealth(client) {
+  try {
+    const healthy = await client.isHealthy();
+    if (!healthy) {
+      return { connected: false, error: "Ollama is not responding" };
+    }
+    const config = client.getConfig();
+    const modelAvailable = await client.isModelAvailable();
+    return {
+      connected: true,
+      model: config.model,
+      modelAvailable,
+      error: modelAvailable ? void 0 : `Model "${config.model}" is not available. Run: ollama pull ${config.model}`
+    };
+  } catch (error) {
+    return {
+      connected: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+// ../../packages/sdk/dist/config.js
+function resolveConfig(userConfig) {
+  return {
+    database: {
+      path: userConfig?.database?.path ?? (process.env.SQLITE_PATH ?? DEFAULT_SQLITE_PATH)
+    },
+    ollama: {
+      host: userConfig?.ollama?.host ?? (process.env.OLLAMA_HOST ?? DEFAULT_OLLAMA_HOST),
+      model: userConfig?.ollama?.model ?? (process.env.OLLAMA_MODEL ?? DEFAULT_EMBEDDING_MODEL),
+      dimensions: userConfig?.ollama?.dimensions ?? (Number(process.env.EMBEDDING_DIMENSIONS) || DEFAULT_EMBEDDING_DIMENSIONS)
+    }
+  };
+}
+
+// ../../packages/sdk/dist/errors.js
+var KnowledgeBaseError = class extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "KnowledgeBaseError";
+  }
+};
+var ConnectionError = class extends KnowledgeBaseError {
+  constructor(message) {
+    super(message, "CONNECTION_ERROR");
+    this.name = "ConnectionError";
+  }
+};
+var EmbeddingError = class extends KnowledgeBaseError {
+  constructor(message) {
+    super(message, "EMBEDDING_ERROR");
+    this.name = "EmbeddingError";
+  }
+};
+var ValidationError = class extends KnowledgeBaseError {
+  constructor(message) {
+    super(message, "VALIDATION_ERROR");
+    this.name = "ValidationError";
+  }
+};
+
+// ../../packages/sdk/dist/sdk.js
+var KnowledgeSDK = class {
+  config;
+  db = null;
+  sqlite = null;
+  service = null;
+  ollamaClient;
+  initialized = false;
+  constructor(config) {
+    this.config = resolveConfig(config);
+    this.ollamaClient = new OllamaEmbeddingClient({
+      host: this.config.ollama.host,
+      model: this.config.ollama.model,
+      dimensions: this.config.ollama.dimensions
+    });
+  }
+  async initialize() {
+    if (this.initialized)
+      return;
+    try {
+      try {
+        const { db, sqlite } = createDbClient(this.config.database.path);
+        this.db = db;
+        this.sqlite = sqlite;
+      } catch (error) {
+        throw new ConnectionError(`Failed to open database: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      try {
+        await this.ollamaClient.ensureModel();
+      } catch (error) {
+        throw new EmbeddingError(`Failed to ensure embedding model: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      const repository = new KnowledgeRepository(this.db, this.sqlite);
+      this.service = new KnowledgeService(repository, this.ollamaClient);
+      this.initialized = true;
+    } catch (error) {
+      await this.cleanup();
+      throw error;
+    }
+  }
+  async close() {
+    await this.cleanup();
+    this.initialized = false;
+  }
+  async addKnowledge(input) {
+    this.ensureInitialized();
+    const parsed = createKnowledgeSchema.safeParse(input);
+    if (!parsed.success) {
+      throw new ValidationError(`Invalid input: ${parsed.error.message}`);
+    }
+    try {
+      return await this.service.add(parsed.data);
+    } catch (error) {
+      throw this.wrapError(error, "Failed to add knowledge");
+    }
+  }
+  async getKnowledge(query, options) {
+    this.ensureInitialized();
+    if (!query || query.trim().length === 0) {
+      throw new ValidationError("Query cannot be empty");
+    }
+    const parsedOptions = options ? searchOptionsSchema.parse(options) : void 0;
+    try {
+      return await this.service.search(query, parsedOptions);
+    } catch (error) {
+      throw this.wrapError(error, "Failed to search knowledge");
+    }
+  }
+  async getKnowledgeById(id) {
+    this.ensureInitialized();
+    try {
+      return await this.service.getById(id);
+    } catch (error) {
+      throw this.wrapError(error, "Failed to get knowledge");
+    }
+  }
+  async updateKnowledge(id, updates) {
+    this.ensureInitialized();
+    const parsed = updateKnowledgeSchema.safeParse(updates);
+    if (!parsed.success) {
+      throw new ValidationError(`Invalid updates: ${parsed.error.message}`);
+    }
+    try {
+      return await this.service.update(id, parsed.data);
+    } catch (error) {
+      throw this.wrapError(error, "Failed to update knowledge");
+    }
+  }
+  async deleteKnowledge(id) {
+    this.ensureInitialized();
+    try {
+      return await this.service.delete(id);
+    } catch (error) {
+      throw this.wrapError(error, "Failed to delete knowledge");
+    }
+  }
+  async listRecent(limit = 20, filters) {
+    this.ensureInitialized();
+    try {
+      return await this.service.listRecent(limit, filters);
+    } catch (error) {
+      throw this.wrapError(error, "Failed to list recent knowledge");
+    }
+  }
+  async getTopTags(limit = 10) {
+    this.ensureInitialized();
+    try {
+      return await this.service.topTags(limit);
+    } catch (error) {
+      throw this.wrapError(error, "Failed to get top tags");
+    }
+  }
+  async listTags() {
+    this.ensureInitialized();
+    try {
+      return await this.service.listTags();
+    } catch (error) {
+      throw this.wrapError(error, "Failed to list tags");
+    }
+  }
+  async getStats() {
+    this.ensureInitialized();
+    try {
+      return await this.service.getStats();
+    } catch (error) {
+      throw this.wrapError(error, "Failed to get stats");
+    }
+  }
+  async listAllKnowledge() {
+    this.ensureInitialized();
+    try {
+      return await this.service.listAll();
+    } catch (error) {
+      throw this.wrapError(error, "Failed to list all knowledge");
+    }
+  }
+  async listScopes() {
+    this.ensureInitialized();
+    try {
+      return await this.service.listScopes();
+    } catch (error) {
+      throw this.wrapError(error, "Failed to list scopes");
+    }
+  }
+  async bulkDeleteKnowledge(ids) {
+    this.ensureInitialized();
+    try {
+      return await this.service.bulkDelete(ids);
+    } catch (error) {
+      throw this.wrapError(error, "Failed to bulk delete knowledge");
+    }
+  }
+  async importKnowledge(entries) {
+    this.ensureInitialized();
+    try {
+      return await this.service.importKnowledge(entries);
+    } catch (error) {
+      throw this.wrapError(error, "Failed to import knowledge");
+    }
+  }
+  async importPlans(plans) {
+    this.ensureInitialized();
+    try {
+      return await this.service.importPlans(plans);
+    } catch (error) {
+      throw this.wrapError(error, "Failed to import plans");
+    }
+  }
+  listAllPlans() {
+    this.ensureInitialized();
+    return this.service.listAllPlans();
+  }
+  // ─── Plans (separate entity) ─────────────────────────────────
+  async createPlan(input) {
+    this.ensureInitialized();
+    const { relatedKnowledgeIds, tasks, ...rest } = input;
+    const parsed = createPlanSchema.safeParse(rest);
+    if (!parsed.success) {
+      throw new ValidationError(`Invalid plan input: ${parsed.error.message}`);
+    }
+    try {
+      const plan = await this.service.createPlan({ ...parsed.data, tasks });
+      if (relatedKnowledgeIds) {
+        for (const kid of relatedKnowledgeIds) {
+          try {
+            this.service.addPlanRelation(plan.id, kid, "input");
+          } catch {
+          }
+        }
+      }
+      return plan;
+    } catch (error) {
+      throw this.wrapError(error, "Failed to create plan");
+    }
+  }
+  getPlanById(id) {
+    this.ensureInitialized();
+    return this.service.getPlanById(id);
+  }
+  updatePlan(id, updates) {
+    this.ensureInitialized();
+    return this.service.updatePlan(id, updates);
+  }
+  deletePlan(id) {
+    this.ensureInitialized();
+    return this.service.deletePlan(id);
+  }
+  listPlans(limit = 20, status) {
+    this.ensureInitialized();
+    return this.service.listPlans(limit, status);
+  }
+  addPlanRelation(planId, knowledgeId, relationType) {
+    this.ensureInitialized();
+    this.service.addPlanRelation(planId, knowledgeId, relationType);
+  }
+  async getPlanRelations(planId) {
+    this.ensureInitialized();
+    return this.service.getPlanRelations(planId);
+  }
+  getPlansForKnowledge(knowledgeId) {
+    this.ensureInitialized();
+    return this.service.getPlansForKnowledge(knowledgeId);
+  }
+  // ─── Plan Tasks ─────────────────────────────────────────────
+  createPlanTask(input) {
+    this.ensureInitialized();
+    return this.service.createPlanTask(input);
+  }
+  updatePlanTask(id, updates) {
+    this.ensureInitialized();
+    return this.service.updatePlanTask(id, updates);
+  }
+  deletePlanTask(id) {
+    this.ensureInitialized();
+    return this.service.deletePlanTask(id);
+  }
+  listPlanTasks(planId) {
+    this.ensureInitialized();
+    return this.service.listPlanTasks(planId);
+  }
+  getPlanTaskStats() {
+    this.ensureInitialized();
+    return this.service.getPlanTaskStats();
+  }
+  // ─── Operations ─────────────────────────────────────────────
+  getOperationCounts() {
+    this.ensureInitialized();
+    return this.service.getOperationCounts();
+  }
+  getOperationsByDay(days = 15) {
+    this.ensureInitialized();
+    return this.service.getOperationsByDay(days);
+  }
+  cleanupOldOperations() {
+    if (!this.initialized || !this.service)
+      return 0;
+    return this.service.cleanupOldOperations();
+  }
+  async healthCheck() {
+    const ollamaHealth = await checkOllamaHealth(this.ollamaClient);
+    let dbConnected = false;
+    let dbError;
+    if (this.sqlite) {
+      try {
+        this.sqlite.prepare("SELECT 1").get();
+        dbConnected = true;
+      } catch (error) {
+        dbError = error instanceof Error ? error.message : String(error);
+      }
+    } else {
+      dbError = "Not initialized";
+    }
+    return {
+      database: {
+        connected: dbConnected,
+        path: this.config.database.path,
+        error: dbError
+      },
+      ollama: {
+        connected: ollamaHealth.connected,
+        model: ollamaHealth.model,
+        host: this.config.ollama.host,
+        error: ollamaHealth.error
+      }
+    };
+  }
+  /**
+   * Remove orphan embeddings (no matching entry) and run VACUUM.
+   * Returns count of orphans removed and final DB size.
+   */
+  async cleanupDatabase() {
+    this.ensureInitialized();
+    try {
+      const orphanIds = this.sqlite.prepare(`SELECT id FROM knowledge_embeddings_rowids WHERE id NOT IN (SELECT id FROM knowledge_entries)`).all();
+      let removed = 0;
+      const deleteStmt = this.sqlite.prepare(`DELETE FROM knowledge_embeddings WHERE id = ?`);
+      for (const row of orphanIds) {
+        deleteStmt.run(row.id);
+        removed++;
+      }
+      this.sqlite.exec("VACUUM");
+      return { orphansRemoved: removed, vacuumed: true };
+    } catch (error) {
+      throw this.wrapError(error, "Failed to cleanup database");
+    }
+  }
+  ensureInitialized() {
+    if (!this.initialized || !this.service) {
+      throw new ConnectionError("SDK not initialized. Call initialize() first.");
+    }
+  }
+  async cleanup() {
+    if (this.sqlite) {
+      try {
+        this.sqlite.close();
+      } catch {
+      }
+      this.sqlite = null;
+    }
+    this.db = null;
+    this.service = null;
+  }
+  wrapError(error, context) {
+    if (error instanceof Error && error.name.endsWith("Error")) {
+      return error;
+    }
+    return new ConnectionError(`${context}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+};
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z as z2 } from "zod";
+var knowledgeTypeValues = ["decision", "pattern", "fix", "constraint", "gotcha"];
+var knowledgeStatusValues = ["draft", "active", "completed", "archived"];
+function createServer(sdk) {
+  const server = new McpServer({
+    name: "cognistore",
+    version: "0.1.0"
+  });
+  server.tool(
+    "addKnowledge",
+    "Store a new knowledge entry with semantic embedding. Content is vectorized for future semantic search.",
+    {
+      title: z2.string().describe("Short descriptive title for the knowledge entry"),
+      content: z2.string().describe("The knowledge content text to store"),
+      tags: z2.array(z2.string()).describe("Mandatory categorical tags for filtering"),
+      type: z2.enum(knowledgeTypeValues).describe("Type of knowledge entry"),
+      scope: z2.string().describe('Scope: "global" or "workspace:<project-name>"'),
+      source: z2.string().describe("Source of the knowledge"),
+      confidenceScore: z2.number().min(0).max(1).optional().describe("Confidence score 0-1"),
+      agentId: z2.string().optional().describe("ID of the agent that created this")
+    },
+    async (params) => {
+      const result = await sdk.addKnowledge({
+        title: params.title,
+        content: params.content,
+        tags: params.tags,
+        type: params.type,
+        scope: params.scope,
+        source: params.source,
+        confidenceScore: params.confidenceScore,
+        agentId: params.agentId
+      });
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server.tool(
+    "getKnowledge",
+    "Search knowledge semantically. When a specific scope is provided, global knowledge is always included.",
+    {
+      query: z2.string().describe("Natural language query to search for"),
+      tags: z2.array(z2.string()).optional().describe("Optional tag filters"),
+      type: z2.enum(knowledgeTypeValues).optional().describe("Optional type filter"),
+      scope: z2.string().optional().describe("Optional scope filter (global always included)"),
+      limit: z2.number().optional().describe("Max results (default: 10)"),
+      threshold: z2.number().optional().describe("Min similarity 0-1 (default: 0.3)")
+    },
+    async (params) => {
+      const results = await sdk.getKnowledge(params.query, {
+        tags: params.tags,
+        type: params.type,
+        scope: params.scope,
+        limit: params.limit,
+        threshold: params.threshold
+      });
+      return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+    }
+  );
+  server.tool(
+    "updateKnowledge",
+    "Update an existing knowledge entry. If content changes, embedding is regenerated. Version auto-increments.",
+    {
+      id: z2.string().describe("UUID of the knowledge entry to update"),
+      title: z2.string().optional().describe("New title"),
+      content: z2.string().optional().describe("New content text"),
+      tags: z2.array(z2.string()).optional().describe("New tags"),
+      type: z2.enum(knowledgeTypeValues).optional().describe("New type"),
+      scope: z2.string().optional().describe("New scope"),
+      source: z2.string().optional().describe("New source"),
+      confidenceScore: z2.number().min(0).max(1).optional().describe("New confidence score")
+    },
+    async (params) => {
+      const { id, ...updates } = params;
+      const result = await sdk.updateKnowledge(id, {
+        title: updates.title,
+        content: updates.content,
+        tags: updates.tags,
+        type: updates.type,
+        scope: updates.scope,
+        source: updates.source,
+        confidenceScore: updates.confidenceScore
+      });
+      const text2 = result ? JSON.stringify(result, null, 2) : "Knowledge entry not found";
+      return { content: [{ type: "text", text: text2 }] };
+    }
+  );
+  server.tool(
+    "deleteKnowledge",
+    "Delete a knowledge entry by ID.",
+    {
+      id: z2.string().describe("UUID of the knowledge entry to delete")
+    },
+    async (params) => {
+      const deleted = await sdk.deleteKnowledge(params.id);
+      return {
+        content: [{ type: "text", text: deleted ? "Deleted successfully" : "Not found" }]
+      };
+    }
+  );
+  server.tool(
+    "listTags",
+    "List all unique tags across all knowledge entries.",
+    {},
+    async () => {
+      const tags = await sdk.listTags();
+      return { content: [{ type: "text", text: JSON.stringify(tags) }] };
+    }
+  );
+  server.tool(
+    "healthCheck",
+    "Check health of the knowledge base infrastructure (database, Ollama).",
+    {},
+    async () => {
+      const health = await sdk.healthCheck();
+      return { content: [{ type: "text", text: JSON.stringify(health, null, 2) }] };
+    }
+  );
+  server.tool(
+    "createPlan",
+    "Create a new plan in the knowledge base. Plans are the ONLY way to persist implementation plans \u2014 never use local files. Status starts as draft.",
+    {
+      title: z2.string().describe("Plan title (short, descriptive)"),
+      content: z2.string().describe("Full plan content (steps, approach, considerations)"),
+      tags: z2.array(z2.string()).describe("Tags for categorization"),
+      scope: z2.string().describe('Scope: "global" or "workspace:<project-name>"'),
+      source: z2.string().describe("Source/context of the plan"),
+      relatedKnowledgeIds: z2.array(z2.string()).optional().describe("IDs of knowledge entries consulted during planning (input relations)"),
+      tasks: z2.array(z2.object({
+        description: z2.string(),
+        priority: z2.enum(["low", "medium", "high"]).optional()
+      })).optional().describe("Initial tasks for the plan todo list")
+    },
+    async (params) => {
+      const result = await sdk.createPlan({
+        title: params.title,
+        content: params.content,
+        tags: params.tags,
+        scope: params.scope,
+        source: params.source,
+        relatedKnowledgeIds: params.relatedKnowledgeIds,
+        tasks: params.tasks
+      });
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server.tool(
+    "updatePlan",
+    "Update an existing plan. Use to change status (draft \u2192 active \u2192 completed \u2192 archived), title, content, tags, or scope.",
+    {
+      planId: z2.string().describe("UUID of the plan to update"),
+      title: z2.string().optional().describe("New title"),
+      content: z2.string().optional().describe("New content"),
+      tags: z2.array(z2.string()).optional().describe("New tags"),
+      scope: z2.string().optional().describe("New scope"),
+      status: z2.enum(knowledgeStatusValues).optional().describe("New status"),
+      source: z2.string().optional().describe("New source")
+    },
+    async (params) => {
+      const { planId, ...updates } = params;
+      const result = sdk.updatePlan(planId, updates);
+      const text2 = result ? JSON.stringify(result, null, 2) : "Plan not found";
+      return { content: [{ type: "text", text: text2 }] };
+    }
+  );
+  server.tool(
+    "addPlanRelation",
+    'Link a knowledge entry to a plan. Use "input" for entries consulted during planning, "output" for entries created/updated during execution.',
+    {
+      planId: z2.string().describe("UUID of the plan"),
+      knowledgeId: z2.string().describe("UUID of the knowledge entry to link"),
+      relationType: z2.enum(["input", "output"]).describe('"input" = consulted during planning, "output" = created/updated during execution')
+    },
+    async (params) => {
+      sdk.addPlanRelation(params.planId, params.knowledgeId, params.relationType);
+      return { content: [{ type: "text", text: JSON.stringify({ success: true, ...params }) }] };
+    }
+  );
+  server.tool(
+    "addPlanTask",
+    "Add a task to a plan todo list. Position is auto-calculated.",
+    {
+      planId: z2.string().describe("UUID of the plan"),
+      description: z2.string().describe("Task description"),
+      priority: z2.enum(["low", "medium", "high"]).optional().describe("Priority (default: medium)"),
+      notes: z2.string().optional().describe("Optional notes")
+    },
+    async (params) => {
+      const task = sdk.createPlanTask(params);
+      return { content: [{ type: "text", text: JSON.stringify(task, null, 2) }] };
+    }
+  );
+  server.tool(
+    "updatePlanTask",
+    "Update a plan task. Mark in_progress when starting, completed when done. Add notes for context.",
+    {
+      taskId: z2.string().describe("UUID of the task"),
+      status: z2.enum(["pending", "in_progress", "completed"]).optional().describe("New status"),
+      description: z2.string().optional().describe("New description"),
+      priority: z2.enum(["low", "medium", "high"]).optional().describe("New priority"),
+      notes: z2.string().nullable().optional().describe("Notes about progress or blockers")
+    },
+    async (params) => {
+      const { taskId, ...updates } = params;
+      const task = sdk.updatePlanTask(taskId, updates);
+      const text2 = task ? JSON.stringify(task, null, 2) : "Task not found";
+      return { content: [{ type: "text", text: text2 }] };
+    }
+  );
+  server.tool(
+    "listPlanTasks",
+    "List all tasks for a plan, ordered by position. Use to check progress or resume work.",
+    {
+      planId: z2.string().describe("UUID of the plan")
+    },
+    async (params) => {
+      const tasks = sdk.listPlanTasks(params.planId);
+      return { content: [{ type: "text", text: JSON.stringify(tasks, null, 2) }] };
+    }
+  );
+  return server;
+}
+
+// src/index.ts
+async function main() {
+  const sdk = new KnowledgeSDK();
+  try {
+    await sdk.initialize();
+  } catch (error) {
+    console.error("Failed to initialize AI Knowledge SDK:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+  const server = createServer(sdk);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  const shutdown = async () => {
+    await sdk.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});