@kaban-board/core 0.2.11 → 0.2.13

package/dist/index-bun.js

@@ -0,0 +1,1207 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/types.ts
+var DEFAULT_CONFIG, KabanError, ExitCode;
+var init_types = __esm(() => {
+  DEFAULT_CONFIG = {
+    board: {
+      name: "Kaban Board"
+    },
+    columns: [
+      { id: "backlog", name: "Backlog" },
+      { id: "todo", name: "Todo" },
+      { id: "in_progress", name: "In Progress", wipLimit: 3 },
+      { id: "review", name: "Review", wipLimit: 2 },
+      { id: "done", name: "Done", isTerminal: true }
+    ],
+    defaults: {
+      column: "todo",
+      agent: "user"
+    }
+  };
+  KabanError = class KabanError extends Error {
+    code;
+    constructor(message, code) {
+      super(message);
+      this.code = code;
+      this.name = "KabanError";
+    }
+  };
+  ExitCode = {
+    SUCCESS: 0,
+    GENERAL_ERROR: 1,
+    NOT_FOUND: 2,
+    CONFLICT: 3,
+    VALIDATION: 4
+  };
+});
+
+// src/db/utils.ts
+import { existsSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+function fileUrlToPath(urlOrPath) {
+  if (!urlOrPath.startsWith("file:"))
+    return urlOrPath;
+  if (urlOrPath.startsWith("file:///") || urlOrPath.startsWith("file://localhost/")) {
+    return fileURLToPath(urlOrPath);
+  }
+  return urlOrPath.replace(/^file:/, "");
+}
+function ensureDbDir(filePath) {
+  if (filePath === ":memory:" || filePath.trim() === "")
+    return;
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+var init_utils = () => {};
+
+// src/db/schema.ts
+var exports_schema = {};
+__export(exports_schema, {
+  undoLog: () => undoLog,
+  tasks: () => tasks,
+  columns: () => columns,
+  boards: () => boards
+});
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+var boards, columns, tasks, undoLog;
+var init_schema = __esm(() => {
+  boards = sqliteTable("boards", {
+    id: text("id").primaryKey(),
+    name: text("name").notNull(),
+    createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+    updatedAt: integer("updated_at", { mode: "timestamp" }).notNull()
+  });
+  columns = sqliteTable("columns", {
+    id: text("id").primaryKey(),
+    boardId: text("board_id").notNull().references(() => boards.id),
+    name: text("name").notNull(),
+    position: integer("position").notNull(),
+    wipLimit: integer("wip_limit"),
+    isTerminal: integer("is_terminal", { mode: "boolean" }).notNull().default(false)
+  });
+  tasks = sqliteTable("tasks", {
+    id: text("id").primaryKey(),
+    title: text("title").notNull(),
+    description: text("description"),
+    columnId: text("column_id").notNull().references(() => columns.id),
+    position: integer("position").notNull(),
+    createdBy: text("created_by").notNull(),
+    assignedTo: text("assigned_to"),
+    parentId: text("parent_id").references(() => tasks.id),
+    dependsOn: text("depends_on", { mode: "json" }).$type().notNull().default([]),
+    files: text("files", { mode: "json" }).$type().notNull().default([]),
+    labels: text("labels", { mode: "json" }).$type().notNull().default([]),
+    blockedReason: text("blocked_reason"),
+    version: integer("version").notNull().default(1),
+    createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+    updatedAt: integer("updated_at", { mode: "timestamp" }).notNull(),
+    startedAt: integer("started_at", { mode: "timestamp" }),
+    completedAt: integer("completed_at", { mode: "timestamp" }),
+    archived: integer("archived", { mode: "boolean" }).notNull().default(false),
+    archivedAt: integer("archived_at", { mode: "timestamp" })
+  });
+  undoLog = sqliteTable("undo_log", {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    operation: text("operation").notNull(),
+    data: text("data", { mode: "json" }).notNull(),
+    createdAt: integer("created_at", { mode: "timestamp" }).notNull()
+  });
+});
+
+// drizzle/meta/_journal.json
+var _journal_default;
+var init__journal = __esm(() => {
+  _journal_default = {
+    version: "7",
+    dialect: "sqlite",
+    entries: [
+      {
+        idx: 0,
+        version: "6",
+        when: 1769351194943,
+        tag: "0000_init",
+        breakpoints: true
+      },
+      {
+        idx: 1,
+        version: "6",
+        when: 1769351198000,
+        tag: "0001_add_archived",
+        breakpoints: true
+      },
+      {
+        idx: 2,
+        version: "6",
+        when: 1769351200000,
+        tag: "0002_add_fts5",
+        breakpoints: true
+      }
+    ]
+  };
+});
+
+// drizzle/0000_init.sql
+var _0000_init_default = "CREATE TABLE `boards` (\n\t`id` text PRIMARY KEY NOT NULL,\n\t`name` text NOT NULL,\n\t`created_at` integer NOT NULL,\n\t`updated_at` integer NOT NULL\n);\n--> statement-breakpoint\nCREATE TABLE `columns` (\n\t`id` text PRIMARY KEY NOT NULL,\n\t`board_id` text NOT NULL,\n\t`name` text NOT NULL,\n\t`position` integer NOT NULL,\n\t`wip_limit` integer,\n\t`is_terminal` integer DEFAULT false NOT NULL,\n\tFOREIGN KEY (`board_id`) REFERENCES `boards`(`id`) ON UPDATE no action ON DELETE no action\n);\n--> statement-breakpoint\nCREATE TABLE `tasks` (\n\t`id` text PRIMARY KEY NOT NULL,\n\t`title` text NOT NULL,\n\t`description` text,\n\t`column_id` text NOT NULL,\n\t`position` integer NOT NULL,\n\t`created_by` text NOT NULL,\n\t`assigned_to` text,\n\t`parent_id` text,\n\t`depends_on` text DEFAULT '[]' NOT NULL,\n\t`files` text DEFAULT '[]' NOT NULL,\n\t`labels` text DEFAULT '[]' NOT NULL,\n\t`blocked_reason` text,\n\t`version` integer DEFAULT 1 NOT NULL,\n\t`created_at` integer NOT NULL,\n\t`updated_at` integer NOT NULL,\n\t`started_at` integer,\n\t`completed_at` integer,\n\t`archived` integer DEFAULT false NOT NULL,\n\t`archived_at` integer,\n\tFOREIGN KEY (`column_id`) REFERENCES `columns`(`id`) ON UPDATE no action ON DELETE no action,\n\tFOREIGN KEY (`parent_id`) REFERENCES `tasks`(`id`) ON UPDATE no action ON DELETE no action\n);\n--> statement-breakpoint\nCREATE TABLE `undo_log` (\n\t`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,\n\t`operation` text NOT NULL,\n\t`data` text NOT NULL,\n\t`created_at` integer NOT NULL\n);\n";
+var init_0000_init = () => {};
+
+// drizzle/0001_add_archived.sql
+var _0001_add_archived_default = `-- Add archived columns for task archiving feature
+-- SQLite doesn't support ADD COLUMN IF NOT EXISTS, so we check manually
+-- These columns may already exist in newer databases
+
+ALTER TABLE tasks ADD COLUMN archived INTEGER DEFAULT false NOT NULL;
+--> statement-breakpoint
+ALTER TABLE tasks ADD COLUMN archived_at INTEGER;
+`;
+var init_0001_add_archived = () => {};
+
+// drizzle/0002_add_fts5.sql
+var _0002_add_fts5_default = `-- Add index for archived column
+CREATE INDEX IF NOT EXISTS idx_tasks_archived ON tasks(archived);
+--> statement-breakpoint
+-- Create FTS5 virtual table for full-text search
+-- Uses unicode61 tokenizer with remove_diacritics for proper Russian language support
+CREATE VIRTUAL TABLE IF NOT EXISTS tasks_fts USING fts5(
+  id, title, description,
+  content='tasks',
+  content_rowid='rowid',
+  tokenize='unicode61 remove_diacritics 2'
+);
+--> statement-breakpoint
+-- Create trigger to keep FTS in sync on INSERT
+CREATE TRIGGER IF NOT EXISTS tasks_fts_insert AFTER INSERT ON tasks BEGIN
+  INSERT INTO tasks_fts(rowid, id, title, description)
+  VALUES (NEW.rowid, NEW.id, NEW.title, COALESCE(NEW.description, ''));
+END;
+--> statement-breakpoint
+-- Create trigger to keep FTS in sync on DELETE
+CREATE TRIGGER IF NOT EXISTS tasks_fts_delete AFTER DELETE ON tasks BEGIN
+  INSERT INTO tasks_fts(tasks_fts, rowid, id, title, description)
+  VALUES('delete', OLD.rowid, OLD.id, OLD.title, COALESCE(OLD.description, ''));
+END;
+--> statement-breakpoint
+-- Create trigger to keep FTS in sync on UPDATE
+CREATE TRIGGER IF NOT EXISTS tasks_fts_update AFTER UPDATE ON tasks BEGIN
+  INSERT INTO tasks_fts(tasks_fts, rowid, id, title, description)
+  VALUES('delete', OLD.rowid, OLD.id, OLD.title, COALESCE(OLD.description, ''));
+  INSERT INTO tasks_fts(rowid, id, title, description)
+  VALUES (NEW.rowid, NEW.id, NEW.title, COALESCE(NEW.description, ''));
+END;
+--> statement-breakpoint
+-- Populate FTS with existing data (only if FTS table is empty)
+INSERT INTO tasks_fts(rowid, id, title, description)
+SELECT rowid, id, title, COALESCE(description, '') FROM tasks
+WHERE NOT EXISTS (SELECT 1 FROM tasks_fts LIMIT 1);
+`;
+var init_0002_add_fts5 = () => {};
+
+// src/db/migrator.ts
+var exports_migrator = {};
+__export(exports_migrator, {
+  runMigrations: () => runMigrations
+});
+import { readFileSync } from "node:fs";
+import { dirname as dirname2, isAbsolute, join } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+function resolveSqlContent(sqlOrPath) {
+  if (sqlOrPath.includes("CREATE") || sqlOrPath.includes("INSERT") || sqlOrPath.includes("--")) {
+    return sqlOrPath;
+  }
+  let filePath = sqlOrPath;
+  if (filePath.startsWith("./")) {
+    filePath = join(drizzleDir, filePath.replace("./", "").replace(/-[a-z0-9]+\.sql$/, ".sql"));
+  }
+  if (!isAbsolute(filePath)) {
+    filePath = join(drizzleDir, filePath);
+  }
+  return readFileSync(filePath, "utf-8");
+}
+function getMigrations() {
+  const j = _journal_default;
+  return j.entries.map((entry) => ({
+    tag: entry.tag,
+    sql: resolveSqlContent(migrationSql[entry.tag] ?? "")
+  }));
+}
+async function getAppliedMigrations(db) {
+  try {
+    const results = [];
+    const client = db.$client;
+    if (client && typeof client.prepare === "function") {
+      const bunClient = client;
+      const rows = bunClient.prepare("SELECT tag FROM __drizzle_migrations").all();
+      return new Set(rows.map((r) => r.tag));
+    }
+    if (client && typeof client.execute === "function") {
+      const libsqlClient = client;
+      const res = await libsqlClient.execute("SELECT tag FROM __drizzle_migrations");
+      return new Set(res.rows.map((r) => String(r.tag)));
+    }
+    return new Set(results.map((r) => r.tag));
+  } catch {
+    return new Set;
+  }
+}
+async function createMigrationsTable(db) {
+  await db.$runRaw(`
+    CREATE TABLE IF NOT EXISTS __drizzle_migrations (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      tag TEXT NOT NULL UNIQUE,
+      created_at INTEGER NOT NULL
+    )
+  `);
+}
+async function recordMigration(db, tag) {
+  const now = Date.now();
+  await db.$runRaw(`INSERT INTO __drizzle_migrations (tag, created_at) VALUES ('${tag}', ${now})`);
+}
+async function isLegacyDatabase(db) {
+  try {
+    const client = db.$client;
+    if (client && typeof client.prepare === "function") {
+      const bunClient = client;
+      const tables = bunClient.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='boards'").all();
+      return tables.length > 0;
+    }
+    if (client && typeof client.execute === "function") {
+      const libsqlClient = client;
+      const res = await libsqlClient.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='boards'");
+      return res.rows.length > 0;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+async function runMigrations(db) {
+  const isLegacy = await isLegacyDatabase(db);
+  await createMigrationsTable(db);
+  const applied = await getAppliedMigrations(db);
+  if (isLegacy && applied.size === 0) {
+    await recordMigration(db, "0000_init");
+    applied.add("0000_init");
+  }
+  const migrations = getMigrations();
+  const toApply = migrations.filter((m) => !applied.has(m.tag));
+  const newlyApplied = [];
+  for (const migration of toApply) {
+    if (!migration.sql) {
+      throw new Error(`Migration SQL not found for: ${migration.tag}`);
+    }
+    const statements = migration.sql.split("--> statement-breakpoint").map((s) => s.trim()).filter(Boolean);
+    for (const stmt of statements) {
+      try {
+        await db.$runRaw(stmt);
+      } catch (err) {
+        const msg = String(err);
+        if (stmt.includes("ADD COLUMN") && msg.includes("duplicate column name")) {
+          continue;
+        }
+        throw err;
+      }
+    }
+    await recordMigration(db, migration.tag);
+    newlyApplied.push(migration.tag);
+  }
+  return { applied: newlyApplied };
+}
+var migrationSql, __dirname2, drizzleDir;
+var init_migrator = __esm(() => {
+  init__journal();
+  init_0000_init();
+  init_0001_add_archived();
+  init_0002_add_fts5();
+  migrationSql = {
+    "0000_init": _0000_init_default,
+    "0001_add_archived": _0001_add_archived_default,
+    "0002_add_fts5": _0002_add_fts5_default
+  };
+  __dirname2 = dirname2(fileURLToPath2(import.meta.url));
+  drizzleDir = join(__dirname2, "..", "..", "drizzle");
+});
+
+// src/db/bun-adapter.ts
+var exports_bun_adapter = {};
+__export(exports_bun_adapter, {
+  createBunDb: () => createBunDb
+});
+async function createBunDb(filePath) {
+  let sqlite;
+  try {
+    const { Database } = await import("bun:sqlite");
+    const { drizzle } = await import("drizzle-orm/bun-sqlite");
+    ensureDbDir(filePath);
+    sqlite = new Database(filePath);
+    const db = drizzle({ client: sqlite, schema: exports_schema });
+    let closed = false;
+    const sqliteRef = sqlite;
+    return Object.assign(db, {
+      $client: sqliteRef,
+      $runRaw: async (sql) => {
+        try {
+          if (typeof sqliteRef.exec === "function") {
+            sqliteRef.exec(sql);
+            return;
+          }
+          const statements = sql.split(";").filter((s) => s.trim());
+          for (const stmt of statements) {
+            sqliteRef.run(stmt);
+          }
+        } catch (error) {
+          throw new KabanError(`SQL execution failed: ${error instanceof Error ? error.message : String(error)}`, ExitCode.GENERAL_ERROR);
+        }
+      },
+      $close: async () => {
+        if (closed)
+          return;
+        closed = true;
+        try {
+          sqliteRef.close();
+        } catch {}
+      }
+    });
+  } catch (error) {
+    try {
+      sqlite?.close?.();
+    } catch {}
+    if (error instanceof KabanError)
+      throw error;
+    throw new KabanError(`Failed to create Bun database: ${error instanceof Error ? error.message : String(error)}`, ExitCode.GENERAL_ERROR);
+  }
+}
+var init_bun_adapter = __esm(() => {
+  init_types();
+  init_schema();
+  init_utils();
+});
+
+// src/db/bun-only.ts
+init_types();
+init_utils();
+init_migrator();
+init_schema();
+async function createDb(config, options = {}) {
+  const { migrate = true } = options;
+  try {
+    const driver = process.env.KABAN_DB_DRIVER;
+    if (driver === "libsql") {
+      throw new KabanError("LibSQL driver requested but this build only supports bun:sqlite", ExitCode.GENERAL_ERROR);
+    }
+    const { createBunDb: createBunDb2 } = await Promise.resolve().then(() => (init_bun_adapter(), exports_bun_adapter));
+    let db;
+    if (typeof config === "string") {
+      db = await createBunDb2(config);
+    } else {
+      db = await createBunDb2(fileUrlToPath(config.url));
+    }
+    if (migrate) {
+      const { runMigrations: runMigrations2 } = await Promise.resolve().then(() => (init_migrator(), exports_migrator));
+      await runMigrations2(db);
+    }
+    return db;
+  } catch (error) {
+    if (error instanceof KabanError)
+      throw error;
+    throw new KabanError(`Failed to create database: ${error instanceof Error ? error.message : String(error)}`, ExitCode.GENERAL_ERROR);
+  }
+}
+async function initializeSchema(db) {
+  const SCHEMA_SQL = `
+PRAGMA journal_mode = WAL;
+
+CREATE TABLE IF NOT EXISTS boards (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS columns (
+  id TEXT PRIMARY KEY,
+  board_id TEXT NOT NULL REFERENCES boards(id),
+  name TEXT NOT NULL,
+  position INTEGER NOT NULL,
+  wip_limit INTEGER,
+  is_terminal INTEGER NOT NULL DEFAULT 0
+);
+
+CREATE TABLE IF NOT EXISTS tasks (
+  id TEXT PRIMARY KEY,
+  title TEXT NOT NULL,
+  description TEXT,
+  column_id TEXT NOT NULL REFERENCES columns(id),
+  position INTEGER NOT NULL,
+  created_by TEXT NOT NULL,
+  assigned_to TEXT,
+  parent_id TEXT REFERENCES tasks(id),
+  depends_on TEXT NOT NULL DEFAULT '[]',
+  files TEXT NOT NULL DEFAULT '[]',
+  labels TEXT NOT NULL DEFAULT '[]',
+  blocked_reason TEXT,
+  version INTEGER NOT NULL DEFAULT 1,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  started_at INTEGER,
+  completed_at INTEGER,
+  archived INTEGER NOT NULL DEFAULT 0,
+  archived_at INTEGER
+);
+
+CREATE TABLE IF NOT EXISTS undo_log (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  operation TEXT NOT NULL,
+  data TEXT NOT NULL,
+  created_at INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_tasks_column ON tasks(column_id);
+CREATE INDEX IF NOT EXISTS idx_tasks_parent ON tasks(parent_id);
+`;
+  await db.$runRaw(SCHEMA_SQL);
+}
+// src/schemas.ts
+import { z } from "zod/v4";
+var ULID_REGEX = /^[0-9A-HJKMNP-TV-Z]{26}$/;
+var UlidSchema = z.string().regex(ULID_REGEX, "Invalid ULID format");
+var TitleBaseSchema = z.string().min(1, "Title cannot be empty").max(200, "Title cannot exceed 200 characters");
+var TitleSchema = TitleBaseSchema.transform((s) => s.trim());
+var AgentNameBaseSchema = z.string().min(1, "Agent name cannot be empty").max(50, "Agent name cannot exceed 50 characters").regex(/^[a-zA-Z][a-zA-Z0-9_-]*$/, "Agent name must start with letter, then alphanumeric with _ or -");
+var AgentNameSchema = AgentNameBaseSchema.transform((s) => s.toLowerCase());
+var ColumnIdSchema = z.string().min(1, "Column ID cannot be empty").max(50, "Column ID cannot exceed 50 characters").regex(/^[a-z0-9_]+$/, "Column ID must be lowercase alphanumeric with underscores");
+var TaskSchema = z.object({
+  id: UlidSchema,
+  title: z.string(),
+  description: z.string().nullable(),
+  columnId: z.string(),
+  position: z.number().int().nonnegative(),
+  createdBy: z.string(),
+  assignedTo: z.string().nullable(),
+  parentId: UlidSchema.nullable(),
+  dependsOn: z.array(UlidSchema),
+  files: z.array(z.string()),
+  labels: z.array(z.string()),
+  blockedReason: z.string().nullable(),
+  version: z.number().int().positive(),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+  startedAt: z.date().nullable(),
+  completedAt: z.date().nullable(),
+  archived: z.boolean().default(false),
+  archivedAt: z.date().nullable().optional()
+});
+var ColumnSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  position: z.number().int().nonnegative(),
+  wipLimit: z.number().int().positive().nullable(),
+  isTerminal: z.boolean()
+});
+var BoardSchema = z.object({
+  id: UlidSchema,
+  name: z.string(),
+  createdAt: z.date(),
+  updatedAt: z.date()
+});
+var BoardResponseSchema = z.object({
+  id: UlidSchema,
+  name: z.string(),
+  createdAt: z.string().datetime(),
+  updatedAt: z.string().datetime()
+});
+var ColumnConfigSchema = z.object({
+  id: ColumnIdSchema,
+  name: z.string().min(1).max(50),
+  wipLimit: z.number().int().positive().optional(),
+  isTerminal: z.boolean().optional()
+});
+var ConfigSchema = z.object({
+  board: z.object({
+    name: z.string().min(1).max(100)
+  }),
+  columns: z.array(ColumnConfigSchema).min(1),
+  defaults: z.object({
+    column: ColumnIdSchema,
+    agent: AgentNameSchema
+  })
+});
+var AddTaskInputSchema = z.object({
+  title: TitleSchema,
+  description: z.string().max(5000).optional(),
+  columnId: ColumnIdSchema.optional(),
+  createdBy: AgentNameSchema.optional(),
+  agent: AgentNameSchema.optional(),
+  assignedTo: AgentNameSchema.optional(),
+  dependsOn: z.array(UlidSchema).optional(),
+  files: z.array(z.string()).optional(),
+  labels: z.array(z.string().max(50)).optional()
+});
+var UpdateTaskInputSchema = z.object({
+  title: TitleSchema.optional(),
+  description: z.string().max(5000).nullable().optional(),
+  assignedTo: AgentNameSchema.nullable().optional(),
+  files: z.array(z.string()).optional(),
+  labels: z.array(z.string().max(50)).optional()
+});
+var MoveTaskInputSchema = z.object({
+  id: UlidSchema,
+  columnId: ColumnIdSchema,
+  force: z.boolean().optional()
+});
+var ListTasksFilterSchema = z.object({
+  columnId: ColumnIdSchema.optional(),
+  createdBy: AgentNameSchema.optional(),
+  agent: AgentNameSchema.optional(),
+  assignee: AgentNameSchema.optional(),
+  blocked: z.boolean().optional(),
+  includeArchived: z.boolean().optional()
+});
+var GetTaskInputSchema = z.object({
+  id: UlidSchema
+});
+var DeleteTaskInputSchema = z.object({
+  id: UlidSchema
+});
+var TaskResponseSchema = TaskSchema.extend({
+  createdAt: z.string().datetime(),
+  updatedAt: z.string().datetime(),
+  startedAt: z.string().datetime().nullable(),
+  completedAt: z.string().datetime().nullable(),
+  archivedAt: z.string().datetime().nullable().optional()
+});
+var BoardStatusSchema = z.object({
+  board: BoardResponseSchema,
+  columns: z.array(ColumnSchema.extend({
+    taskCount: z.number().int().nonnegative()
+  })),
+  totalTasks: z.number().int().nonnegative()
+});
+var ApiResponseSchema = (dataSchema) => z.object({
+  success: z.boolean(),
+  data: dataSchema.optional(),
+  error: z.object({
+    message: z.string(),
+    code: z.number()
+  }).optional()
+});
+var AddTaskInputJsonSchema = z.object({
+  title: TitleBaseSchema,
+  description: z.string().max(5000).optional(),
+  columnId: ColumnIdSchema.optional(),
+  createdBy: AgentNameBaseSchema.optional(),
+  agent: AgentNameBaseSchema.optional(),
+  assignedTo: AgentNameBaseSchema.optional(),
+  dependsOn: z.array(UlidSchema).optional(),
+  files: z.array(z.string()).optional(),
+  labels: z.array(z.string().max(50)).optional()
+});
+var UpdateTaskInputJsonSchema = z.object({
+  title: TitleBaseSchema.optional(),
+  description: z.string().max(5000).nullable().optional(),
+  assignedTo: AgentNameBaseSchema.nullable().optional(),
+  files: z.array(z.string()).optional(),
+  labels: z.array(z.string().max(50)).optional()
+});
+var ListTasksFilterJsonSchema = z.object({
+  columnId: ColumnIdSchema.optional(),
+  createdBy: AgentNameBaseSchema.optional(),
+  agent: AgentNameBaseSchema.optional(),
+  assignee: AgentNameBaseSchema.optional(),
+  blocked: z.boolean().optional(),
+  includeArchived: z.boolean().optional()
+});
+var ColumnConfigJsonSchema = z.object({
+  id: ColumnIdSchema,
+  name: z.string().min(1).max(50),
+  wipLimit: z.number().int().positive().optional(),
+  isTerminal: z.boolean().optional()
+});
+var ConfigJsonSchema = z.object({
+  board: z.object({
+    name: z.string().min(1).max(100)
+  }),
+  columns: z.array(ColumnConfigJsonSchema).min(1),
+  defaults: z.object({
+    column: ColumnIdSchema,
+    agent: AgentNameBaseSchema
+  })
+});
+var jsonSchemas = {
+  Task: z.toJSONSchema(TaskResponseSchema),
+  Column: z.toJSONSchema(ColumnSchema),
+  Board: z.toJSONSchema(BoardResponseSchema),
+  Config: z.toJSONSchema(ConfigJsonSchema),
+  AddTaskInput: z.toJSONSchema(AddTaskInputJsonSchema),
+  UpdateTaskInput: z.toJSONSchema(UpdateTaskInputJsonSchema),
+  MoveTaskInput: z.toJSONSchema(MoveTaskInputSchema),
+  ListTasksFilter: z.toJSONSchema(ListTasksFilterJsonSchema),
+  BoardStatus: z.toJSONSchema(BoardStatusSchema)
+};
+function getJsonSchema(name) {
+  return jsonSchemas[name];
+}
+// src/services/board.ts
+init_schema();
+import { eq } from "drizzle-orm";
+import { ulid } from "ulid";
+
+class BoardService {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async initializeBoard(config) {
+    const now = new Date;
+    const boardId = ulid();
+    await this.db.insert(boards).values({
+      id: boardId,
+      name: config.board.name,
+      createdAt: now,
+      updatedAt: now
+    });
+    for (let i = 0;i < config.columns.length; i++) {
+      const col = config.columns[i];
+      await this.db.insert(columns).values({
+        id: col.id,
+        boardId,
+        name: col.name,
+        position: i,
+        wipLimit: col.wipLimit ?? null,
+        isTerminal: col.isTerminal ?? false
+      });
+    }
+    return {
+      id: boardId,
+      name: config.board.name,
+      createdAt: now,
+      updatedAt: now
+    };
+  }
+  async getBoard() {
+    const rows = await this.db.select().from(boards).limit(1);
+    return rows[0] ?? null;
+  }
+  async getColumns() {
+    return this.db.select().from(columns).orderBy(columns.position);
+  }
+  async getColumn(id) {
+    const rows = await this.db.select().from(columns).where(eq(columns.id, id));
+    return rows[0] ?? null;
+  }
+  async getTerminalColumn() {
+    const rows = await this.db.select().from(columns).where(eq(columns.isTerminal, true));
+    return rows[0] ?? null;
+  }
+  async getTerminalColumns() {
+    return this.db.select().from(columns).where(eq(columns.isTerminal, true)).orderBy(columns.position);
+  }
+}
+// src/services/task.ts
+init_schema();
+init_types();
+import { and, eq as eq2, inArray, lt, sql } from "drizzle-orm";
+import { ulid as ulid2 } from "ulid";
+
+// src/utils/similarity.ts
+function tokenize(text2) {
+  const words = text2.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((word) => word.length > 0);
+  return new Set(words);
+}
+function jaccardSimilarity(text1, text2) {
+  const set1 = tokenize(text1);
+  const set2 = tokenize(text2);
+  if (set1.size === 0 || set2.size === 0) {
+    return 0;
+  }
+  const intersection = new Set([...set1].filter((word) => set2.has(word)));
+  const union = new Set([...set1, ...set2]);
+  return intersection.size / union.size;
+}
+
+// src/validation.ts
+import { ZodError } from "zod";
+init_types();
+function wrapZodError(fn, fieldName) {
+  try {
+    return fn();
+  } catch (error) {
+    if (error instanceof ZodError) {
+      const message = error.issues?.[0]?.message ?? `Invalid ${fieldName}`;
+      throw new KabanError(message, ExitCode.VALIDATION);
+    }
+    throw error;
+  }
+}
+function validateTitle(title) {
+  return wrapZodError(() => TitleSchema.parse(title), "title");
+}
+function validateAgentName(name) {
+  return wrapZodError(() => AgentNameSchema.parse(name), "agent name");
+}
+function validateColumnId(id) {
+  return wrapZodError(() => ColumnIdSchema.parse(id), "column ID");
+}
+function isValidUlid(id) {
+  return UlidSchema.safeParse(id).success;
+}
+function validateTaskId(id) {
+  return wrapZodError(() => UlidSchema.parse(id), "task ID");
+}
+
+// src/services/task.ts
+class TaskService {
+  db;
+  boardService;
+  duplicateConfig = {
+    enabled: true,
+    threshold: 0.5,
+    warnThreshold: 0.5
+  };
+  constructor(db, boardService) {
+    this.db = db;
+    this.boardService = boardService;
+  }
+  async getTaskOrThrow(id) {
+    const task = await this.getTask(id);
+    if (!task) {
+      throw new KabanError(`Task '${id}' not found`, ExitCode.NOT_FOUND);
+    }
+    return task;
+  }
+  async addTask(input) {
+    const title = validateTitle(input.title);
+    const createdBy = input.createdBy ? validateAgentName(input.createdBy) : input.agent ? validateAgentName(input.agent) : "user";
+    const columnId = input.columnId ? validateColumnId(input.columnId) : "todo";
+    const column = await this.boardService.getColumn(columnId);
+    if (!column) {
+      throw new KabanError(`Column '${columnId}' does not exist`, ExitCode.VALIDATION);
+    }
+    const now = new Date;
+    const id = ulid2();
+    const maxPositionResult = await this.db.select({ max: sql`COALESCE(MAX(position), -1)` }).from(tasks).where(eq2(tasks.columnId, columnId));
+    const position = (maxPositionResult[0]?.max ?? -1) + 1;
+    await this.db.insert(tasks).values({
+      id,
+      title,
+      description: input.description ?? null,
+      columnId,
+      position,
+      createdBy,
+      assignedTo: null,
+      parentId: null,
+      dependsOn: input.dependsOn ?? [],
+      files: input.files ?? [],
+      labels: input.labels ?? [],
+      blockedReason: null,
+      version: 1,
+      createdAt: now,
+      updatedAt: now,
+      startedAt: null,
+      completedAt: null,
+      archived: false,
+      archivedAt: null
+    });
+    return this.getTaskOrThrow(id);
+  }
+  async getTask(id) {
+    const rows = await this.db.select().from(tasks).where(eq2(tasks.id, id));
+    return rows[0] ?? null;
+  }
+  async listTasks(filter) {
+    const conditions = [];
+    if (!filter?.includeArchived) {
+      conditions.push(eq2(tasks.archived, false));
+    }
+    if (filter?.columnId) {
+      conditions.push(eq2(tasks.columnId, filter.columnId));
+    }
+    const creatorFilter = filter?.createdBy ?? filter?.agent;
+    if (creatorFilter) {
+      conditions.push(eq2(tasks.createdBy, creatorFilter));
+    }
+    if (filter?.assignee) {
+      conditions.push(eq2(tasks.assignedTo, filter.assignee));
+    }
+    if (filter?.blocked === true) {
+      conditions.push(sql`${tasks.blockedReason} IS NOT NULL`);
+    }
+    if (conditions.length > 0) {
+      return this.db.select().from(tasks).where(and(...conditions)).orderBy(tasks.columnId, tasks.position);
+    }
+    return this.db.select().from(tasks).orderBy(tasks.columnId, tasks.position);
+  }
+  async deleteTask(id) {
+    const task = await this.getTask(id);
+    if (!task) {
+      throw new KabanError(`Task '${id}' not found`, ExitCode.NOT_FOUND);
+    }
+    await this.db.delete(tasks).where(eq2(tasks.id, id));
+  }
+  async moveTask(id, columnId, options) {
+    const task = await this.getTask(id);
+    if (!task) {
+      throw new KabanError(`Task '${id}' not found`, ExitCode.NOT_FOUND);
+    }
+    validateColumnId(columnId);
+    const column = await this.boardService.getColumn(columnId);
+    if (!column) {
+      throw new KabanError(`Column '${columnId}' does not exist`, ExitCode.VALIDATION);
+    }
+    if (column.wipLimit && !options?.force) {
+      const count = await this.getTaskCountInColumn(columnId);
+      if (count >= column.wipLimit) {
+        throw new KabanError(`Column '${column.name}' at WIP limit (${count}/${column.wipLimit}). Move a task out first.`, ExitCode.VALIDATION);
+      }
+    }
+    if (column.isTerminal && options?.validateDeps) {
+      const depResult = await this.validateDependencies(id);
+      if (!depResult.valid) {
+        throw new KabanError(`Task '${id}' is blocked by incomplete dependencies: ${depResult.blockedBy.join(", ")}`, ExitCode.VALIDATION);
+      }
+    }
+    const now = new Date;
+    const isTerminal = column.isTerminal;
+    const maxPositionResult = await this.db.select({ max: sql`COALESCE(MAX(position), -1)` }).from(tasks).where(eq2(tasks.columnId, columnId));
+    const newPosition = (maxPositionResult[0]?.max ?? -1) + 1;
+    await this.db.update(tasks).set({
+      columnId,
+      position: newPosition,
+      version: task.version + 1,
+      updatedAt: now,
+      completedAt: isTerminal ? now : task.completedAt,
+      startedAt: columnId === "in_progress" && !task.startedAt ? now : task.startedAt
+    }).where(eq2(tasks.id, id));
+    return this.getTaskOrThrow(id);
+  }
+  async updateTask(id, input, expectedVersion) {
+    const task = await this.getTask(id);
+    if (!task) {
+      throw new KabanError(`Task '${id}' not found`, ExitCode.NOT_FOUND);
+    }
+    if (expectedVersion !== undefined && task.version !== expectedVersion) {
+      throw new KabanError(`Task modified by another agent, re-read required. Current version: ${task.version}`, ExitCode.CONFLICT);
+    }
+    const updates = {
+      version: task.version + 1,
+      updatedAt: new Date
+    };
+    if (input.title !== undefined) {
+      updates.title = validateTitle(input.title);
+    }
+    if (input.description !== undefined) {
+      updates.description = input.description;
+    }
+    if (input.assignedTo !== undefined) {
+      updates.assignedTo = input.assignedTo ? validateAgentName(input.assignedTo) : null;
+    }
+    if (input.files !== undefined) {
+      updates.files = input.files;
+    }
+    if (input.labels !== undefined) {
+      updates.labels = input.labels;
+    }
+    await this.db.update(tasks).set(updates).where(expectedVersion !== undefined ? and(eq2(tasks.id, id), eq2(tasks.version, expectedVersion)) : eq2(tasks.id, id));
+    return this.getTaskOrThrow(id);
+  }
+  async getTaskCountInColumn(columnId) {
+    const result = await this.db.select({ count: sql`COUNT(*)` }).from(tasks).where(eq2(tasks.columnId, columnId));
+    return result[0]?.count ?? 0;
+  }
+  async archiveTasks(criteria) {
+    const hasCriteria = criteria.status || criteria.olderThan || criteria.taskIds?.length;
+    if (!hasCriteria) {
+      throw new KabanError("At least one criteria must be provided", ExitCode.VALIDATION);
+    }
+    const conditions = [eq2(tasks.archived, false)];
+    if (criteria.status) {
+      conditions.push(eq2(tasks.columnId, criteria.status));
+    }
+    if (criteria.olderThan) {
+      conditions.push(lt(tasks.createdAt, criteria.olderThan));
+    }
+    if (criteria.taskIds?.length) {
+      conditions.push(inArray(tasks.id, criteria.taskIds));
+    }
+    const matchingTasks = await this.db.select({ id: tasks.id }).from(tasks).where(and(...conditions));
+    if (matchingTasks.length === 0) {
+      return { archivedCount: 0, taskIds: [] };
+    }
+    const taskIds = matchingTasks.map((t) => t.id);
+    const now = new Date;
+    await this.db.update(tasks).set({
+      archived: true,
+      archivedAt: now,
+      updatedAt: now
+    }).where(inArray(tasks.id, taskIds));
+    return {
+      archivedCount: taskIds.length,
+      taskIds
+    };
+  }
+  async restoreTask(taskId, targetColumnId) {
+    const task = await this.getTask(taskId);
+    if (!task) {
+      throw new KabanError(`Task '${taskId}' not found`, ExitCode.NOT_FOUND);
+    }
+    if (!task.archived) {
+      throw new KabanError(`Task '${taskId}' is not archived`, ExitCode.VALIDATION);
+    }
+    const columnId = targetColumnId ?? task.columnId;
+    if (targetColumnId) {
+      validateColumnId(targetColumnId);
+      const column = await this.boardService.getColumn(targetColumnId);
+      if (!column) {
+        throw new KabanError(`Column '${targetColumnId}' does not exist`, ExitCode.VALIDATION);
+      }
+    }
+    const now = new Date;
+    await this.db.update(tasks).set({
+      archived: false,
+      archivedAt: null,
+      columnId,
+      version: task.version + 1,
+      updatedAt: now
+    }).where(eq2(tasks.id, taskId));
+    return this.getTaskOrThrow(taskId);
+  }
+  async searchArchive(query, options) {
+    const limit = options?.limit ?? 50;
+    const offset = options?.offset ?? 0;
+    if (!query.trim()) {
+      const countResult = await this.db.select({ count: sql`COUNT(*)` }).from(tasks).where(eq2(tasks.archived, true));
+      const total2 = countResult[0]?.count ?? 0;
+      const archivedTasks = await this.db.select().from(tasks).where(eq2(tasks.archived, true)).orderBy(tasks.archivedAt).limit(limit).offset(offset);
+      return { tasks: archivedTasks, total: total2 };
+    }
+    const ftsQuery = query.trim().split(/\s+/).map((term) => `"${term}"`).join(" ");
+    const client = this.db.$client;
+    const countRow = client.prepare(`SELECT COUNT(*) as count FROM tasks t
+         JOIN tasks_fts fts ON t.id = fts.id
+         WHERE tasks_fts MATCH ?
+         AND t.archived = 1`).get(ftsQuery);
+    const total = countRow?.count ?? 0;
+    const rows = client.prepare(`SELECT t.* FROM tasks t
+         JOIN tasks_fts fts ON t.id = fts.id
+         WHERE tasks_fts MATCH ?
+         AND t.archived = 1
+         ORDER BY rank
+         LIMIT ? OFFSET ?`).all(ftsQuery, limit, offset);
+    const searchTasks = rows.map((row) => ({
+      id: row.id,
+      title: row.title,
+      description: row.description,
+      columnId: row.column_id,
+      position: row.position,
+      createdBy: row.created_by,
+      assignedTo: row.assigned_to,
+      parentId: row.parent_id,
+      dependsOn: JSON.parse(row.depends_on || "[]"),
+      files: JSON.parse(row.files || "[]"),
+      labels: JSON.parse(row.labels || "[]"),
+      blockedReason: row.blocked_reason,
+      version: row.version,
+      createdAt: new Date(row.created_at),
+      updatedAt: new Date(row.updated_at),
+      startedAt: row.started_at ? new Date(row.started_at) : null,
+      completedAt: row.completed_at ? new Date(row.completed_at) : null,
+      archived: Boolean(row.archived),
+      archivedAt: row.archived_at ? new Date(row.archived_at) : null
+    }));
+    return { tasks: searchTasks, total };
+  }
+  async purgeArchive(criteria) {
+    const conditions = [eq2(tasks.archived, true)];
+    if (criteria?.olderThan) {
+      conditions.push(lt(tasks.archivedAt, criteria.olderThan));
+    }
+    const matchingTasks = await this.db.select({ id: tasks.id }).from(tasks).where(and(...conditions));
+    if (matchingTasks.length === 0) {
+      return { deletedCount: 0 };
+    }
+    const taskIds = matchingTasks.map((t) => t.id);
+    await this.db.delete(tasks).where(inArray(tasks.id, taskIds));
+    return { deletedCount: taskIds.length };
+  }
+  async resetBoard() {
+    const allTasks = await this.db.select({ id: tasks.id }).from(tasks);
+    if (allTasks.length === 0) {
+      return { deletedCount: 0 };
+    }
+    await this.db.delete(tasks).where(sql`1=1`);
+    return { deletedCount: allTasks.length };
+  }
+  async addDependency(taskId, dependsOnId) {
+    if (taskId === dependsOnId) {
+      throw new KabanError("Task cannot depend on itself", ExitCode.VALIDATION);
+    }
+    const task = await this.getTaskOrThrow(taskId);
+    await this.getTaskOrThrow(dependsOnId);
+    if (task.dependsOn.includes(dependsOnId)) {
+      return task;
+    }
+    const updatedDependsOn = [...task.dependsOn, dependsOnId];
+    const now = new Date;
+    await this.db.update(tasks).set({
+      dependsOn: updatedDependsOn,
+      version: task.version + 1,
+      updatedAt: now
+    }).where(eq2(tasks.id, taskId));
+    return this.getTaskOrThrow(taskId);
+  }
+  async removeDependency(taskId, dependsOnId) {
+    const task = await this.getTaskOrThrow(taskId);
+    if (!task.dependsOn.includes(dependsOnId)) {
+      return task;
+    }
+    const updatedDependsOn = task.dependsOn.filter((id) => id !== dependsOnId);
+    const now = new Date;
+    await this.db.update(tasks).set({
+      dependsOn: updatedDependsOn,
+      version: task.version + 1,
+      updatedAt: now
+    }).where(eq2(tasks.id, taskId));
+    return this.getTaskOrThrow(taskId);
+  }
+  async validateDependencies(taskId) {
+    const task = await this.getTask(taskId);
+    if (!task) {
+      throw new KabanError(`Task '${taskId}' not found`, ExitCode.NOT_FOUND);
+    }
+    if (!task.dependsOn || task.dependsOn.length === 0) {
+      return { valid: true, blockedBy: [] };
+    }
+    const terminalColumn = await this.boardService.getTerminalColumn();
+    if (!terminalColumn) {
+      return { valid: true, blockedBy: [] };
+    }
+    const blockedBy = [];
+    for (const depId of task.dependsOn) {
+      const depTask = await this.getTask(depId);
+      if (depTask && depTask.columnId !== terminalColumn.id) {
+        blockedBy.push(depId);
+      }
+    }
+    return {
+      valid: blockedBy.length === 0,
+      blockedBy
+    };
+  }
+  async findSimilarTasks(title, threshold = 0.5) {
+    const activeTasks = await this.listTasks({ includeArchived: false });
+    return activeTasks.map((task) => ({
+      task,
+      similarity: jaccardSimilarity(title, task.title)
+    })).filter((result) => result.similarity >= threshold).sort((a, b) => b.similarity - a.similarity).slice(0, 5);
+  }
+  async addTaskChecked(input, options) {
+    const similarTasks = await this.findSimilarTasks(input.title, this.duplicateConfig.threshold);
+    const highSimilarity = similarTasks.filter((s) => s.similarity >= this.duplicateConfig.warnThreshold);
+    if (highSimilarity.length > 0 && !options?.force) {
+      const similar = highSimilarity.map((s) => `"${s.task.title}" (${Math.round(s.similarity * 100)}%)`).join(", ");
+      return {
+        task: null,
+        created: false,
+        similarTasks,
+        rejected: true,
+        rejectionReason: `Found ${highSimilarity.length} very similar task(s): ${similar}. Use force=true to create anyway.`
+      };
+    }
+    const task = await this.addTask(input);
+    return {
+      task,
+      created: true,
+      similarTasks,
+      rejected: false
+    };
+  }
+  async getArchiveStats() {
+    const archived = await this.db.select().from(tasks).where(eq2(tasks.archived, true));
+    const byColumn = {};
+    let oldestArchivedAt = null;
+    for (const task of archived) {
+      byColumn[task.columnId] = (byColumn[task.columnId] ?? 0) + 1;
+      if (task.archivedAt && (!oldestArchivedAt || task.archivedAt < oldestArchivedAt)) {
+        oldestArchivedAt = task.archivedAt;
+      }
+    }
+    return {
+      totalArchived: archived.length,
+      byColumn,
+      oldestArchivedAt
+    };
+  }
+}
+
+// src/index-bun.ts
+init_types();
+export {
+  validateTitle,
+  validateTaskId,
+  validateColumnId,
+  validateAgentName,
+  undoLog,
+  tokenize,
+  tasks,
+  runMigrations,
+  jsonSchemas,
+  jaccardSimilarity,
+  isValidUlid,
+  initializeSchema,
+  getJsonSchema,
+  createDb,
+  columns,
+  boards,
+  UpdateTaskInputSchema,
+  UlidSchema,
+  TitleSchema,
+  TaskService,
+  TaskSchema,
+  TaskResponseSchema,
+  MoveTaskInputSchema,
+  ListTasksFilterSchema,
+  KabanError,
+  GetTaskInputSchema,
+  ExitCode,
+  DeleteTaskInputSchema,
+  DEFAULT_CONFIG,
+  ConfigSchema,
+  ColumnSchema,
+  ColumnIdSchema,
+  ColumnConfigSchema,
+  BoardStatusSchema,
+  BoardService,
+  BoardSchema,
+  ApiResponseSchema,
+  AgentNameSchema,
+  AddTaskInputSchema
+};