trekoon 0.1.5 → 0.1.7

package/src/commands/subtask.ts

@@ -1,7 +1,8 @@
 import { hasFlag, parseArgs, parseStrictPositiveInt, readEnumOption, readMissingOptionValue, readOption } from "./arg-parser";
 
-import { DomainError, type SubtaskRecord } from "../domain/types";
+import { MutationService } from "../domain/mutation-service";
 import { TrackerDomain } from "../domain/tracker-domain";
+import { DomainError, type SubtaskRecord } from "../domain/types";
 import { formatHumanTable } from "../io/human-table";
 import { failResult, okResult } from "../io/output";
 import { type CliContext, type CliResult } from "../runtime/command-types";
@@ -126,6 +127,7 @@ export async function runSubtask(context: CliContext): Promise<CliResult> {
     const parsed = parseArgs(context.args);
     const subcommand: string | undefined = parsed.positional[0];
     const domain = new TrackerDomain(database.db);
+    const mutations = new MutationService(database.db, context.cwd);
 
     switch (subcommand) {
       case "create": {
@@ -141,7 +143,7 @@ export async function runSubtask(context: CliContext): Promise<CliResult> {
         const title: string | undefined = readOption(parsed.options, "title") ?? parsed.positional[2];
         const description: string | undefined = readOption(parsed.options, "description", "d");
         const status: string | undefined = readOption(parsed.options, "status", "s");
-        const subtask = domain.createSubtask({
+        const subtask = mutations.createSubtask({
           taskId: taskId ?? "",
           title: title ?? "",
           description,
@@ -337,7 +339,7 @@ export async function runSubtask(context: CliContext): Promise<CliResult> {
 
           const targets = updateAll ? [...domain.listSubtasks()] : ids.map((id) => domain.getSubtaskOrThrow(id));
           const subtasks = targets.map((target) =>
-            domain.updateSubtask(target.id, {
+            mutations.updateSubtask(target.id, {
               status,
               description: append === undefined ? undefined : appendLine(target.description, append),
             }),
@@ -370,7 +372,7 @@ export async function runSubtask(context: CliContext): Promise<CliResult> {
           append === undefined
             ? description
             : appendLine(domain.getSubtaskOrThrow(subtaskId).description, append);
-        const subtask = domain.updateSubtask(subtaskId, { title, description: nextDescription, status });
+        const subtask = mutations.updateSubtask(subtaskId, { title, description: nextDescription, status });
 
         return okResult({
           command: "subtask.update",
@@ -380,7 +382,7 @@ export async function runSubtask(context: CliContext): Promise<CliResult> {
       }
       case "delete": {
         const subtaskId: string = parsed.positional[1] ?? "";
-        domain.deleteSubtask(subtaskId);
+        mutations.deleteSubtask(subtaskId);
 
         return okResult({
           command: "subtask.delete",

package/src/commands/sync.ts

@@ -1,8 +1,8 @@
 import { failResult, okResult } from "../io/output";
 import { type CliContext, type CliResult } from "../runtime/command-types";
 import { MissingBranchDatabaseError } from "../sync/branch-db";
-import { syncPull, syncResolve, syncStatus } from "../sync/service";
-import { type SyncResolution } from "../sync/types";
+import { getSyncConflict, listSyncConflicts, syncPull, syncResolve, syncStatus } from "../sync/service";
+import { type SyncConflictMode, type SyncResolution } from "../sync/types";
 
 function parseOption(args: readonly string[], option: string): string | null {
   const index: number = args.indexOf(option);
@@ -17,7 +17,7 @@ function parseOption(args: readonly string[], option: string): string | null {
 function usage(message: string): CliResult {
   return failResult({
     command: "sync",
-    human: `${message}\nUsage: trekoon sync <status|pull|resolve> [options]`,
+    human: `${message}\nUsage: trekoon sync <status|pull|resolve|conflicts> [options]`,
     data: { message },
     error: {
       code: "invalid_args",
@@ -35,6 +35,50 @@ function statusMessage(sourceBranch: string, ahead: number, behind: number, conf
   ].join("\n");
 }
 
+function formatConflictList(
+  conflicts: ReadonlyArray<{
+    id: string;
+    entity_kind: string;
+    entity_id: string;
+    field_name: string;
+    resolution: string;
+  }>,
+): string {
+  if (conflicts.length === 0) {
+    return "No conflicts found.";
+  }
+
+  return conflicts
+    .map((conflict) =>
+      [
+        conflict.id,
+        conflict.entity_kind,
+        conflict.entity_id,
+        conflict.field_name,
+        conflict.resolution,
+      ].join(" | "),
+    )
+    .join("\n");
+}
+
+function parseConflictMode(args: readonly string[]): SyncConflictMode | null {
+  const modeIndex = args.indexOf("--mode");
+  if (modeIndex < 0) {
+    return "pending";
+  }
+
+  const explicitMode = args[modeIndex + 1];
+  if (!explicitMode || explicitMode.startsWith("--")) {
+    return null;
+  }
+
+  if (explicitMode === "pending" || explicitMode === "all") {
+    return explicitMode;
+  }
+
+  return null;
+}
+
 export async function runSync(context: CliContext): Promise<CliResult> {
   const subcommand: string | undefined = context.args[0];
 
@@ -69,6 +113,10 @@ export async function runSync(context: CliContext): Promise<CliResult> {
           `Scanned events: ${summary.scannedEvents}`,
           `Applied events: ${summary.appliedEvents}`,
           `Created conflicts: ${summary.createdConflicts}`,
+          `Malformed payloads: ${summary.diagnostics.malformedPayloadEvents}`,
+          `Quarantined events: ${summary.diagnostics.quarantinedEvents}`,
+          `Conflict events: ${summary.diagnostics.conflictEvents}`,
+          ...summary.diagnostics.errorHints,
         ].join("\n"),
         data: summary,
       });
@@ -95,6 +143,57 @@ export async function runSync(context: CliContext): Promise<CliResult> {
       });
     }
 
+    if (subcommand === "conflicts") {
+      const conflictsCommand: string | undefined = context.args[1];
+      if (!conflictsCommand) {
+        return usage("sync conflicts requires list|show.");
+      }
+
+      if (conflictsCommand === "list") {
+        const mode = parseConflictMode(context.args);
+        if (!mode) {
+          return usage("sync conflicts list --mode only accepts pending|all.");
+        }
+
+        const conflicts = listSyncConflicts(context.cwd, mode);
+
+        return okResult({
+          command: "sync conflicts list",
+          human: formatConflictList(conflicts),
+          data: {
+            mode,
+            conflicts,
+          },
+        });
+      }
+
+      if (conflictsCommand === "show") {
+        const conflictId: string | undefined = context.args[2];
+        if (!conflictId) {
+          return usage("sync conflicts show requires <conflict-id>.");
+        }
+
+        const conflict = getSyncConflict(context.cwd, conflictId);
+
+        return okResult({
+          command: "sync conflicts show",
+          human: [
+            `Conflict: ${conflict.id}`,
+            `Entity: ${conflict.entityKind} ${conflict.entityId}`,
+            `Field: ${conflict.fieldName}`,
+            `Resolution: ${conflict.resolution}`,
+            `Ours: ${JSON.stringify(conflict.oursValue)}`,
+            `Theirs: ${JSON.stringify(conflict.theirsValue)}`,
+          ].join("\n"),
+          data: {
+            conflict,
+          },
+        });
+      }
+
+      return usage(`Unknown sync conflicts subcommand '${conflictsCommand}'.`);
+    }
+
     return usage(`Unknown sync subcommand '${subcommand}'.`);
   } catch (error) {
     if (error instanceof MissingBranchDatabaseError) {

package/src/commands/task.ts

@@ -1,7 +1,8 @@
 import { hasFlag, parseArgs, parseStrictPositiveInt, readEnumOption, readMissingOptionValue, readOption } from "./arg-parser";
 
-import { DomainError, type TaskRecord } from "../domain/types";
+import { MutationService } from "../domain/mutation-service";
 import { TrackerDomain } from "../domain/tracker-domain";
+import { DomainError, type TaskRecord } from "../domain/types";
 import { formatHumanTable } from "../io/human-table";
 import { failResult, okResult } from "../io/output";
 import { type CliContext, type CliResult } from "../runtime/command-types";
@@ -192,6 +193,7 @@ export async function runTask(context: CliContext): Promise<CliResult> {
     const parsed = parseArgs(context.args);
     const subcommand: string | undefined = parsed.positional[0];
     const domain = new TrackerDomain(database.db);
+    const mutations = new MutationService(database.db, context.cwd);
 
     switch (subcommand) {
       case "create": {
@@ -207,7 +209,7 @@ export async function runTask(context: CliContext): Promise<CliResult> {
         const title: string | undefined = readOption(parsed.options, "title", "t");
         const description: string | undefined = readOption(parsed.options, "description", "d");
         const status: string | undefined = readOption(parsed.options, "status", "s");
-        const task = domain.createTask({
+        const task = mutations.createTask({
           epicId: epicId ?? "",
           title: title ?? "",
           description: description ?? "",
@@ -482,7 +484,7 @@ export async function runTask(context: CliContext): Promise<CliResult> {
 
           const targets = updateAll ? [...domain.listTasks()] : ids.map((id) => domain.getTaskOrThrow(id));
           const tasks = targets.map((target) =>
-            domain.updateTask(target.id, {
+            mutations.updateTask(target.id, {
               status,
               description: append === undefined ? undefined : appendLine(target.description, append),
             }),
@@ -515,7 +517,7 @@ export async function runTask(context: CliContext): Promise<CliResult> {
           append === undefined
             ? description
             : appendLine(domain.getTaskOrThrow(taskId).description, append);
-        const task = domain.updateTask(taskId, { title, description: nextDescription, status });
+        const task = mutations.updateTask(taskId, { title, description: nextDescription, status });
 
         return okResult({
           command: "task.update",
@@ -525,7 +527,7 @@ export async function runTask(context: CliContext): Promise<CliResult> {
       }
       case "delete": {
         const taskId: string = parsed.positional[1] ?? "";
-        domain.deleteTask(taskId);
+        mutations.deleteTask(taskId);
 
         return okResult({
           command: "task.delete",

package/src/domain/mutation-operations.ts

@@ -0,0 +1,27 @@
+export const ENTITY_OPERATIONS = {
+  epic: {
+    created: "epic.created",
+    updated: "epic.updated",
+    deleted: "epic.deleted",
+  },
+  task: {
+    created: "task.created",
+    updated: "task.updated",
+    deleted: "task.deleted",
+  },
+  subtask: {
+    created: "subtask.created",
+    updated: "subtask.updated",
+    deleted: "subtask.deleted",
+  },
+  dependency: {
+    added: "dependency.added",
+    removed: "dependency.removed",
+  },
+} as const;
+
+export type MutationOperation =
+  | (typeof ENTITY_OPERATIONS)["epic"][keyof (typeof ENTITY_OPERATIONS)["epic"]]
+  | (typeof ENTITY_OPERATIONS)["task"][keyof (typeof ENTITY_OPERATIONS)["task"]]
+  | (typeof ENTITY_OPERATIONS)["subtask"][keyof (typeof ENTITY_OPERATIONS)["subtask"]]
+  | (typeof ENTITY_OPERATIONS)["dependency"][keyof (typeof ENTITY_OPERATIONS)["dependency"]];

package/src/domain/mutation-service.ts

@@ -0,0 +1,169 @@
+import { type Database } from "bun:sqlite";
+
+import { appendEventWithGitContext } from "../sync/event-writes";
+import { ENTITY_OPERATIONS } from "./mutation-operations";
+import { TrackerDomain } from "./tracker-domain";
+import { type DependencyRecord, type EpicRecord, type SubtaskRecord, type TaskRecord } from "./types";
+
+export class MutationService {
+  readonly #db: Database;
+  readonly #cwd: string;
+  readonly #domain: TrackerDomain;
+
+  constructor(db: Database, cwd: string) {
+    this.#db = db;
+    this.#cwd = cwd;
+    this.#domain = new TrackerDomain(db);
+  }
+
+  createEpic(input: { title: string; description: string; status?: string | undefined }): EpicRecord {
+    return this.#db.transaction((): EpicRecord => {
+      const epic = this.#domain.createEpic(input);
+      this.#appendEntityEvent("epic", epic.id, ENTITY_OPERATIONS.epic.created, {
+        title: epic.title,
+        description: epic.description,
+        status: epic.status,
+      });
+      return epic;
+    })();
+  }
+
+  updateEpic(
+    id: string,
+    input: { title?: string | undefined; description?: string | undefined; status?: string | undefined },
+  ): EpicRecord {
+    return this.#db.transaction((): EpicRecord => {
+      const epic = this.#domain.updateEpic(id, input);
+      this.#appendEntityEvent("epic", epic.id, ENTITY_OPERATIONS.epic.updated, {
+        title: epic.title,
+        description: epic.description,
+        status: epic.status,
+      });
+      return epic;
+    })();
+  }
+
+  deleteEpic(id: string): void {
+    this.#db.transaction((): void => {
+      this.#domain.deleteEpic(id);
+      this.#appendEntityEvent("epic", id, ENTITY_OPERATIONS.epic.deleted, {});
+    })();
+  }
+
+  createTask(input: { epicId: string; title: string; description: string; status?: string | undefined }): TaskRecord {
+    return this.#db.transaction((): TaskRecord => {
+      const task = this.#domain.createTask(input);
+      this.#appendEntityEvent("task", task.id, ENTITY_OPERATIONS.task.created, {
+        epic_id: task.epicId,
+        title: task.title,
+        description: task.description,
+        status: task.status,
+      });
+      return task;
+    })();
+  }
+
+  updateTask(
+    id: string,
+    input: { title?: string | undefined; description?: string | undefined; status?: string | undefined },
+  ): TaskRecord {
+    return this.#db.transaction((): TaskRecord => {
+      const task = this.#domain.updateTask(id, input);
+      this.#appendEntityEvent("task", task.id, ENTITY_OPERATIONS.task.updated, {
+        epic_id: task.epicId,
+        title: task.title,
+        description: task.description,
+        status: task.status,
+      });
+      return task;
+    })();
+  }
+
+  deleteTask(id: string): void {
+    this.#db.transaction((): void => {
+      this.#domain.deleteTask(id);
+      this.#appendEntityEvent("task", id, ENTITY_OPERATIONS.task.deleted, {});
+    })();
+  }
+
+  createSubtask(input: {
+    taskId: string;
+    title: string;
+    description?: string | undefined;
+    status?: string | undefined;
+  }): SubtaskRecord {
+    return this.#db.transaction((): SubtaskRecord => {
+      const subtask = this.#domain.createSubtask(input);
+      this.#appendEntityEvent("subtask", subtask.id, ENTITY_OPERATIONS.subtask.created, {
+        task_id: subtask.taskId,
+        title: subtask.title,
+        description: subtask.description,
+        status: subtask.status,
+      });
+      return subtask;
+    })();
+  }
+
+  updateSubtask(
+    id: string,
+    input: { title?: string | undefined; description?: string | undefined; status?: string | undefined },
+  ): SubtaskRecord {
+    return this.#db.transaction((): SubtaskRecord => {
+      const subtask = this.#domain.updateSubtask(id, input);
+      this.#appendEntityEvent("subtask", subtask.id, ENTITY_OPERATIONS.subtask.updated, {
+        task_id: subtask.taskId,
+        title: subtask.title,
+        description: subtask.description,
+        status: subtask.status,
+      });
+      return subtask;
+    })();
+  }
+
+  deleteSubtask(id: string): void {
+    this.#db.transaction((): void => {
+      this.#domain.deleteSubtask(id);
+      this.#appendEntityEvent("subtask", id, ENTITY_OPERATIONS.subtask.deleted, {});
+    })();
+  }
+
+  addDependency(sourceId: string, dependsOnId: string): DependencyRecord {
+    return this.#db.transaction((): DependencyRecord => {
+      const dependency = this.#domain.addDependency(sourceId, dependsOnId);
+      this.#appendEntityEvent("dependency", dependency.id, ENTITY_OPERATIONS.dependency.added, {
+        source_id: dependency.sourceId,
+        source_kind: dependency.sourceKind,
+        depends_on_id: dependency.dependsOnId,
+        depends_on_kind: dependency.dependsOnKind,
+      });
+      return dependency;
+    })();
+  }
+
+  removeDependency(sourceId: string, dependsOnId: string): number {
+    return this.#db.transaction((): number => {
+      const removed = this.#domain.removeDependency(sourceId, dependsOnId);
+      if (removed > 0) {
+        this.#appendEntityEvent("dependency", `${sourceId}->${dependsOnId}`, ENTITY_OPERATIONS.dependency.removed, {
+          source_id: sourceId,
+          depends_on_id: dependsOnId,
+        });
+      }
+      return removed;
+    })();
+  }
+
+  #appendEntityEvent(
+    entityKind: "epic" | "task" | "subtask" | "dependency",
+    entityId: string,
+    operation: string,
+    fields: Record<string, unknown>,
+  ): void {
+    appendEventWithGitContext(this.#db, this.#cwd, {
+      entityKind,
+      entityId,
+      operation,
+      fields,
+    });
+  }
+}

package/src/storage/migrations.ts

@@ -278,11 +278,58 @@ function recordMigration(db: Database, migration: Migration): void {
   );
 }
 
+function isSchemaCurrentFastPath(db: Database, latestVersion: number): boolean {
+  if (latestVersion === 0 || !migrationTableExists(db) || !hasMigrationVersionColumn(db)) {
+    return false;
+  }
+
+  const row = db
+    .query(
+      `
+      SELECT
+        COALESCE(MIN(version), 0) AS min_version,
+        COALESCE(MAX(version), 0) AS max_version,
+        COUNT(DISTINCT version) AS distinct_versions,
+        SUM(CASE WHEN version IS NULL THEN 1 ELSE 0 END) AS null_versions
+      FROM schema_migrations;
+      `,
+    )
+    .get() as
+    | {
+        min_version: number;
+        max_version: number;
+        distinct_versions: number;
+        null_versions: number;
+      }
+    | null;
+
+  if (!row) {
+    return false;
+  }
+
+  return (
+    row.null_versions === 0 &&
+    row.min_version === 1 &&
+    row.max_version === latestVersion &&
+    row.distinct_versions === latestVersion
+  );
+}
+
 export function migrateDatabase(db: Database): void {
+  validateMigrationPlan();
+
+  const latestVersion: number = MIGRATIONS[MIGRATIONS.length - 1]?.version ?? 0;
+
+  // Fast path: avoid BEGIN EXCLUSIVE when schema is already current.
+  // This reduces startup lock contention while keeping the explicit
+  // transactional migration path for non-current/legacy schemas.
+  if (isSchemaCurrentFastPath(db, latestVersion)) {
+    return;
+  }
+
   runExclusive(db, (): void => {
     ensureMigrationTable(db);
     ensureMigrationVersionColumn(db);
-    validateMigrationPlan();
 
     const version: number = currentVersion(db);