trekoon 0.3.3 → 0.3.4

package/src/domain/tracker-domain.ts

@@ -39,6 +39,7 @@ import {
 
 const DEFAULT_STATUS = "todo";
 const DEPENDENCY_GATED_STATUSES = new Set<string>(["in_progress", "done"]);
+const SQLITE_MAX_VARIABLES = 999;
 
 interface EpicRow {
   id: string;
@@ -391,20 +392,69 @@ export class TrackerDomain {
       status: normalizeStatus(spec.status),
     }));
 
-    const tasks: TaskRecord[] = [];
-    for (const spec of validatedSpecs) {
-      const now: number = Date.now();
-      const id: string = randomUUID();
+    if (validatedSpecs.length === 0) {
+      return {
+        tasks: [],
+        result: {
+          mappings: [],
+        },
+      };
+    }
+
+    if (!this.#db.inTransaction) {
+      throw new DomainError({
+        code: "invalid_state",
+        message: "createTaskBatch must be called inside a writeTransaction",
+        details: { entity: "task" },
+      });
+    }
+
+    const TASK_COLS_PER_ROW = 7; // id, epic_id, title, description, status, created_at, updated_at (version is literal 1)
+    const WRITE_CHUNK_SIZE: number = Math.floor(SQLITE_MAX_VARIABLES / TASK_COLS_PER_ROW);
+    const batchTimestamp: number = Date.now();
 
+    const prepared: Array<{ id: string; now: number; spec: ValidatedTaskBatchSpec }> = validatedSpecs.map((spec) => ({
+      id: randomUUID(),
+      now: batchTimestamp,
+      spec,
+    }));
+
+    for (let offset = 0; offset < prepared.length; offset += WRITE_CHUNK_SIZE) {
+      const chunk = prepared.slice(offset, offset + WRITE_CHUNK_SIZE);
+      const placeholders: string = chunk.map(() => "(?, ?, ?, ?, ?, ?, ?, 1)").join(", ");
+      const params: Array<string | number> = [];
+      for (const item of chunk) {
+        params.push(item.id, epicId, item.spec.title, item.spec.description, item.spec.status, item.now, item.now);
+      }
       this.#db
         .query(
-          "INSERT INTO tasks (id, epic_id, title, description, status, created_at, updated_at, version) VALUES (?, ?, ?, ?, ?, ?, ?, 1);",
+          `INSERT INTO tasks (id, epic_id, title, description, status, created_at, updated_at, version) VALUES ${placeholders};`,
         )
-        .run(id, epicId, spec.title, spec.description, spec.status, now, now);
+        .run(...params);
+    }
 
-      tasks.push(this.getTaskOrThrow(id));
+    const allIds: string[] = prepared.map((p) => p.id);
+    const fetchedRows: TaskRow[] = [];
+    for (let offset = 0; offset < allIds.length; offset += SQLITE_MAX_VARIABLES) {
+      const chunkIds = allIds.slice(offset, offset + SQLITE_MAX_VARIABLES);
+      const inPlaceholders: string = chunkIds.map(() => "?").join(", ");
+      const chunkRows = this.#db
+        .query(
+          `SELECT id, epic_id, title, description, status, owner, created_at, updated_at FROM tasks WHERE id IN (${inPlaceholders});`,
+        )
+        .all(...chunkIds) as TaskRow[];
+      fetchedRows.push(...chunkRows);
     }
 
+    const rowById = new Map<string, TaskRow>(fetchedRows.map((row) => [row.id, row]));
+    const tasks: TaskRecord[] = allIds.map((id) => {
+      const row = rowById.get(id);
+      if (!row) {
+        throw new DomainError({ code: "not_found", message: `task not found: ${id}`, details: { entity: "task", id } });
+      }
+      return mapTask(row);
+    });
+
     return {
       tasks,
       result: {
@@ -504,9 +554,13 @@ export class TrackerDomain {
     const defaultTaskId: string = assertNonEmpty("taskId", input.taskId);
     this.getTaskOrThrow(defaultTaskId);
 
+    const validatedTaskIds = new Set<string>([defaultTaskId]);
     const validatedSpecs: ValidatedSubtaskBatchSpec[] = input.specs.map((spec) => {
       const taskId = spec.parent.kind === "id" ? assertNonEmpty("taskId", spec.parent.id) : defaultTaskId;
-      this.getTaskOrThrow(taskId);
+      if (!validatedTaskIds.has(taskId)) {
+        this.getTaskOrThrow(taskId);
+        validatedTaskIds.add(taskId);
+      }
 
       return {
         tempKey: assertNonEmpty("tempKey", spec.tempKey),
@@ -517,20 +571,73 @@ export class TrackerDomain {
       };
     });
 
-    const subtasks: SubtaskRecord[] = [];
-    for (const spec of validatedSpecs) {
-      const now: number = Date.now();
-      const id: string = randomUUID();
+    if (validatedSpecs.length === 0) {
+      return {
+        subtasks: [],
+        result: {
+          mappings: [],
+        },
+      };
+    }
+
+    if (!this.#db.inTransaction) {
+      throw new DomainError({
+        code: "invalid_state",
+        message: "createSubtaskBatch must be called inside a writeTransaction",
+        details: { entity: "subtask" },
+      });
+    }
+
+    const SUBTASK_COLS_PER_ROW = 7; // id, task_id, title, description, status, created_at, updated_at (version is literal 1)
+    const WRITE_CHUNK_SIZE: number = Math.floor(SQLITE_MAX_VARIABLES / SUBTASK_COLS_PER_ROW);
+    const batchTimestamp: number = Date.now();
+
+    const prepared: Array<{ id: string; now: number; spec: ValidatedSubtaskBatchSpec }> = validatedSpecs.map((spec) => ({
+      id: randomUUID(),
+      now: batchTimestamp,
+      spec,
+    }));
 
+    for (let offset = 0; offset < prepared.length; offset += WRITE_CHUNK_SIZE) {
+      const chunk = prepared.slice(offset, offset + WRITE_CHUNK_SIZE);
+      const placeholders: string = chunk.map(() => "(?, ?, ?, ?, ?, ?, ?, 1)").join(", ");
+      const params: Array<string | number> = [];
+      for (const item of chunk) {
+        params.push(item.id, item.spec.taskId, item.spec.title, item.spec.description, item.spec.status, item.now, item.now);
+      }
       this.#db
         .query(
-          "INSERT INTO subtasks (id, task_id, title, description, status, created_at, updated_at, version) VALUES (?, ?, ?, ?, ?, ?, ?, 1);",
+          `INSERT INTO subtasks (id, task_id, title, description, status, created_at, updated_at, version) VALUES ${placeholders};`,
         )
-        .run(id, spec.taskId, spec.title, spec.description, spec.status, now, now);
+        .run(...params);
+    }
 
-      subtasks.push(this.getSubtaskOrThrow(id));
+    const allIds: string[] = prepared.map((p) => p.id);
+    const fetchedRows: SubtaskRow[] = [];
+    for (let offset = 0; offset < allIds.length; offset += SQLITE_MAX_VARIABLES) {
+      const chunkIds = allIds.slice(offset, offset + SQLITE_MAX_VARIABLES);
+      const inPlaceholders: string = chunkIds.map(() => "?").join(", ");
+      const chunkRows = this.#db
+        .query(
+          `SELECT id, task_id, title, description, status, owner, created_at, updated_at FROM subtasks WHERE id IN (${inPlaceholders});`,
+        )
+        .all(...chunkIds) as SubtaskRow[];
+      fetchedRows.push(...chunkRows);
     }
 
+    const rowById = new Map<string, SubtaskRow>(fetchedRows.map((row) => [row.id, row]));
+    const subtasks: SubtaskRecord[] = allIds.map((id) => {
+      const row = rowById.get(id);
+      if (!row) {
+        throw new DomainError({
+          code: "not_found",
+          message: `subtask not found: ${id}`,
+          details: { entity: "subtask", id },
+        });
+      }
+      return mapSubtask(row);
+    });
+
     return {
       subtasks,
       result: {
@@ -930,24 +1037,62 @@ export class TrackerDomain {
       });
     }
 
+    // Batch-fetch all existing edges with a single prepared statement instead
+    // of one #getDependencyByEdge call per spec (eliminates N+1 pattern).
+    const edgeLookupStmt = this.#db.query(
+      "SELECT id, source_id, source_kind, depends_on_id, depends_on_kind, created_at, updated_at FROM dependencies WHERE source_id = ? AND depends_on_id = ?;",
+    );
+    const existingEdgeMap = new Map<string, DependencyRecord>();
+    for (const spec of resolvedSpecs) {
+      const edgeKey = `${spec.sourceId}\0${spec.dependsOnId}`;
+      if (!existingEdgeMap.has(edgeKey)) {
+        const row = edgeLookupStmt.get(spec.sourceId, spec.dependsOnId) as DependencyRow | null;
+        if (row) {
+          existingEdgeMap.set(edgeKey, mapDependency(row));
+        }
+      }
+    }
+
     const dependencies: DependencyRecord[] = [];
+    const newIds: string[] = [];
+    const batchNow: number = Date.now();
+
     for (const spec of resolvedSpecs) {
-      const existing = this.#getDependencyByEdge(spec.sourceId, spec.dependsOnId);
+      const edgeKey = `${spec.sourceId}\0${spec.dependsOnId}`;
+      const existing = existingEdgeMap.get(edgeKey);
       if (existing) {
         dependencies.push(existing);
         continue;
       }
 
       const id: string = randomUUID();
-      const now: number = Date.now();
 
       this.#db
         .query(
           "INSERT INTO dependencies (id, source_id, source_kind, depends_on_id, depends_on_kind, created_at, updated_at, version) VALUES (?, ?, ?, ?, ?, ?, ?, 1);",
         )
-        .run(id, spec.sourceId, spec.sourceKind, spec.dependsOnId, spec.dependsOnKind, now, now);
+        .run(id, spec.sourceId, spec.sourceKind, spec.dependsOnId, spec.dependsOnKind, batchNow, batchNow);
 
-      dependencies.push(this.getDependencyOrThrow(id));
+      newIds.push(id);
+    }
+
+    // Batch-fetch all newly inserted dependencies instead of one getDependencyOrThrow per row.
+    for (let offset = 0; offset < newIds.length; offset += SQLITE_MAX_VARIABLES) {
+      const chunkIds = newIds.slice(offset, offset + SQLITE_MAX_VARIABLES);
+      const inPlaceholders: string = chunkIds.map(() => "?").join(", ");
+      const rows = this.#db
+        .query(
+          `SELECT id, source_id, source_kind, depends_on_id, depends_on_kind, created_at, updated_at FROM dependencies WHERE id IN (${inPlaceholders});`,
+        )
+        .all(...chunkIds) as DependencyRow[];
+      const rowMap = new Map(rows.map((row) => [row.id, row]));
+      for (const id of chunkIds) {
+        const row = rowMap.get(id);
+        if (!row) {
+          throw new DomainError({ code: "not_found", message: `dependency not found: ${id}`, details: { entity: "dependency", id } });
+        }
+        dependencies.push(mapDependency(row));
+      }
     }
 
     return {
@@ -1602,36 +1747,64 @@ export class TrackerDomain {
       return [];
     }
 
-    const blockers: StatusCascadeBlocker[] = [];
+    // Collect all dependency-eligible change IDs upfront.
+    const eligibleIds: string[] = [];
     for (const change of changes) {
-      if (change.kind !== "task" && change.kind !== "subtask") {
-        continue;
+      if (change.kind === "task" || change.kind === "subtask") {
+        eligibleIds.push(change.id);
       }
+    }
+
+    if (eligibleIds.length === 0) {
+      return [];
+    }
+
+    // Batch-fetch all dependency rows with their target statuses using a
+    // chunked IN query with JOINs.  This replaces the previous per-ID
+    // prepared statement approach, reducing N queries to ceil(N/999).
+    type DepStatusRow = {
+      source_id: string;
+      source_kind: "task" | "subtask";
+      depends_on_id: string;
+      depends_on_kind: "task" | "subtask";
+      dep_status: string | null;
+    };
 
-      for (const dependency of this.listDependencies(change.id)) {
-        const dependencyNode =
-          dependency.dependsOnKind === "task"
-            ? this.getTask(dependency.dependsOnId)
-            : this.getSubtask(dependency.dependsOnId);
+    const blockers: StatusCascadeBlocker[] = [];
 
+    for (let offset = 0; offset < eligibleIds.length; offset += SQLITE_MAX_VARIABLES) {
+      const chunkIds = eligibleIds.slice(offset, offset + SQLITE_MAX_VARIABLES);
+      const inPlaceholders: string = chunkIds.map(() => "?").join(", ");
+      const rows = this.#db
+        .query(
+          `SELECT d.source_id, d.source_kind, d.depends_on_id, d.depends_on_kind,
+                  COALESCE(t.status, s.status) AS dep_status
+           FROM dependencies d
+           LEFT JOIN tasks t ON d.depends_on_kind = 'task' AND d.depends_on_id = t.id
+           LEFT JOIN subtasks s ON d.depends_on_kind = 'subtask' AND d.depends_on_id = s.id
+           WHERE d.source_id IN (${inPlaceholders})
+           ORDER BY d.created_at ASC, d.id ASC;`,
+        )
+        .all(...chunkIds) as DepStatusRow[];
+
+      for (const row of rows) {
         // Skip orphaned dependency rows where the referenced node no longer exists.
-        if (!dependencyNode) {
+        if (row.dep_status === null) {
           continue;
         }
 
-        const dependencyStatus = dependencyNode.status;
-        const inScope = scopeIdSet.has(dependency.dependsOnId);
-        const willCascade = targetStatus === "done" && changedIdSet.has(dependency.dependsOnId);
-        if (dependencyStatus === "done" || willCascade) {
+        const inScope = scopeIdSet.has(row.depends_on_id);
+        const willCascade = targetStatus === "done" && changedIdSet.has(row.depends_on_id);
+        if (row.dep_status === "done" || willCascade) {
           continue;
         }
 
         blockers.push({
-          sourceId: dependency.sourceId,
-          sourceKind: dependency.sourceKind,
-          dependsOnId: dependency.dependsOnId,
-          dependsOnKind: dependency.dependsOnKind,
-          dependsOnStatus: dependencyStatus,
+          sourceId: row.source_id,
+          sourceKind: row.source_kind,
+          dependsOnId: row.depends_on_id,
+          dependsOnKind: row.depends_on_kind,
+          dependsOnStatus: row.dep_status,
           inScope,
           willCascade,
         });

package/src/storage/events-retention.ts

@@ -3,6 +3,7 @@ import { type Database } from "bun:sqlite";
 import { writeTransaction } from "./database";
 
 export const DEFAULT_EVENT_RETENTION_DAYS = 90;
+export const DEFAULT_CONFLICT_RETENTION_DAYS = 30;
 const DAY_IN_MILLISECONDS = 24 * 60 * 60 * 1000;
 
 export interface EventPruneOptions {
@@ -92,6 +93,20 @@ function countStaleCursors(db: Database): number {
   return row?.count ?? 0;
 }
 
+export interface ConflictPruneOptions {
+  readonly retentionDays?: number;
+  readonly dryRun?: boolean;
+  readonly now?: number;
+}
+
+export interface ConflictPruneSummary {
+  readonly retentionDays: number;
+  readonly cutoffTimestamp: number;
+  readonly dryRun: boolean;
+  readonly candidateCount: number;
+  readonly deletedCount: number;
+}
+
 export function pruneEvents(db: Database, options: EventPruneOptions = {}): EventPruneSummary {
   const retentionDays: number = assertRetentionDays(options.retentionDays ?? DEFAULT_EVENT_RETENTION_DAYS);
   const dryRun: boolean = options.dryRun ?? false;
@@ -185,3 +200,60 @@ export function pruneEvents(db: Database, options: EventPruneOptions = {}): Even
     };
   });
 }
+
+export function pruneResolvedConflicts(db: Database, options: ConflictPruneOptions = {}): ConflictPruneSummary {
+  const retentionDays: number = assertRetentionDays(options.retentionDays ?? DEFAULT_CONFLICT_RETENTION_DAYS);
+  const dryRun: boolean = options.dryRun ?? false;
+  const now: number = options.now ?? Date.now();
+  const cutoffTimestamp: number = now - retentionDays * DAY_IN_MILLISECONDS;
+
+  if (dryRun) {
+    const candidateRow = db
+      .query(
+        "SELECT COUNT(*) AS count FROM sync_conflicts WHERE resolution != 'pending' AND updated_at < ?;",
+      )
+      .get(cutoffTimestamp) as { count: number } | null;
+
+    return {
+      retentionDays,
+      cutoffTimestamp,
+      dryRun,
+      candidateCount: candidateRow?.count ?? 0,
+      deletedCount: 0,
+    };
+  }
+
+  return writeTransaction(db, (): ConflictPruneSummary => {
+    const candidateRow = db
+      .query(
+        "SELECT COUNT(*) AS count FROM sync_conflicts WHERE resolution != 'pending' AND updated_at < ?;",
+      )
+      .get(cutoffTimestamp) as { count: number } | null;
+
+    const candidateCount: number = candidateRow?.count ?? 0;
+
+    if (candidateCount === 0) {
+      return {
+        retentionDays,
+        cutoffTimestamp,
+        dryRun,
+        candidateCount,
+        deletedCount: 0,
+      };
+    }
+
+    const deleted = db
+      .query(
+        "DELETE FROM sync_conflicts WHERE resolution != 'pending' AND updated_at < ?;",
+      )
+      .run(cutoffTimestamp);
+
+    return {
+      retentionDays,
+      cutoffTimestamp,
+      dryRun,
+      candidateCount,
+      deletedCount: deleted.changes,
+    };
+  });
+}

package/src/storage/migrations.ts

@@ -58,6 +58,20 @@ const EVENT_ARCHIVE_MIGRATION_DOWN_STATEMENTS: readonly string[] = [
   "DROP TABLE IF EXISTS event_archive;",
 ];
 
+const LOOKUP_INDEX_MIGRATION_UP_STATEMENTS: readonly string[] = [
+  "CREATE INDEX IF NOT EXISTS idx_dependencies_depends_on_kind ON dependencies(depends_on_id, depends_on_kind);",
+  "CREATE INDEX IF NOT EXISTS idx_tasks_owner ON tasks(owner);",
+  "CREATE INDEX IF NOT EXISTS idx_subtasks_owner ON subtasks(owner);",
+  "CREATE INDEX IF NOT EXISTS idx_conflicts_resolution_updated_at ON sync_conflicts(resolution, updated_at);",
+];
+
+const LOOKUP_INDEX_MIGRATION_DOWN_STATEMENTS: readonly string[] = [
+  "DROP INDEX IF EXISTS idx_conflicts_resolution_updated_at;",
+  "DROP INDEX IF EXISTS idx_subtasks_owner;",
+  "DROP INDEX IF EXISTS idx_tasks_owner;",
+  "DROP INDEX IF EXISTS idx_dependencies_depends_on_kind;",
+];
+
 function tableHasColumn(db: Database, tableName: string, columnName: string): boolean {
   const columns = db.query(`PRAGMA table_info(${tableName});`).all() as Array<{ name: string }>;
   return columns.some((column) => column.name === columnName);
@@ -237,6 +251,20 @@ const MIGRATIONS: readonly Migration[] = [
       );
     },
   },
+  {
+    version: 7,
+    name: "0007_add_lookup_indexes",
+    up(db: Database): void {
+      for (const statement of LOOKUP_INDEX_MIGRATION_UP_STATEMENTS) {
+        db.exec(statement);
+      }
+    },
+    down(db: Database): void {
+      for (const statement of LOOKUP_INDEX_MIGRATION_DOWN_STATEMENTS) {
+        db.exec(statement);
+      }
+    },
+  },
 ];
 
 function migrationTableExists(db: Database): boolean {

package/src/sync/event-writes.ts

@@ -11,7 +11,7 @@ interface EventRecordInput {
   readonly fields: Record<string, unknown>;
 }
 
-function nextEventTimestamp(db: Database): number {
+export function nextEventTimestamp(db: Database): number {
   const now: number = Date.now();
   const latestEvent = db
     .query(
@@ -31,12 +31,16 @@ function nextEventTimestamp(db: Database): number {
   return Math.max(now, latestEvent.created_at + 1);
 }
 
-export function appendEventWithGitContext(db: Database, cwd: string, input: EventRecordInput): string {
+/** Append a single event to the events table with git context. Returns void (event ID is not exposed). */
+export function appendEventWithGitContext(
+  db: Database,
+  cwd: string,
+  input: EventRecordInput,
+): void {
   const git = resolveGitContext(cwd);
   persistGitContext(db, git);
 
   const now: number = nextEventTimestamp(db);
-  const eventId: string = randomUUID();
 
   db.query(
     `
@@ -54,7 +58,7 @@ export function appendEventWithGitContext(db: Database, cwd: string, input: Even
     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 1);
     `,
   ).run(
-    eventId,
+    randomUUID(),
     input.entityKind,
     input.entityId,
     input.operation,
@@ -64,6 +68,4 @@ export function appendEventWithGitContext(db: Database, cwd: string, input: Even
     now,
     now,
   );
-
-  return eventId;
 }