trekoon 0.1.5 → 0.1.7

package/src/sync/service.ts

@@ -5,7 +5,15 @@ import { type Database } from "bun:sqlite";
 import { openTrekoonDatabase } from "../storage/database";
 import { openBranchDatabaseSnapshot } from "./branch-db";
 import { persistGitContext, resolveGitContext } from "./git-context";
-import { type PullSummary, type ResolveSummary, type SyncResolution, type SyncStatusSummary } from "./types";
+import {
+  type PullSummary,
+  type ResolveSummary,
+  type SyncConflictDetail,
+  type SyncConflictListItem,
+  type SyncConflictMode,
+  type SyncResolution,
+  type SyncStatusSummary,
+} from "./types";
 
 interface StoredEvent {
   readonly id: string;
@@ -35,32 +43,62 @@ interface ConflictRow {
   readonly ours_value: string | null;
   readonly theirs_value: string | null;
   readonly resolution: string;
+  readonly created_at: number;
+  readonly updated_at: number;
 }
 
 interface EventPayload {
-  readonly fields?: Record<string, unknown>;
+  readonly fields: Record<string, unknown>;
+}
+
+interface PayloadValidation {
+  readonly ok: boolean;
+  readonly fields: Record<string, unknown>;
+  readonly reason?: string;
 }
 
 function isObjectRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-function parsePayload(rawPayload: string): EventPayload {
+function parsePayload(rawPayload: string): PayloadValidation {
   try {
     const parsed: unknown = JSON.parse(rawPayload);
 
-    if (isObjectRecord(parsed)) {
-      if ("fields" in parsed && !isObjectRecord(parsed.fields)) {
-        return {};
-      }
+    if (!isObjectRecord(parsed)) {
+      return {
+        ok: false,
+        fields: {},
+        reason: "payload must be a JSON object",
+      };
+    }
 
-      return parsed as EventPayload;
+    if (!("fields" in parsed)) {
+      return {
+        ok: true,
+        fields: {},
+      };
     }
+
+    if (!isObjectRecord(parsed.fields)) {
+      return {
+        ok: false,
+        fields: {},
+        reason: "payload.fields must be an object",
+      };
+    }
+
+    return {
+      ok: true,
+      fields: parsed.fields,
+    };
   } catch {
-    // Fall back to empty payload.
+    return {
+      ok: false,
+      fields: {},
+      reason: "payload is not valid JSON",
+    };
   }
-
-  return {};
 }
 
 function tableForEntityKind(entityKind: string): "epics" | "tasks" | "subtasks" | "dependencies" | null {
@@ -187,26 +225,59 @@ function countBehind(remoteDb: Database, cursorToken: string): number {
   return row?.count ?? 0;
 }
 
-function listRemoteEventIds(remoteDb: Database): Set<string> {
-  const rows = remoteDb.query("SELECT id FROM events;").all() as Array<{ id: string }>;
-  return new Set(rows.map((row) => row.id));
-}
+function countAhead(localDb: Database, currentBranch: string | null, remoteDbPath: string): number {
+  if (!currentBranch) {
+    return 0;
+  }
 
-function countAhead(localDb: Database, currentBranch: string | null, remoteEventIds: Set<string>): number {
-  const rows = localDb
-    .query("SELECT id, git_branch FROM events WHERE git_branch = ?;")
-    .all(currentBranch) as Array<{ id: string; git_branch: string | null }>;
+  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 rows.filter((row) => !remoteEventIds.has(row.id)).length;
+    return row?.count ?? 0;
+  } finally {
+    localDb.query("DETACH DATABASE sync_remote;").run();
+  }
 }
 
-function readFieldValue(payload: EventPayload, field: string): unknown {
-  const fields = payload.fields;
-  if (!fields) {
-    return undefined;
+function buildSyncErrorHints(diagnostics: {
+  malformedPayloadEvents: number;
+  applyRejectedEvents: number;
+  conflictEvents: number;
+}): string[] {
+  const hints: string[] = [];
+
+  if (diagnostics.malformedPayloadEvents > 0) {
+    hints.push("Malformed event payloads were quarantined; inspect sync conflicts with field '__payload__'.");
+  }
+
+  if (diagnostics.applyRejectedEvents > 0) {
+    hints.push("Some events were quarantined as invalid; inspect sync conflicts with field '__apply__'.");
+  }
+
+  if (diagnostics.conflictEvents > 0) {
+    hints.push("Field-level conflicts detected; run 'trekoon sync conflicts list' and resolve pending entries.");
   }
 
-  return fields[field];
+  return hints;
+}
+
+function readFieldValue(payload: EventPayload, field: string): unknown {
+  return payload.fields[field];
 }
 
 function serializeValue(value: unknown): string | null {
@@ -217,6 +288,31 @@ function serializeValue(value: unknown): string | null {
   return JSON.stringify(value);
 }
 
+function currentEntityFieldValue(db: Database, entityKind: string, entityId: string, fieldName: string): unknown {
+  const tableName = tableForEntityKind(entityKind);
+  if (!tableName) {
+    return undefined;
+  }
+
+  const allowedFields: Record<string, readonly string[]> = {
+    epics: ["title", "description", "status"],
+    tasks: ["epic_id", "title", "description", "status"],
+    subtasks: ["task_id", "title", "description", "status"],
+    dependencies: ["source_id", "source_kind", "depends_on_id", "depends_on_kind"],
+  };
+
+  const validFields = allowedFields[tableName] ?? [];
+  if (!validFields.includes(fieldName)) {
+    return undefined;
+  }
+
+  const row = db.query(`SELECT ${fieldName} AS value FROM ${tableName} WHERE id = ? LIMIT 1;`).get(entityId) as
+    | { value: string }
+    | null;
+
+  return row?.value;
+}
+
 function entityFieldConflict(
   localDb: Database,
   sourceBranch: string,
@@ -224,6 +320,11 @@ function entityFieldConflict(
   fieldName: string,
   incomingValue: unknown,
 ): { oursValue: string | null; theirsValue: string | null } | null {
+  const currentValue = currentEntityFieldValue(localDb, event.entity_kind, event.entity_id, fieldName);
+  if (serializeValue(currentValue) === serializeValue(incomingValue)) {
+    return null;
+  }
+
   const rows = localDb
     .query(
       `
@@ -241,7 +342,12 @@ function entityFieldConflict(
       continue;
     }
 
-    const payload = parsePayload(row.payload);
+    const payloadValidation = parsePayload(row.payload);
+    if (!payloadValidation.ok) {
+      continue;
+    }
+
+    const payload: EventPayload = { fields: payloadValidation.fields };
     const localValue: unknown = readFieldValue(payload, fieldName);
 
     if (typeof localValue === "undefined") {
@@ -268,6 +374,7 @@ function createConflict(
   fieldName: string,
   oursValue: string | null,
   theirsValue: string | null,
+  resolution: string = "pending",
 ): void {
   const now: number = Date.now();
   db.query(
@@ -284,12 +391,26 @@ function createConflict(
       created_at,
       updated_at,
       version
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, 'pending', ?, ?, 1);
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1);
     `,
-  ).run(randomUUID(), event.id, event.entity_kind, event.entity_id, fieldName, oursValue, theirsValue, now, now);
+  ).run(randomUUID(), event.id, event.entity_kind, event.entity_id, fieldName, oursValue, theirsValue, resolution, now, now);
 }
 
-function applyEntityFields(db: Database, event: StoredEvent, fields: Record<string, unknown>): boolean {
+function rowExists(db: Database, tableName: string, id: string): boolean {
+  const row = db.query(`SELECT id FROM ${tableName} WHERE id = ? LIMIT 1;`).get(id) as { id: string } | null;
+  return row !== null;
+}
+
+function validateRequiredStringField(fields: Record<string, unknown>, fieldName: string): string | null {
+  const value: unknown = fields[fieldName];
+  if (typeof value !== "string" || value.length === 0) {
+    return null;
+  }
+
+  return value;
+}
+
+function applyCreate(db: Database, event: StoredEvent, fields: Record<string, unknown>): boolean {
   const tableName = tableForEntityKind(event.entity_kind);
   if (!tableName) {
     return false;
@@ -298,10 +419,17 @@ function applyEntityFields(db: Database, event: StoredEvent, fields: Record<stri
   const now: number = Date.now();
 
   if (tableName === "epics") {
+    const title = validateRequiredStringField(fields, "title");
+    const status = validateRequiredStringField(fields, "status");
+    if (!title || !status) {
+      return false;
+    }
+
+    const description = typeof fields.description === "string" ? fields.description : "";
     db.query(
       `
       INSERT INTO epics (id, title, description, status, created_at, updated_at, version)
-      VALUES (@id, @title, @description, @status, @now, @now, 1)
+      VALUES (?, ?, ?, ?, ?, ?, 1)
       ON CONFLICT(id) DO UPDATE SET
         title = excluded.title,
         description = excluded.description,
@@ -309,22 +437,24 @@ function applyEntityFields(db: Database, event: StoredEvent, fields: Record<stri
         updated_at = excluded.updated_at,
         version = epics.version + 1;
       `,
-    ).run({
-      "@id": event.entity_id,
-      "@title": typeof fields.title === "string" ? fields.title : "Untitled epic",
-      "@description": typeof fields.description === "string" ? fields.description : "",
-      "@status": typeof fields.status === "string" ? fields.status : "open",
-      "@now": now,
-    });
+    ).run(event.entity_id, title, description, status, now, now);
 
     return true;
   }
 
   if (tableName === "tasks") {
+    const epicId = validateRequiredStringField(fields, "epic_id");
+    const title = validateRequiredStringField(fields, "title");
+    const status = validateRequiredStringField(fields, "status");
+    if (!epicId || !title || !status || !rowExists(db, "epics", epicId)) {
+      return false;
+    }
+
+    const description = typeof fields.description === "string" ? fields.description : "";
     db.query(
       `
       INSERT INTO tasks (id, epic_id, title, description, status, created_at, updated_at, version)
-      VALUES (@id, @epicId, @title, @description, @status, @now, @now, 1)
+      VALUES (?, ?, ?, ?, ?, ?, ?, 1)
       ON CONFLICT(id) DO UPDATE SET
         epic_id = excluded.epic_id,
         title = excluded.title,
@@ -333,23 +463,24 @@ function applyEntityFields(db: Database, event: StoredEvent, fields: Record<stri
         updated_at = excluded.updated_at,
         version = tasks.version + 1;
       `,
-    ).run({
-      "@id": event.entity_id,
-      "@epicId": typeof fields.epic_id === "string" ? fields.epic_id : "missing-epic",
-      "@title": typeof fields.title === "string" ? fields.title : "Untitled task",
-      "@description": typeof fields.description === "string" ? fields.description : "",
-      "@status": typeof fields.status === "string" ? fields.status : "open",
-      "@now": now,
-    });
+    ).run(event.entity_id, epicId, title, description, status, now, now);
 
     return true;
   }
 
   if (tableName === "subtasks") {
+    const taskId = validateRequiredStringField(fields, "task_id");
+    const title = validateRequiredStringField(fields, "title");
+    const status = validateRequiredStringField(fields, "status");
+    if (!taskId || !title || !status || !rowExists(db, "tasks", taskId)) {
+      return false;
+    }
+
+    const description = typeof fields.description === "string" ? fields.description : "";
     db.query(
       `
       INSERT INTO subtasks (id, task_id, title, description, status, created_at, updated_at, version)
-      VALUES (@id, @taskId, @title, @description, @status, @now, @now, 1)
+      VALUES (?, ?, ?, ?, ?, ?, ?, 1)
       ON CONFLICT(id) DO UPDATE SET
         task_id = excluded.task_id,
         title = excluded.title,
@@ -358,18 +489,20 @@ function applyEntityFields(db: Database, event: StoredEvent, fields: Record<stri
         updated_at = excluded.updated_at,
         version = subtasks.version + 1;
       `,
-    ).run({
-      "@id": event.entity_id,
-      "@taskId": typeof fields.task_id === "string" ? fields.task_id : "missing-task",
-      "@title": typeof fields.title === "string" ? fields.title : "Untitled subtask",
-      "@description": typeof fields.description === "string" ? fields.description : "",
-      "@status": typeof fields.status === "string" ? fields.status : "open",
-      "@now": now,
-    });
+    ).run(event.entity_id, taskId, title, description, status, now, now);
 
     return true;
   }
 
+  const sourceId = validateRequiredStringField(fields, "source_id");
+  const sourceKind = validateRequiredStringField(fields, "source_kind");
+  const dependsOnId = validateRequiredStringField(fields, "depends_on_id");
+  const dependsOnKind = validateRequiredStringField(fields, "depends_on_kind");
+
+  if (!sourceId || !sourceKind || !dependsOnId || !dependsOnKind) {
+    return false;
+  }
+
   db.query(
     `
     INSERT INTO dependencies (
@@ -381,8 +514,7 @@ function applyEntityFields(db: Database, event: StoredEvent, fields: Record<stri
       created_at,
       updated_at,
       version
-    )
-    VALUES (@id, @sourceId, @sourceKind, @dependsOnId, @dependsOnKind, @now, @now, 1)
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, 1)
     ON CONFLICT(id) DO UPDATE SET
       source_id = excluded.source_id,
       source_kind = excluded.source_kind,
@@ -391,18 +523,108 @@ function applyEntityFields(db: Database, event: StoredEvent, fields: Record<stri
       updated_at = excluded.updated_at,
       version = dependencies.version + 1;
     `,
-  ).run({
-    "@id": event.entity_id,
-    "@sourceId": typeof fields.source_id === "string" ? fields.source_id : "",
-    "@sourceKind": typeof fields.source_kind === "string" ? fields.source_kind : "task",
-    "@dependsOnId": typeof fields.depends_on_id === "string" ? fields.depends_on_id : "",
-    "@dependsOnKind": typeof fields.depends_on_kind === "string" ? fields.depends_on_kind : "task",
-    "@now": now,
-  });
+  ).run(event.entity_id, sourceId, sourceKind, dependsOnId, dependsOnKind, now, now);
+
+  return true;
+}
+
+function applyUpdatePatch(db: Database, event: StoredEvent, fields: Record<string, unknown>): boolean {
+  const tableName = tableForEntityKind(event.entity_kind);
+  if (!tableName) {
+    return false;
+  }
+
+  const allowedFields: Record<string, readonly string[]> = {
+    epics: ["title", "description", "status"],
+    tasks: ["epic_id", "title", "description", "status"],
+    subtasks: ["task_id", "title", "description", "status"],
+    dependencies: ["source_id", "source_kind", "depends_on_id", "depends_on_kind"],
+  };
+
+  if (!rowExists(db, tableName, event.entity_id)) {
+    return false;
+  }
+
+  const allowed = new Set(allowedFields[tableName] ?? []);
+  const entries = Object.entries(fields).filter(([fieldName, value]) => allowed.has(fieldName) && typeof value === "string");
+
+  if (entries.length === 0) {
+    return false;
+  }
+
+  if (tableName === "tasks") {
+    const epicIdEntry = entries.find(([field]) => field === "epic_id");
+    if (epicIdEntry && !rowExists(db, "epics", epicIdEntry[1] as string)) {
+      return false;
+    }
+  }
+
+  if (tableName === "subtasks") {
+    const taskIdEntry = entries.find(([field]) => field === "task_id");
+    if (taskIdEntry && !rowExists(db, "tasks", taskIdEntry[1] as string)) {
+      return false;
+    }
+  }
+
+  const now = Date.now();
+  const setClause = entries.map(([field]) => `${field} = ?`).join(", ");
+  const values = entries.map(([, value]) => value as string);
+
+  db.query(`UPDATE ${tableName} SET ${setClause}, updated_at = ?, version = version + 1 WHERE id = ?;`).run(
+    ...values,
+    now,
+    event.entity_id,
+  );
+
+  return true;
+}
+
+function applyDelete(db: Database, event: StoredEvent, fields: Record<string, unknown>): boolean {
+  const tableName = tableForEntityKind(event.entity_kind);
+  if (!tableName) {
+    return false;
+  }
 
+  if (event.operation === "dependency.removed") {
+    const sourceId = validateRequiredStringField(fields, "source_id");
+    const dependsOnId = validateRequiredStringField(fields, "depends_on_id");
+    if (!sourceId || !dependsOnId) {
+      return false;
+    }
+
+    db.query("DELETE FROM dependencies WHERE source_id = ? AND depends_on_id = ?;").run(sourceId, dependsOnId);
+    return true;
+  }
+
+  db.query(`DELETE FROM ${tableName} WHERE id = ?;`).run(event.entity_id);
   return true;
 }
 
+function applyEntityFields(db: Database, event: StoredEvent, fields: Record<string, unknown>): boolean {
+  if (event.operation.endsWith(".deleted") || event.operation === "dependency.removed") {
+    return applyDelete(db, event, fields);
+  }
+
+  if (event.operation.endsWith(".created") || event.operation === "dependency.added") {
+    return applyCreate(db, event, fields);
+  }
+
+  if (event.operation.endsWith(".updated")) {
+    return applyUpdatePatch(db, event, fields);
+  }
+
+  // Backward-compatible fallback for old upsert events.
+  if (event.operation === "upsert") {
+    const tableName = tableForEntityKind(event.entity_kind);
+    if (!tableName || !rowExists(db, tableName, event.entity_id)) {
+      return applyCreate(db, event, fields);
+    }
+    return applyUpdatePatch(db, event, fields);
+  }
+
+  return false;
+}
+
 function storeEvent(db: Database, event: StoredEvent): void {
   db.query(
     `
@@ -447,7 +669,7 @@ export function syncStatus(cwd: string, sourceBranch: string): SyncStatusSummary
     try {
       return {
         sourceBranch,
-        ahead: countAhead(storage.db, git.branchName, listRemoteEventIds(remote.db)),
+        ahead: countAhead(storage.db, git.branchName, remote.path),
         behind: countBehind(remote.db, cursorToken),
         pendingConflicts: countPendingConflicts(storage.db),
         git,
@@ -474,31 +696,65 @@ export function syncPull(cwd: string, sourceBranch: string): PullSummary {
 
     let appliedEvents = 0;
     let createdConflicts = 0;
+    let malformedPayloadEvents = 0;
+    let applyRejectedEvents = 0;
+    let quarantinedEvents = 0;
+    let conflictEvents = 0;
     let lastToken: string | null = null;
     let lastEventAt: number | null = cursor?.last_event_at ?? null;
 
     storage.db.transaction((): void => {
       for (const incoming of incomingEvents) {
-        const payload = parsePayload(incoming.payload);
-        const incomingFields: Record<string, unknown> = payload.fields ?? {};
+        const payloadValidation = parsePayload(incoming.payload);
+
+        if (!payloadValidation.ok) {
+          malformedPayloadEvents += 1;
+          quarantinedEvents += 1;
+          createConflict(
+            storage.db,
+            incoming,
+            "__payload__",
+            null,
+            payloadValidation.reason ?? "Invalid payload",
+            "invalid",
+          );
+          createdConflicts += 1;
+          storeEvent(storage.db, incoming);
+          lastToken = cursorTokenFromEvent(incoming);
+          lastEventAt = incoming.created_at;
+          continue;
+        }
+
+        const payload: EventPayload = { fields: payloadValidation.fields };
         const fieldsToApply: Record<string, unknown> = {};
-        let hasAppliedField = false;
 
-        for (const [fieldName, value] of Object.entries(incomingFields)) {
+        for (const [fieldName, value] of Object.entries(payload.fields)) {
           const conflict = entityFieldConflict(storage.db, sourceBranch, incoming, fieldName, value);
 
           if (conflict) {
+            conflictEvents += 1;
             createConflict(storage.db, incoming, fieldName, conflict.oursValue, conflict.theirsValue);
             createdConflicts += 1;
             continue;
           }
 
           fieldsToApply[fieldName] = value;
-          hasAppliedField = true;
         }
 
-        if (hasAppliedField && applyEntityFields(storage.db, incoming, fieldsToApply)) {
+        if (applyEntityFields(storage.db, incoming, fieldsToApply)) {
           appliedEvents += 1;
+        } else if (incoming.operation !== "resolve_conflict") {
+          applyRejectedEvents += 1;
+          quarantinedEvents += 1;
+          createConflict(
+            storage.db,
+            incoming,
+            "__apply__",
+            null,
+            `Rejected event ${incoming.operation} for ${incoming.entity_kind}`,
+            "invalid",
+          );
+          createdConflicts += 1;
         }
 
         storeEvent(storage.db, incoming);
@@ -517,6 +773,17 @@ export function syncPull(cwd: string, sourceBranch: string): PullSummary {
       appliedEvents,
       createdConflicts,
       cursorToken: lastToken,
+      diagnostics: {
+        malformedPayloadEvents,
+        applyRejectedEvents,
+        quarantinedEvents,
+        conflictEvents,
+        errorHints: buildSyncErrorHints({
+          malformedPayloadEvents,
+          applyRejectedEvents,
+          conflictEvents,
+        }),
+      },
     };
   } finally {
     remote.close();
@@ -604,6 +871,83 @@ function appendResolutionEvent(
   );
 }
 
+export function listSyncConflicts(cwd: string, mode: SyncConflictMode): SyncConflictListItem[] {
+  const storage = openTrekoonDatabase(cwd);
+
+  try {
+    const whereClause = mode === "pending" ? "WHERE resolution = 'pending'" : "";
+    return storage.db
+      .query(
+        `
+        SELECT id, event_id, entity_kind, entity_id, field_name, ours_value, theirs_value, resolution, created_at, updated_at
+        FROM sync_conflicts
+        ${whereClause}
+        ORDER BY created_at ASC;
+        `,
+      )
+      .all() as SyncConflictListItem[];
+  } finally {
+    storage.close();
+  }
+}
+
+export function getSyncConflict(cwd: string, conflictId: string): SyncConflictDetail {
+  const storage = openTrekoonDatabase(cwd);
+
+  try {
+    const conflict = storage.db
+      .query(
+        `
+        SELECT id, event_id, entity_kind, entity_id, field_name, ours_value, theirs_value, resolution, created_at, updated_at
+        FROM sync_conflicts
+        WHERE id = ?
+        LIMIT 1;
+        `,
+      )
+      .get(conflictId) as ConflictRow | null;
+
+    if (!conflict) {
+      throw new Error(`Conflict '${conflictId}' not found.`);
+    }
+
+    const event = storage.db
+      .query(
+        `
+        SELECT id, operation, payload, git_branch, git_head, created_at
+        FROM events
+        WHERE id = ?
+        LIMIT 1;
+        `,
+      )
+      .get(conflict.event_id) as
+      | {
+          id: string;
+          operation: string;
+          payload: string;
+          git_branch: string | null;
+          git_head: string | null;
+          created_at: number;
+        }
+      | null;
+
+    return {
+      id: conflict.id,
+      eventId: conflict.event_id,
+      entityKind: conflict.entity_kind,
+      entityId: conflict.entity_id,
+      fieldName: conflict.field_name,
+      oursValue: parseConflictValue(conflict.ours_value),
+      theirsValue: parseConflictValue(conflict.theirs_value),
+      resolution: conflict.resolution,
+      createdAt: conflict.created_at,
+      updatedAt: conflict.updated_at,
+      event,
+    };
+  } finally {
+    storage.close();
+  }
+}
+
 export function syncResolve(cwd: string, conflictId: string, resolution: SyncResolution): ResolveSummary {
   const storage = openTrekoonDatabase(cwd);
   const git = resolveGitContext(cwd);
@@ -614,7 +958,7 @@ export function syncResolve(cwd: string, conflictId: string, resolution: SyncRes
     const conflict = storage.db
       .query(
         `
-        SELECT id, event_id, entity_kind, entity_id, field_name, ours_value, theirs_value, resolution
+        SELECT id, event_id, entity_kind, entity_id, field_name, ours_value, theirs_value, resolution, created_at, updated_at
         FROM sync_conflicts
         WHERE id = ?
         LIMIT 1;