trekoon 0.2.0 → 0.2.4

package/src/sync/service.ts

@@ -3,7 +3,7 @@ import { randomUUID } from "node:crypto";
 import { type Database } from "bun:sqlite";
 
 import { openTrekoonDatabase } from "../storage/database";
-import { openBranchDatabaseSnapshot } from "./branch-db";
+import { countBranchEventsSince, queryBranchEventsSince } from "./branch-db";
 import { persistGitContext, resolveGitContext } from "./git-context";
 import {
   type PullSummary,
@@ -29,6 +29,8 @@ interface StoredEvent {
 }
 
 interface CursorRow {
+  readonly owner_scope: string;
+  readonly owner_worktree_path: string;
   readonly source_branch: string;
   readonly cursor_token: string;
   readonly last_event_at: number | null;
@@ -116,40 +118,45 @@ function tableForEntityKind(entityKind: string): "epics" | "tasks" | "subtasks"
   }
 }
 
-function parseCursorToken(token: string): { createdAt: number; id: string | null } {
-  const [createdAtRaw, idRaw] = token.split(":");
-  const createdAt: number = Number.parseInt(createdAtRaw ?? "0", 10);
-
-  return {
-    createdAt: Number.isFinite(createdAt) ? createdAt : 0,
-    id: idRaw && idRaw.length > 0 ? idRaw : null,
-  };
-}
-
 function cursorTokenFromEvent(event: StoredEvent): string {
   return `${event.created_at}:${event.id}`;
 }
 
-function loadCursor(db: Database, sourceBranch: string): CursorRow | null {
+function cursorIdForWorktree(worktreePath: string, sourceBranch: string): string {
+  return `${worktreePath}::${sourceBranch}`;
+}
+
+function loadCursor(db: Database, worktreePath: string, sourceBranch: string): CursorRow | null {
   return db
     .query(
       `
-      SELECT source_branch, cursor_token, last_event_at
+      SELECT owner_scope, owner_worktree_path, source_branch, cursor_token, last_event_at
       FROM sync_cursors
-      WHERE source_branch = ?
+      WHERE owner_scope = 'worktree'
+        AND owner_worktree_path = ?
+        AND source_branch = ?
       LIMIT 1;
       `,
     )
-    .get(sourceBranch) as CursorRow | null;
+    .get(worktreePath, sourceBranch) as CursorRow | null;
 }
 
-function saveCursor(db: Database, sourceBranch: string, cursorToken: string, lastEventAt: number | null): void {
+function saveCursor(
+  db: Database,
+  worktreePath: string,
+  sourceBranch: string,
+  cursorToken: string,
+  lastEventAt: number | null,
+): void {
   const now: number = Date.now();
+  const cursorId = cursorIdForWorktree(worktreePath, sourceBranch);
 
   db.query(
     `
     INSERT INTO sync_cursors (
       id,
+      owner_scope,
+      owner_worktree_path,
       source_branch,
       cursor_token,
       last_event_at,
@@ -157,7 +164,9 @@ function saveCursor(db: Database, sourceBranch: string, cursorToken: string, las
       updated_at,
       version
     ) VALUES (
-      @sourceBranch,
+      @cursorId,
+      'worktree',
+      @worktreePath,
       @sourceBranch,
       @cursorToken,
       @lastEventAt,
@@ -166,12 +175,16 @@ function saveCursor(db: Database, sourceBranch: string, cursorToken: string, las
       1
     )
     ON CONFLICT(id) DO UPDATE SET
+      owner_scope = excluded.owner_scope,
+      owner_worktree_path = excluded.owner_worktree_path,
       cursor_token = excluded.cursor_token,
       last_event_at = excluded.last_event_at,
       updated_at = excluded.updated_at,
       version = sync_cursors.version + 1;
     `,
   ).run({
+    "@cursorId": cursorId,
+    "@worktreePath": worktreePath,
     "@sourceBranch": sourceBranch,
     "@cursorToken": cursorToken,
     "@lastEventAt": lastEventAt,
@@ -179,25 +192,6 @@ function saveCursor(db: Database, sourceBranch: string, cursorToken: string, las
   });
 }
 
-function queryNewEvents(remoteDb: Database, cursorToken: string): StoredEvent[] {
-  const cursor = parseCursorToken(cursorToken);
-
-  return remoteDb
-    .query(
-      `
-      SELECT id, entity_kind, entity_id, operation, payload, git_branch, git_head, created_at, updated_at, version
-      FROM events
-      WHERE created_at > @createdAt
-         OR (created_at = @createdAt AND id > @id)
-      ORDER BY created_at ASC, id ASC;
-      `,
-    )
-    .all({
-      "@createdAt": cursor.createdAt,
-      "@id": cursor.id ?? "",
-    }) as StoredEvent[];
-}
-
 function countPendingConflicts(db: Database): number {
   const row = db
     .query("SELECT COUNT(*) AS count FROM sync_conflicts WHERE resolution = 'pending';")
@@ -206,54 +200,24 @@ function countPendingConflicts(db: Database): number {
   return row?.count ?? 0;
 }
 
-function countBehind(remoteDb: Database, cursorToken: string): number {
-  const cursor = parseCursorToken(cursorToken);
-  const row = remoteDb
+function countAhead(localDb: Database, currentBranch: string | null, sourceBranch: string): number {
+  if (!currentBranch || currentBranch === sourceBranch) {
+    return 0;
+  }
+
+  const row = localDb
     .query(
       `
       SELECT COUNT(*) AS count
       FROM events
-      WHERE created_at > @createdAt
-         OR (created_at = @createdAt AND id > @id);
+      WHERE git_branch = @branch;
       `,
     )
-    .get({
-      "@createdAt": cursor.createdAt,
-      "@id": cursor.id ?? "",
-    }) as { count: number } | null;
+    .get({ "@branch": currentBranch }) as { count: number } | null;
 
   return row?.count ?? 0;
 }
 
-function countAhead(localDb: Database, currentBranch: string | null, remoteDbPath: string): number {
-  if (!currentBranch) {
-    return 0;
-  }
-
-  localDb.query("ATTACH DATABASE ? AS sync_remote;").run(remoteDbPath);
-
-  try {
-    const row = localDb
-      .query(
-        `
-        SELECT COUNT(*) AS count
-        FROM events AS local_events
-        WHERE local_events.git_branch = @branch
-          AND NOT EXISTS (
-            SELECT 1
-            FROM sync_remote.events AS remote_events
-            WHERE remote_events.id = local_events.id
-          );
-        `,
-      )
-      .get({ "@branch": currentBranch }) as { count: number } | null;
-
-    return row?.count ?? 0;
-  } finally {
-    localDb.query("DETACH DATABASE sync_remote;").run();
-  }
-}
-
 function buildSyncErrorHints(diagnostics: {
   malformedPayloadEvents: number;
   applyRejectedEvents: number;
@@ -401,6 +365,18 @@ function rowExists(db: Database, tableName: string, id: string): boolean {
   return row !== null;
 }
 
+function dependencyNodeExists(db: Database, nodeKind: string, nodeId: string): boolean {
+  if (nodeKind === "task") {
+    return rowExists(db, "tasks", nodeId);
+  }
+
+  if (nodeKind === "subtask") {
+    return rowExists(db, "subtasks", nodeId);
+  }
+
+  return false;
+}
+
 function validateRequiredStringField(fields: Record<string, unknown>, fieldName: string): string | null {
   const value: unknown = fields[fieldName];
   if (typeof value !== "string" || value.length === 0) {
@@ -503,6 +479,10 @@ function applyCreate(db: Database, event: StoredEvent, fields: Record<string, un
     return false;
   }
 
+  if (!dependencyNodeExists(db, sourceKind, sourceId) || !dependencyNodeExists(db, dependsOnKind, dependsOnId)) {
+    return false;
+  }
+
   db.query(
     `
     INSERT INTO dependencies (
@@ -625,6 +605,28 @@ function applyEntityFields(db: Database, event: StoredEvent, fields: Record<stri
   return false;
 }
 
+function applyReplayedCreateWithConflicts(
+  db: Database,
+  event: StoredEvent,
+  fields: Record<string, unknown>,
+  withheldConflictCount: number,
+): boolean {
+  if (withheldConflictCount === 0 || !event.operation.endsWith(".created")) {
+    return false;
+  }
+
+  const tableName = tableForEntityKind(event.entity_kind);
+  if (!tableName || !rowExists(db, tableName, event.entity_id)) {
+    return false;
+  }
+
+  if (Object.keys(fields).length === 0) {
+    return true;
+  }
+
+  return applyUpdatePatch(db, event, fields);
+}
+
 function storeEvent(db: Database, event: StoredEvent): void {
   db.query(
     `
@@ -662,21 +664,18 @@ export function syncStatus(cwd: string, sourceBranch: string): SyncStatusSummary
   try {
     persistGitContext(storage.db, git);
 
-    const cursor = loadCursor(storage.db, sourceBranch);
+    const cursor = loadCursor(storage.db, git.worktreePath, sourceBranch);
     const cursorToken: string = cursor?.cursor_token ?? "0:";
-    const remote = openBranchDatabaseSnapshot(sourceBranch, cwd);
+    const onSourceBranch: boolean = git.branchName !== null && git.branchName === sourceBranch;
 
-    try {
-      return {
-        sourceBranch,
-        ahead: countAhead(storage.db, git.branchName, remote.path),
-        behind: countBehind(remote.db, cursorToken),
-        pendingConflicts: countPendingConflicts(storage.db),
-        git,
-      };
-    } finally {
-      remote.close();
-    }
+    return {
+      sourceBranch,
+      ahead: countAhead(storage.db, git.branchName, sourceBranch),
+      behind: onSourceBranch ? 0 : countBranchEventsSince(storage.db, sourceBranch, cursorToken),
+      pendingConflicts: countPendingConflicts(storage.db),
+      sameBranch: onSourceBranch,
+      git,
+    };
   } finally {
     storage.close();
   }
@@ -684,15 +683,48 @@ export function syncStatus(cwd: string, sourceBranch: string): SyncStatusSummary
 
 export function syncPull(cwd: string, sourceBranch: string): PullSummary {
   const storage = openTrekoonDatabase(cwd);
-  const git = resolveGitContext(cwd);
-  persistGitContext(storage.db, git);
-
-  const remote = openBranchDatabaseSnapshot(sourceBranch, cwd);
 
   try {
-    const cursor = loadCursor(storage.db, sourceBranch);
+    const git = resolveGitContext(cwd);
+    persistGitContext(storage.db, git);
+    const cursor = loadCursor(storage.db, git.worktreePath, sourceBranch);
     const cursorToken = cursor?.cursor_token ?? "0:";
-    const incomingEvents: StoredEvent[] = queryNewEvents(remote.db, cursorToken);
+    const incomingEvents: StoredEvent[] = queryBranchEventsSince(storage.db, sourceBranch, cursorToken) as StoredEvent[];
+
+    // Same-branch fast path: skip conflict detection when already on sourceBranch.
+    // Null branchName (detached HEAD) falls through to the normal path.
+    if (git.branchName !== null && git.branchName === sourceBranch) {
+      let lastToken: string | null = null;
+      let lastEventAt: number | null = cursor?.last_event_at ?? null;
+
+      storage.db.transaction((): void => {
+        for (const incoming of incomingEvents) {
+          storeEvent(storage.db, incoming);
+          lastToken = cursorTokenFromEvent(incoming);
+          lastEventAt = incoming.created_at;
+        }
+
+        if (lastToken) {
+          saveCursor(storage.db, git.worktreePath, sourceBranch, lastToken, lastEventAt);
+        }
+      })();
+
+      return {
+        sourceBranch,
+        scannedEvents: incomingEvents.length,
+        appliedEvents: 0,
+        createdConflicts: 0,
+        cursorToken: lastToken,
+        sameBranch: true,
+        diagnostics: {
+          malformedPayloadEvents: 0,
+          applyRejectedEvents: 0,
+          quarantinedEvents: 0,
+          conflictEvents: 0,
+          errorHints: [],
+        },
+      };
+    }
 
     let appliedEvents = 0;
     let createdConflicts = 0;
@@ -727,11 +759,13 @@ export function syncPull(cwd: string, sourceBranch: string): PullSummary {
 
         const payload: EventPayload = { fields: payloadValidation.fields };
         const fieldsToApply: Record<string, unknown> = {};
+        let withheldConflictCount = 0;
 
         for (const [fieldName, value] of Object.entries(payload.fields)) {
           const conflict = entityFieldConflict(storage.db, sourceBranch, incoming, fieldName, value);
 
           if (conflict) {
+            withheldConflictCount += 1;
             conflictEvents += 1;
             createConflict(storage.db, incoming, fieldName, conflict.oursValue, conflict.theirsValue);
             createdConflicts += 1;
@@ -743,6 +777,8 @@ export function syncPull(cwd: string, sourceBranch: string): PullSummary {
 
         if (applyEntityFields(storage.db, incoming, fieldsToApply)) {
           appliedEvents += 1;
+        } else if (applyReplayedCreateWithConflicts(storage.db, incoming, fieldsToApply, withheldConflictCount)) {
+          appliedEvents += 1;
         } else if (incoming.operation !== "resolve_conflict") {
           applyRejectedEvents += 1;
           quarantinedEvents += 1;
@@ -763,7 +799,7 @@ export function syncPull(cwd: string, sourceBranch: string): PullSummary {
       }
 
       if (lastToken) {
-        saveCursor(storage.db, sourceBranch, lastToken, lastEventAt);
+        saveCursor(storage.db, git.worktreePath, sourceBranch, lastToken, lastEventAt);
       }
     })();
 
@@ -773,6 +809,7 @@ export function syncPull(cwd: string, sourceBranch: string): PullSummary {
       appliedEvents,
       createdConflicts,
       cursorToken: lastToken,
+      sameBranch: false,
       diagnostics: {
         malformedPayloadEvents,
         applyRejectedEvents,
@@ -786,7 +823,6 @@ export function syncPull(cwd: string, sourceBranch: string): PullSummary {
       },
     };
   } finally {
-    remote.close();
     storage.close();
   }
 }

package/src/sync/types.ts

@@ -12,6 +12,7 @@ export interface SyncStatusSummary {
   readonly ahead: number;
   readonly behind: number;
   readonly pendingConflicts: number;
+  readonly sameBranch: boolean;
   readonly git: GitContextSnapshot;
 }
 
@@ -21,6 +22,7 @@ export interface PullSummary {
   readonly appliedEvents: number;
   readonly createdConflicts: number;
   readonly cursorToken: string | null;
+  readonly sameBranch: boolean;
   readonly diagnostics: SyncPullDiagnostics;
 }