@hasna/todos 0.1.0

package/dist/index.js

@@ -0,0 +1,711 @@
+// @bun
+// src/db/database.ts
+import { Database } from "bun:sqlite";
+import { existsSync, mkdirSync } from "fs";
+import { dirname, join, resolve } from "path";
+var LOCK_EXPIRY_MINUTES = 30;
+function getDbPath() {
+  if (process.env["TODOS_DB_PATH"]) {
+    return process.env["TODOS_DB_PATH"];
+  }
+  const cwd = process.cwd();
+  const localDb = join(cwd, ".todos", "todos.db");
+  if (existsSync(localDb)) {
+    return localDb;
+  }
+  const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
+  return join(home, ".todos", "todos.db");
+}
+function ensureDir(filePath) {
+  const dir = dirname(resolve(filePath));
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+var MIGRATIONS = [
+  `
+  CREATE TABLE IF NOT EXISTS projects (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    path TEXT UNIQUE NOT NULL,
+    description TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS tasks (
+    id TEXT PRIMARY KEY,
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    parent_id TEXT REFERENCES tasks(id) ON DELETE CASCADE,
+    title TEXT NOT NULL,
+    description TEXT,
+    status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending', 'in_progress', 'completed', 'failed', 'cancelled')),
+    priority TEXT NOT NULL DEFAULT 'medium' CHECK(priority IN ('low', 'medium', 'high', 'critical')),
+    agent_id TEXT,
+    assigned_to TEXT,
+    session_id TEXT,
+    working_dir TEXT,
+    tags TEXT DEFAULT '[]',
+    metadata TEXT DEFAULT '{}',
+    version INTEGER NOT NULL DEFAULT 1,
+    locked_by TEXT,
+    locked_at TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+    completed_at TEXT
+  );
+
+  CREATE TABLE IF NOT EXISTS task_dependencies (
+    task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    depends_on TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    PRIMARY KEY (task_id, depends_on),
+    CHECK (task_id != depends_on)
+  );
+
+  CREATE TABLE IF NOT EXISTS task_comments (
+    id TEXT PRIMARY KEY,
+    task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    agent_id TEXT,
+    session_id TEXT,
+    content TEXT NOT NULL,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS sessions (
+    id TEXT PRIMARY KEY,
+    agent_id TEXT,
+    project_id TEXT REFERENCES projects(id) ON DELETE SET NULL,
+    working_dir TEXT,
+    started_at TEXT NOT NULL DEFAULT (datetime('now')),
+    last_activity TEXT NOT NULL DEFAULT (datetime('now')),
+    metadata TEXT DEFAULT '{}'
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_tasks_project ON tasks(project_id);
+  CREATE INDEX IF NOT EXISTS idx_tasks_parent ON tasks(parent_id);
+  CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+  CREATE INDEX IF NOT EXISTS idx_tasks_priority ON tasks(priority);
+  CREATE INDEX IF NOT EXISTS idx_tasks_assigned ON tasks(assigned_to);
+  CREATE INDEX IF NOT EXISTS idx_tasks_agent ON tasks(agent_id);
+  CREATE INDEX IF NOT EXISTS idx_tasks_session ON tasks(session_id);
+  CREATE INDEX IF NOT EXISTS idx_comments_task ON task_comments(task_id);
+  CREATE INDEX IF NOT EXISTS idx_sessions_agent ON sessions(agent_id);
+  CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_id);
+
+  CREATE TABLE IF NOT EXISTS _migrations (
+    id INTEGER PRIMARY KEY,
+    applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  INSERT OR IGNORE INTO _migrations (id) VALUES (1);
+  `
+];
+var _db = null;
+function getDatabase(dbPath) {
+  if (_db)
+    return _db;
+  const path = dbPath || getDbPath();
+  ensureDir(path);
+  _db = new Database(path, { create: true });
+  _db.run("PRAGMA journal_mode = WAL");
+  _db.run("PRAGMA busy_timeout = 5000");
+  _db.run("PRAGMA foreign_keys = ON");
+  runMigrations(_db);
+  return _db;
+}
+function runMigrations(db) {
+  try {
+    const result = db.query("SELECT MAX(id) as max_id FROM _migrations").get();
+    const currentLevel = result?.max_id ?? 0;
+    for (let i = currentLevel;i < MIGRATIONS.length; i++) {
+      db.run(MIGRATIONS[i]);
+    }
+  } catch {
+    for (const migration of MIGRATIONS) {
+      db.exec(migration);
+    }
+  }
+}
+function closeDatabase() {
+  if (_db) {
+    _db.close();
+    _db = null;
+  }
+}
+function resetDatabase() {
+  _db = null;
+}
+function now() {
+  return new Date().toISOString();
+}
+function uuid() {
+  return crypto.randomUUID();
+}
+function isLockExpired(lockedAt) {
+  if (!lockedAt)
+    return true;
+  const lockTime = new Date(lockedAt).getTime();
+  const expiryMs = LOCK_EXPIRY_MINUTES * 60 * 1000;
+  return Date.now() - lockTime > expiryMs;
+}
+function resolvePartialId(db, table, partialId) {
+  if (partialId.length >= 36) {
+    const row = db.query(`SELECT id FROM ${table} WHERE id = ?`).get(partialId);
+    return row?.id ?? null;
+  }
+  const rows = db.query(`SELECT id FROM ${table} WHERE id LIKE ?`).all(`${partialId}%`);
+  if (rows.length === 1) {
+    return rows[0].id;
+  }
+  if (rows.length > 1) {
+    return null;
+  }
+  return null;
+}
+// src/types/index.ts
+var TASK_STATUSES = [
+  "pending",
+  "in_progress",
+  "completed",
+  "failed",
+  "cancelled"
+];
+var TASK_PRIORITIES = [
+  "low",
+  "medium",
+  "high",
+  "critical"
+];
+
+class VersionConflictError extends Error {
+  taskId;
+  expectedVersion;
+  actualVersion;
+  constructor(taskId, expectedVersion, actualVersion) {
+    super(`Version conflict for task ${taskId}: expected ${expectedVersion}, got ${actualVersion}`);
+    this.taskId = taskId;
+    this.expectedVersion = expectedVersion;
+    this.actualVersion = actualVersion;
+    this.name = "VersionConflictError";
+  }
+}
+
+class TaskNotFoundError extends Error {
+  taskId;
+  constructor(taskId) {
+    super(`Task not found: ${taskId}`);
+    this.taskId = taskId;
+    this.name = "TaskNotFoundError";
+  }
+}
+
+class ProjectNotFoundError extends Error {
+  projectId;
+  constructor(projectId) {
+    super(`Project not found: ${projectId}`);
+    this.projectId = projectId;
+    this.name = "ProjectNotFoundError";
+  }
+}
+
+class LockError extends Error {
+  taskId;
+  lockedBy;
+  constructor(taskId, lockedBy) {
+    super(`Task ${taskId} is locked by ${lockedBy}`);
+    this.taskId = taskId;
+    this.lockedBy = lockedBy;
+    this.name = "LockError";
+  }
+}
+
+class DependencyCycleError extends Error {
+  taskId;
+  dependsOn;
+  constructor(taskId, dependsOn) {
+    super(`Adding dependency ${taskId} -> ${dependsOn} would create a cycle`);
+    this.taskId = taskId;
+    this.dependsOn = dependsOn;
+    this.name = "DependencyCycleError";
+  }
+}
+
+// src/db/tasks.ts
+function rowToTask(row) {
+  return {
+    ...row,
+    tags: JSON.parse(row.tags || "[]"),
+    metadata: JSON.parse(row.metadata || "{}"),
+    status: row.status,
+    priority: row.priority
+  };
+}
+function createTask(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  d.run(`INSERT INTO tasks (id, project_id, parent_id, title, description, status, priority, agent_id, assigned_to, session_id, working_dir, tags, metadata, version, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)`, [
+    id,
+    input.project_id || null,
+    input.parent_id || null,
+    input.title,
+    input.description || null,
+    input.status || "pending",
+    input.priority || "medium",
+    input.agent_id || null,
+    input.assigned_to || null,
+    input.session_id || null,
+    input.working_dir || null,
+    JSON.stringify(input.tags || []),
+    JSON.stringify(input.metadata || {}),
+    timestamp,
+    timestamp
+  ]);
+  return getTask(id, d);
+}
+function getTask(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM tasks WHERE id = ?").get(id);
+  if (!row)
+    return null;
+  return rowToTask(row);
+}
+function getTaskWithRelations(id, db) {
+  const d = db || getDatabase();
+  const task = getTask(id, d);
+  if (!task)
+    return null;
+  const subtaskRows = d.query("SELECT * FROM tasks WHERE parent_id = ? ORDER BY created_at").all(id);
+  const subtasks = subtaskRows.map(rowToTask);
+  const depRows = d.query(`SELECT t.* FROM tasks t
+       JOIN task_dependencies td ON td.depends_on = t.id
+       WHERE td.task_id = ?`).all(id);
+  const dependencies = depRows.map(rowToTask);
+  const blockedByRows = d.query(`SELECT t.* FROM tasks t
+       JOIN task_dependencies td ON td.task_id = t.id
+       WHERE td.depends_on = ?`).all(id);
+  const blocked_by = blockedByRows.map(rowToTask);
+  const comments = d.query("SELECT * FROM task_comments WHERE task_id = ? ORDER BY created_at").all(id);
+  const parent = task.parent_id ? getTask(task.parent_id, d) : null;
+  return {
+    ...task,
+    subtasks,
+    dependencies,
+    blocked_by,
+    comments,
+    parent
+  };
+}
+function listTasks(filter = {}, db) {
+  const d = db || getDatabase();
+  const conditions = [];
+  const params = [];
+  if (filter.project_id) {
+    conditions.push("project_id = ?");
+    params.push(filter.project_id);
+  }
+  if (filter.parent_id !== undefined) {
+    if (filter.parent_id === null) {
+      conditions.push("parent_id IS NULL");
+    } else {
+      conditions.push("parent_id = ?");
+      params.push(filter.parent_id);
+    }
+  }
+  if (filter.status) {
+    if (Array.isArray(filter.status)) {
+      conditions.push(`status IN (${filter.status.map(() => "?").join(",")})`);
+      params.push(...filter.status);
+    } else {
+      conditions.push("status = ?");
+      params.push(filter.status);
+    }
+  }
+  if (filter.priority) {
+    if (Array.isArray(filter.priority)) {
+      conditions.push(`priority IN (${filter.priority.map(() => "?").join(",")})`);
+      params.push(...filter.priority);
+    } else {
+      conditions.push("priority = ?");
+      params.push(filter.priority);
+    }
+  }
+  if (filter.assigned_to) {
+    conditions.push("assigned_to = ?");
+    params.push(filter.assigned_to);
+  }
+  if (filter.agent_id) {
+    conditions.push("agent_id = ?");
+    params.push(filter.agent_id);
+  }
+  if (filter.session_id) {
+    conditions.push("session_id = ?");
+    params.push(filter.session_id);
+  }
+  if (filter.tags && filter.tags.length > 0) {
+    const tagConditions = filter.tags.map(() => "tags LIKE ?");
+    conditions.push(`(${tagConditions.join(" OR ")})`);
+    params.push(...filter.tags.map((t) => `%"${t}"%`));
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const rows = d.query(`SELECT * FROM tasks ${where} ORDER BY
+       CASE priority WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 END,
+       created_at DESC`).all(...params);
+  return rows.map(rowToTask);
+}
+function updateTask(id, input, db) {
+  const d = db || getDatabase();
+  const task = getTask(id, d);
+  if (!task)
+    throw new TaskNotFoundError(id);
+  if (task.version !== input.version) {
+    throw new VersionConflictError(id, input.version, task.version);
+  }
+  const sets = ["version = version + 1", "updated_at = ?"];
+  const params = [now()];
+  if (input.title !== undefined) {
+    sets.push("title = ?");
+    params.push(input.title);
+  }
+  if (input.description !== undefined) {
+    sets.push("description = ?");
+    params.push(input.description);
+  }
+  if (input.status !== undefined) {
+    sets.push("status = ?");
+    params.push(input.status);
+    if (input.status === "completed") {
+      sets.push("completed_at = ?");
+      params.push(now());
+    }
+  }
+  if (input.priority !== undefined) {
+    sets.push("priority = ?");
+    params.push(input.priority);
+  }
+  if (input.assigned_to !== undefined) {
+    sets.push("assigned_to = ?");
+    params.push(input.assigned_to);
+  }
+  if (input.tags !== undefined) {
+    sets.push("tags = ?");
+    params.push(JSON.stringify(input.tags));
+  }
+  if (input.metadata !== undefined) {
+    sets.push("metadata = ?");
+    params.push(JSON.stringify(input.metadata));
+  }
+  params.push(id, input.version);
+  const result = d.run(`UPDATE tasks SET ${sets.join(", ")} WHERE id = ? AND version = ?`, params);
+  if (result.changes === 0) {
+    const current = getTask(id, d);
+    throw new VersionConflictError(id, input.version, current?.version ?? -1);
+  }
+  return getTask(id, d);
+}
+function deleteTask(id, db) {
+  const d = db || getDatabase();
+  const result = d.run("DELETE FROM tasks WHERE id = ?", [id]);
+  return result.changes > 0;
+}
+function startTask(id, agentId, db) {
+  const d = db || getDatabase();
+  const task = getTask(id, d);
+  if (!task)
+    throw new TaskNotFoundError(id);
+  if (task.locked_by && task.locked_by !== agentId && !isLockExpired(task.locked_at)) {
+    throw new LockError(id, task.locked_by);
+  }
+  const timestamp = now();
+  d.run(`UPDATE tasks SET status = 'in_progress', assigned_to = ?, locked_by = ?, locked_at = ?, version = version + 1, updated_at = ?
+     WHERE id = ?`, [agentId, agentId, timestamp, timestamp, id]);
+  return getTask(id, d);
+}
+function completeTask(id, agentId, db) {
+  const d = db || getDatabase();
+  const task = getTask(id, d);
+  if (!task)
+    throw new TaskNotFoundError(id);
+  if (agentId && task.locked_by && task.locked_by !== agentId && !isLockExpired(task.locked_at)) {
+    throw new LockError(id, task.locked_by);
+  }
+  const timestamp = now();
+  d.run(`UPDATE tasks SET status = 'completed', locked_by = NULL, locked_at = NULL, completed_at = ?, version = version + 1, updated_at = ?
+     WHERE id = ?`, [timestamp, timestamp, id]);
+  return getTask(id, d);
+}
+function lockTask(id, agentId, db) {
+  const d = db || getDatabase();
+  const task = getTask(id, d);
+  if (!task)
+    throw new TaskNotFoundError(id);
+  if (task.locked_by === agentId) {
+    return { success: true, locked_by: agentId, locked_at: task.locked_at };
+  }
+  if (task.locked_by && !isLockExpired(task.locked_at)) {
+    return {
+      success: false,
+      locked_by: task.locked_by,
+      locked_at: task.locked_at,
+      error: `Task is locked by ${task.locked_by}`
+    };
+  }
+  const timestamp = now();
+  d.run(`UPDATE tasks SET locked_by = ?, locked_at = ?, version = version + 1, updated_at = ?
+     WHERE id = ?`, [agentId, timestamp, timestamp, id]);
+  return { success: true, locked_by: agentId, locked_at: timestamp };
+}
+function unlockTask(id, agentId, db) {
+  const d = db || getDatabase();
+  const task = getTask(id, d);
+  if (!task)
+    throw new TaskNotFoundError(id);
+  if (agentId && task.locked_by && task.locked_by !== agentId) {
+    throw new LockError(id, task.locked_by);
+  }
+  const timestamp = now();
+  d.run(`UPDATE tasks SET locked_by = NULL, locked_at = NULL, version = version + 1, updated_at = ?
+     WHERE id = ?`, [timestamp, id]);
+  return true;
+}
+function addDependency(taskId, dependsOn, db) {
+  const d = db || getDatabase();
+  if (!getTask(taskId, d))
+    throw new TaskNotFoundError(taskId);
+  if (!getTask(dependsOn, d))
+    throw new TaskNotFoundError(dependsOn);
+  if (wouldCreateCycle(taskId, dependsOn, d)) {
+    throw new DependencyCycleError(taskId, dependsOn);
+  }
+  d.run("INSERT OR IGNORE INTO task_dependencies (task_id, depends_on) VALUES (?, ?)", [taskId, dependsOn]);
+}
+function removeDependency(taskId, dependsOn, db) {
+  const d = db || getDatabase();
+  const result = d.run("DELETE FROM task_dependencies WHERE task_id = ? AND depends_on = ?", [taskId, dependsOn]);
+  return result.changes > 0;
+}
+function getTaskDependencies(taskId, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM task_dependencies WHERE task_id = ?").all(taskId);
+}
+function getTaskDependents(taskId, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM task_dependencies WHERE depends_on = ?").all(taskId);
+}
+function wouldCreateCycle(taskId, dependsOn, db) {
+  const visited = new Set;
+  const queue = [dependsOn];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (current === taskId)
+      return true;
+    if (visited.has(current))
+      continue;
+    visited.add(current);
+    const deps = db.query("SELECT depends_on FROM task_dependencies WHERE task_id = ?").all(current);
+    for (const dep of deps) {
+      queue.push(dep.depends_on);
+    }
+  }
+  return false;
+}
+// src/db/projects.ts
+function createProject(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  d.run(`INSERT INTO projects (id, name, path, description, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?)`, [id, input.name, input.path, input.description || null, timestamp, timestamp]);
+  return getProject(id, d);
+}
+function getProject(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM projects WHERE id = ?").get(id);
+  return row;
+}
+function getProjectByPath(path, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM projects WHERE path = ?").get(path);
+  return row;
+}
+function listProjects(db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM projects ORDER BY name").all();
+}
+function updateProject(id, input, db) {
+  const d = db || getDatabase();
+  const project = getProject(id, d);
+  if (!project)
+    throw new ProjectNotFoundError(id);
+  const sets = ["updated_at = ?"];
+  const params = [now()];
+  if (input.name !== undefined) {
+    sets.push("name = ?");
+    params.push(input.name);
+  }
+  if (input.description !== undefined) {
+    sets.push("description = ?");
+    params.push(input.description);
+  }
+  params.push(id);
+  d.run(`UPDATE projects SET ${sets.join(", ")} WHERE id = ?`, params);
+  return getProject(id, d);
+}
+function deleteProject(id, db) {
+  const d = db || getDatabase();
+  const result = d.run("DELETE FROM projects WHERE id = ?", [id]);
+  return result.changes > 0;
+}
+function ensureProject(name, path, db) {
+  const d = db || getDatabase();
+  const existing = getProjectByPath(path, d);
+  if (existing)
+    return existing;
+  return createProject({ name, path }, d);
+}
+// src/db/comments.ts
+function addComment(input, db) {
+  const d = db || getDatabase();
+  if (!getTask(input.task_id, d)) {
+    throw new TaskNotFoundError(input.task_id);
+  }
+  const id = uuid();
+  const timestamp = now();
+  d.run(`INSERT INTO task_comments (id, task_id, agent_id, session_id, content, created_at)
+     VALUES (?, ?, ?, ?, ?, ?)`, [
+    id,
+    input.task_id,
+    input.agent_id || null,
+    input.session_id || null,
+    input.content,
+    timestamp
+  ]);
+  return getComment(id, d);
+}
+function getComment(id, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM task_comments WHERE id = ?").get(id);
+}
+function listComments(taskId, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM task_comments WHERE task_id = ? ORDER BY created_at").all(taskId);
+}
+function deleteComment(id, db) {
+  const d = db || getDatabase();
+  const result = d.run("DELETE FROM task_comments WHERE id = ?", [id]);
+  return result.changes > 0;
+}
+// src/db/sessions.ts
+function rowToSession(row) {
+  return {
+    ...row,
+    metadata: JSON.parse(row.metadata || "{}")
+  };
+}
+function createSession(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  d.run(`INSERT INTO sessions (id, agent_id, project_id, working_dir, started_at, last_activity, metadata)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    input.agent_id || null,
+    input.project_id || null,
+    input.working_dir || null,
+    timestamp,
+    timestamp,
+    JSON.stringify(input.metadata || {})
+  ]);
+  return getSession(id, d);
+}
+function getSession(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM sessions WHERE id = ?").get(id);
+  if (!row)
+    return null;
+  return rowToSession(row);
+}
+function listSessions(db) {
+  const d = db || getDatabase();
+  const rows = d.query("SELECT * FROM sessions ORDER BY last_activity DESC").all();
+  return rows.map(rowToSession);
+}
+function updateSessionActivity(id, db) {
+  const d = db || getDatabase();
+  d.run("UPDATE sessions SET last_activity = ? WHERE id = ?", [now(), id]);
+}
+function deleteSession(id, db) {
+  const d = db || getDatabase();
+  const result = d.run("DELETE FROM sessions WHERE id = ?", [id]);
+  return result.changes > 0;
+}
+// src/lib/search.ts
+function rowToTask2(row) {
+  return {
+    ...row,
+    tags: JSON.parse(row.tags || "[]"),
+    metadata: JSON.parse(row.metadata || "{}"),
+    status: row.status,
+    priority: row.priority
+  };
+}
+function searchTasks(query, projectId, db) {
+  const d = db || getDatabase();
+  const pattern = `%${query}%`;
+  let sql = `SELECT * FROM tasks WHERE (title LIKE ? OR description LIKE ? OR tags LIKE ?)`;
+  const params = [pattern, pattern, pattern];
+  if (projectId) {
+    sql += " AND project_id = ?";
+    params.push(projectId);
+  }
+  sql += ` ORDER BY
+    CASE priority WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 END,
+    created_at DESC`;
+  const rows = d.query(sql).all(...params);
+  return rows.map(rowToTask2);
+}
+export {
+  updateTask,
+  updateSessionActivity,
+  updateProject,
+  unlockTask,
+  startTask,
+  searchTasks,
+  resolvePartialId,
+  resetDatabase,
+  removeDependency,
+  lockTask,
+  listTasks,
+  listSessions,
+  listProjects,
+  listComments,
+  getTaskWithRelations,
+  getTaskDependents,
+  getTaskDependencies,
+  getTask,
+  getSession,
+  getProjectByPath,
+  getProject,
+  getDatabase,
+  getComment,
+  ensureProject,
+  deleteTask,
+  deleteSession,
+  deleteProject,
+  deleteComment,
+  createTask,
+  createSession,
+  createProject,
+  completeTask,
+  closeDatabase,
+  addDependency,
+  addComment,
+  VersionConflictError,
+  TaskNotFoundError,
+  TASK_STATUSES,
+  TASK_PRIORITIES,
+  ProjectNotFoundError,
+  LockError,
+  DependencyCycleError
+};