trekoon 0.1.4 → 0.1.6

package/src/commands/subtask.ts

@@ -1,7 +1,8 @@
-import { hasFlag, parseArgs, readEnumOption, readMissingOptionValue, readOption } from "./arg-parser";
+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";
@@ -12,6 +13,8 @@ function formatSubtask(subtask: SubtaskRecord): string {
 }
 
 const VIEW_MODES = ["table", "compact"] as const;
+const DEFAULT_SUBTASK_LIST_LIMIT = 10;
+const DEFAULT_OPEN_SUBTASK_STATUSES = ["in_progress", "in-progress", "todo"] as const;
 
 function parseIdsOption(rawIds: string | undefined): string[] {
   if (rawIds === undefined) {
@@ -24,6 +27,45 @@ function parseIdsOption(rawIds: string | undefined): string[] {
     .filter((value) => value.length > 0);
 }
 
+function parseStatusCsv(rawStatuses: string | undefined): string[] | undefined {
+  if (rawStatuses === undefined) {
+    return undefined;
+  }
+
+  return rawStatuses
+    .split(",")
+    .map((value) => value.trim())
+    .filter((value) => value.length > 0);
+}
+
+function subtaskStatusPriority(status: string): number {
+  if (status === "in_progress" || status === "in-progress") {
+    return 0;
+  }
+
+  if (status === "todo") {
+    return 1;
+  }
+
+  return 2;
+}
+
+function filterSortAndLimitSubtasks(
+  subtasks: readonly SubtaskRecord[],
+  statuses: readonly string[] | undefined,
+  limit: number | undefined,
+): SubtaskRecord[] {
+  const allowedStatuses = statuses === undefined ? undefined : new Set(statuses);
+  const filtered = allowedStatuses === undefined ? [...subtasks] : subtasks.filter((subtask) => allowedStatuses.has(subtask.status));
+  const sorted = [...filtered].sort((left, right) => subtaskStatusPriority(left.status) - subtaskStatusPriority(right.status));
+
+  if (limit === undefined) {
+    return sorted;
+  }
+
+  return sorted.slice(0, limit);
+}
+
 function appendLine(existing: string, line: string): string {
   return existing.length > 0 ? `${existing}\n${line}` : line;
 }
@@ -85,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": {
@@ -100,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,
@@ -116,6 +159,8 @@ export async function runSubtask(context: CliContext): Promise<CliResult> {
       case "list": {
         const missingListOption =
           readMissingOptionValue(parsed.missingOptionValues, "view") ??
+          readMissingOptionValue(parsed.missingOptionValues, "status", "s") ??
+          readMissingOptionValue(parsed.missingOptionValues, "limit", "l") ??
           readMissingOptionValue(parsed.missingOptionValues, "task", "t");
         if (missingListOption !== undefined) {
           return failMissingOptionValue("subtask.list", missingListOption);
@@ -123,6 +168,10 @@ export async function runSubtask(context: CliContext): Promise<CliResult> {
 
         const rawView: string | undefined = readOption(parsed.options, "view");
         const view = readEnumOption(parsed.options, VIEW_MODES, "view");
+        const includeAll = hasFlag(parsed.flags, "all");
+        const rawStatuses = readOption(parsed.options, "status", "s");
+        const rawLimit = readOption(parsed.options, "limit", "l");
+
         if (rawView !== undefined && view === undefined) {
           return failResult({
             command: "subtask.list",
@@ -135,8 +184,64 @@ export async function runSubtask(context: CliContext): Promise<CliResult> {
           });
         }
 
+        if (includeAll && rawStatuses !== undefined) {
+          return failResult({
+            command: "subtask.list",
+            human: "Use either --all or --status, not both.",
+            data: { code: "invalid_input", flags: ["all", "status"] },
+            error: {
+              code: "invalid_input",
+              message: "--all and --status are mutually exclusive",
+            },
+          });
+        }
+
+        if (includeAll && rawLimit !== undefined) {
+          return failResult({
+            command: "subtask.list",
+            human: "Use either --all or --limit, not both.",
+            data: { code: "invalid_input", flags: ["all", "limit"] },
+            error: {
+              code: "invalid_input",
+              message: "--all and --limit are mutually exclusive",
+            },
+          });
+        }
+
+        const statuses = parseStatusCsv(rawStatuses);
+        if (rawStatuses !== undefined && statuses !== undefined && statuses.length === 0) {
+          return failResult({
+            command: "subtask.list",
+            human: "Provide at least one status with --status.",
+            data: { code: "invalid_input", status: rawStatuses },
+            error: {
+              code: "invalid_input",
+              message: "Invalid --status value",
+            },
+          });
+        }
+
+        const parsedLimit = parseStrictPositiveInt(rawLimit);
+        if (Number.isNaN(parsedLimit)) {
+          return failResult({
+            command: "subtask.list",
+            human: "Invalid --limit value. Use an integer >= 1.",
+            data: { code: "invalid_input", limit: rawLimit },
+            error: {
+              code: "invalid_input",
+              message: "Invalid --limit value",
+            },
+          });
+        }
+
         const taskId: string | undefined = readOption(parsed.options, "task", "t") ?? parsed.positional[1];
-        const subtasks = domain.listSubtasks(taskId);
+        const selectedStatuses = includeAll
+          ? undefined
+          : statuses ?? [...DEFAULT_OPEN_SUBTASK_STATUSES];
+        const selectedLimit = includeAll
+          ? undefined
+          : parsedLimit ?? DEFAULT_SUBTASK_LIST_LIMIT;
+        const subtasks = filterSortAndLimitSubtasks(domain.listSubtasks(taskId), selectedStatuses, selectedLimit);
         const listView = view ?? "table";
         const human =
           subtasks.length === 0
@@ -234,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),
             }),
@@ -267,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",
@@ -277,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];
 
@@ -95,6 +139,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,
+    });
+  }
+}