trekoon 0.2.0 → 0.2.1

package/src/domain/tracker-domain.ts

@@ -3,6 +3,14 @@ import { randomUUID } from "node:crypto";
 import { Database } from "bun:sqlite";
 
 import {
+  type CompactEpicExpandResult,
+  type CompactDependencyBatchAddResult,
+  type CompactDependencySpec,
+  type CompactEntityRef,
+  type CompactSubtaskBatchCreateResult,
+  type CompactSubtaskSpec,
+  type CompactTaskBatchCreateResult,
+  type CompactTaskSpec,
   type DependencyRecord,
   DomainError,
   type EpicTreeDetailed,
@@ -62,6 +70,47 @@ interface UnresolvedDependencyBlocker {
   readonly status: string;
 }
 
+interface ValidatedTaskBatchSpec {
+  readonly tempKey: string;
+  readonly title: string;
+  readonly description: string;
+  readonly status: string;
+}
+
+interface ValidatedSubtaskBatchSpec {
+  readonly tempKey: string;
+  readonly taskId: string;
+  readonly title: string;
+  readonly description: string;
+  readonly status: string;
+}
+
+interface ResolvedDependencyBatchSpec {
+  readonly index: number;
+  readonly sourceId: string;
+  readonly sourceKind: "task" | "subtask";
+  readonly dependsOnId: string;
+  readonly dependsOnKind: "task" | "subtask";
+}
+
+interface DependencyBatchValidationIssue {
+  readonly index: number;
+  readonly type: "missing_id" | "duplicate" | "cycle";
+  readonly sourceId: string;
+  readonly dependsOnId: string;
+  readonly details: Record<string, unknown>;
+}
+
+interface DependencyBatchResolution {
+  readonly spec?: ResolvedDependencyBatchSpec;
+  readonly issues: readonly DependencyBatchValidationIssue[];
+}
+
+interface ResolvedCompactEntity {
+  readonly id: string;
+  readonly kind: "task" | "subtask";
+}
+
 function assertNonEmpty(field: string, value: string | undefined | null): string {
   const normalized: string = (value ?? "").trim();
   if (!normalized) {
@@ -271,6 +320,43 @@ export class TrackerDomain {
     return this.getTaskOrThrow(id);
   }
 
+  createTaskBatch(input: { epicId: string; specs: readonly CompactTaskSpec[] }): CompactTaskBatchCreateResult {
+    const epicId: string = assertNonEmpty("epicId", input.epicId);
+    this.getEpicOrThrow(epicId);
+
+    const validatedSpecs: ValidatedTaskBatchSpec[] = input.specs.map((spec) => ({
+      tempKey: assertNonEmpty("tempKey", spec.tempKey),
+      title: assertNonEmpty("title", spec.title),
+      description: assertNonEmpty("description", spec.description),
+      status: normalizeStatus(spec.status),
+    }));
+
+    const tasks: TaskRecord[] = [];
+    for (const spec of validatedSpecs) {
+      const now: number = Date.now();
+      const id: string = randomUUID();
+
+      this.#db
+        .query(
+          "INSERT INTO tasks (id, epic_id, title, description, status, created_at, updated_at, version) VALUES (?, ?, ?, ?, ?, ?, ?, 1);",
+        )
+        .run(id, epicId, spec.title, spec.description, spec.status, now, now);
+
+      tasks.push(this.getTaskOrThrow(id));
+    }
+
+    return {
+      tasks,
+      result: {
+        mappings: tasks.map((task, index) => ({
+          kind: "task",
+          tempKey: validatedSpecs[index]?.tempKey ?? "",
+          id: task.id,
+        })),
+      },
+    };
+  }
+
   listTasks(epicId?: string): readonly TaskRecord[] {
     if (epicId) {
       this.getEpicOrThrow(epicId);
@@ -353,6 +439,89 @@ export class TrackerDomain {
     return this.getSubtaskOrThrow(id);
   }
 
+  createSubtaskBatch(input: { taskId: string; specs: readonly CompactSubtaskSpec[] }): CompactSubtaskBatchCreateResult {
+    const defaultTaskId: string = assertNonEmpty("taskId", input.taskId);
+    this.getTaskOrThrow(defaultTaskId);
+
+    const validatedSpecs: ValidatedSubtaskBatchSpec[] = input.specs.map((spec) => {
+      const taskId = spec.parent.kind === "id" ? assertNonEmpty("taskId", spec.parent.id) : defaultTaskId;
+      this.getTaskOrThrow(taskId);
+
+      return {
+        tempKey: assertNonEmpty("tempKey", spec.tempKey),
+        taskId,
+        title: assertNonEmpty("title", spec.title),
+        description: spec.description === undefined ? "" : assertNonEmpty("description", spec.description),
+        status: normalizeStatus(spec.status),
+      };
+    });
+
+    const subtasks: SubtaskRecord[] = [];
+    for (const spec of validatedSpecs) {
+      const now: number = Date.now();
+      const id: string = randomUUID();
+
+      this.#db
+        .query(
+          "INSERT INTO subtasks (id, task_id, title, description, status, created_at, updated_at, version) VALUES (?, ?, ?, ?, ?, ?, ?, 1);",
+        )
+        .run(id, spec.taskId, spec.title, spec.description, spec.status, now, now);
+
+      subtasks.push(this.getSubtaskOrThrow(id));
+    }
+
+    return {
+      subtasks,
+      result: {
+        mappings: subtasks.map((subtask, index) => ({
+          kind: "subtask",
+          tempKey: validatedSpecs[index]?.tempKey ?? "",
+          id: subtask.id,
+        })),
+      },
+    };
+  }
+
+  expandEpic(input: {
+    epicId: string;
+    taskSpecs: readonly CompactTaskSpec[];
+    subtaskSpecs: readonly CompactSubtaskSpec[];
+    dependencySpecs: readonly CompactDependencySpec[];
+  }): CompactEpicExpandResult {
+    const createdTasks = this.createTaskBatch({
+      epicId: input.epicId,
+      specs: input.taskSpecs,
+    });
+
+    const resolvedSubtaskSpecs = this.#resolveEpicExpandSubtaskSpecs(input.subtaskSpecs, createdTasks.result.mappings);
+    const createdSubtasks = resolvedSubtaskSpecs.length === 0
+      ? { subtasks: [], result: { mappings: [] } }
+      : this.createSubtaskBatch({
+          taskId: resolvedSubtaskSpecs[0]?.parent.kind === "id" ? resolvedSubtaskSpecs[0].parent.id : "",
+          specs: resolvedSubtaskSpecs,
+        });
+
+    const mappings = [...createdTasks.result.mappings, ...createdSubtasks.result.mappings];
+    const resolvedDependencySpecs = this.#resolveEpicExpandDependencySpecs(input.dependencySpecs, mappings);
+    const createdDependencies = resolvedDependencySpecs.length === 0
+      ? { dependencies: [], result: { mappings: [] } }
+      : this.addDependencyBatch({ specs: resolvedDependencySpecs });
+
+    return {
+      tasks: createdTasks.tasks,
+      subtasks: createdSubtasks.subtasks,
+      dependencies: createdDependencies.dependencies,
+      result: {
+        mappings,
+        counts: {
+          tasks: createdTasks.tasks.length,
+          subtasks: createdSubtasks.subtasks.length,
+          dependencies: createdDependencies.dependencies.length,
+        },
+      },
+    };
+  }
+
   listSubtasks(taskId?: string): readonly SubtaskRecord[] {
     if (taskId) {
       this.getTaskOrThrow(taskId);
@@ -633,6 +802,54 @@ export class TrackerDomain {
     return this.getDependencyOrThrow(id);
   }
 
+  addDependencyBatch(input: { specs: readonly CompactDependencySpec[] }): CompactDependencyBatchAddResult {
+    const resolutions = input.specs.map((spec, index) => this.#resolveDependencyBatchSpec(index, spec));
+    const resolvedSpecs = resolutions.flatMap((resolution) => (resolution.spec === undefined ? [] : [resolution.spec]));
+    const issues = resolutions.flatMap((resolution) => resolution.issues).concat(this.#collectDependencyBatchIssues(resolvedSpecs));
+    if (issues.length > 0) {
+      const orderedIssues = issues.sort((left, right) => left.index - right.index || left.type.localeCompare(right.type));
+      const firstIssue = orderedIssues[0] ?? null;
+      throw new DomainError({
+        code: "invalid_dependency",
+        message:
+          firstIssue?.type === "missing_id"
+            ? "dependency batch contains missing ids"
+            : firstIssue?.type === "duplicate"
+              ? "dependency batch contains duplicate edges"
+              : "dependency batch contains cycles",
+        details: {
+          issues: orderedIssues,
+          firstIssue,
+        },
+      });
+    }
+
+    const dependencies: DependencyRecord[] = [];
+    for (const spec of resolvedSpecs) {
+      const existing = this.#getDependencyByEdge(spec.sourceId, spec.dependsOnId);
+      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);
+
+      dependencies.push(this.getDependencyOrThrow(id));
+    }
+
+    return {
+      dependencies,
+      result: { mappings: [] },
+    };
+  }
+
   removeDependency(sourceId: string, dependsOnId: string): number {
     const normalizedSourceId: string = assertNonEmpty("sourceId", sourceId);
     const normalizedDependsOnId: string = assertNonEmpty("dependsOnId", dependsOnId);
@@ -707,6 +924,292 @@ export class TrackerDomain {
     return mapDependency(row);
   }
 
+  #getDependencyByEdge(sourceId: string, dependsOnId: string): DependencyRecord | null {
+    const row = 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 = ?;",
+      )
+      .get(sourceId, dependsOnId) as DependencyRow | null;
+
+    return row ? mapDependency(row) : null;
+  }
+
+  #resolveDependencyBatchSpec(index: number, spec: CompactDependencySpec): DependencyBatchResolution {
+    const sourceResolution = this.#resolveDependencyBatchId(spec.source, "source", index);
+    const dependsOnResolution = this.#resolveDependencyBatchId(spec.dependsOn, "dependsOn", index);
+    const issues = [...sourceResolution.issues, ...dependsOnResolution.issues];
+    const sourceId = sourceResolution.id;
+    const dependsOnId = dependsOnResolution.id;
+
+    if (sourceId === undefined || dependsOnId === undefined) {
+      return {
+        issues,
+      };
+    }
+
+    if (sourceId === dependsOnId) {
+      return {
+        issues: [
+          ...issues,
+          {
+            index,
+            type: "cycle",
+            sourceId,
+            dependsOnId,
+            details: { sourceId, dependsOnId, reason: "self_reference" },
+          },
+        ],
+      };
+    }
+
+    return {
+      spec: {
+        index,
+        sourceId,
+        sourceKind: this.resolveNodeKind(sourceId),
+        dependsOnId,
+        dependsOnKind: this.resolveNodeKind(dependsOnId),
+      },
+      issues,
+    };
+  }
+
+  #resolveDependencyBatchId(
+    reference: CompactEntityRef,
+    field: "source" | "dependsOn",
+    index: number,
+  ): { readonly id?: string; readonly issues: readonly DependencyBatchValidationIssue[] } {
+    if (reference.kind === "temp_key") {
+      return {
+        issues: [
+          {
+            index,
+            type: "missing_id",
+            sourceId: field === "source" ? `@${reference.tempKey}` : "",
+            dependsOnId: field === "dependsOn" ? `@${reference.tempKey}` : "",
+            details: {
+              field,
+              tempKey: reference.tempKey,
+              message: `Unresolved temp key @${reference.tempKey}`,
+            },
+          },
+        ],
+      };
+    }
+
+    const id = assertNonEmpty(field === "source" ? "sourceId" : "dependsOnId", reference.id);
+    const task = this.getTask(id);
+    const subtask = this.getSubtask(id);
+    if (!task && !subtask) {
+      return {
+        issues: [
+          {
+            index,
+            type: "missing_id",
+            sourceId: field === "source" ? id : "",
+            dependsOnId: field === "dependsOn" ? id : "",
+            details: {
+              field,
+              id,
+              message: `Node not found: ${id}`,
+            },
+          },
+        ],
+      };
+    }
+
+    return { id, issues: [] };
+  }
+
+  #resolveEpicExpandSubtaskSpecs(
+    specs: readonly CompactSubtaskSpec[],
+    mappings: readonly { tempKey: string; id: string; kind: "task" | "subtask" }[],
+  ): CompactSubtaskSpec[] {
+    return specs.map((spec, index) => {
+      const parent = this.#resolveEpicExpandEntityRef(spec.parent, mappings, "subtask", index, "parent");
+      if (parent.kind !== "task") {
+        throw new DomainError({
+          code: "invalid_input",
+          message: `Subtask parent must resolve to a task in --subtask spec ${index + 1}`,
+          details: {
+            index,
+            field: "parent",
+            kind: parent.kind,
+            id: parent.id,
+          },
+        });
+      }
+
+      return {
+        ...spec,
+        parent: {
+          kind: "id",
+          id: parent.id,
+        },
+      };
+    });
+  }
+
+  #resolveEpicExpandDependencySpecs(
+    specs: readonly CompactDependencySpec[],
+    mappings: readonly { tempKey: string; id: string; kind: "task" | "subtask" }[],
+  ): CompactDependencySpec[] {
+    return specs.map((spec, index) => ({
+      source: {
+        kind: "id",
+        id: this.#resolveEpicExpandEntityRef(spec.source, mappings, "dep", index, "source").id,
+      },
+      dependsOn: {
+        kind: "id",
+        id: this.#resolveEpicExpandEntityRef(spec.dependsOn, mappings, "dep", index, "dependsOn").id,
+      },
+    }));
+  }
+
+  #resolveEpicExpandEntityRef(
+    reference: CompactEntityRef,
+    mappings: readonly { tempKey: string; id: string; kind: "task" | "subtask" }[],
+    option: "subtask" | "dep",
+    index: number,
+    field: "parent" | "source" | "dependsOn",
+  ): ResolvedCompactEntity {
+    if (reference.kind === "temp_key") {
+      const mapping = mappings.find((candidate) => candidate.tempKey === reference.tempKey);
+      if (mapping === undefined) {
+        throw new DomainError({
+          code: "invalid_input",
+          message: `Unknown temp key @${reference.tempKey} in --${option} spec ${index + 1}`,
+          details: {
+            index,
+            field,
+            tempKey: reference.tempKey,
+            option,
+          },
+        });
+      }
+
+      return {
+        id: mapping.id,
+        kind: mapping.kind,
+      };
+    }
+
+    const id = assertNonEmpty(field === "parent" ? "taskId" : `${field}Id`, reference.id);
+    return {
+      id,
+      kind: this.resolveNodeKind(id),
+    };
+  }
+
+  #collectDependencyBatchIssues(specs: readonly ResolvedDependencyBatchSpec[]): DependencyBatchValidationIssue[] {
+    const issues: DependencyBatchValidationIssue[] = [];
+    const seenEdges = new Map<string, number>();
+    const adjacency = this.#buildDependencyAdjacency();
+
+    for (const spec of specs) {
+      const edgeKey = `${spec.sourceId}->${spec.dependsOnId}`;
+      const existingIndex = seenEdges.get(edgeKey);
+      if (existingIndex !== undefined) {
+        issues.push({
+          index: spec.index,
+          type: "duplicate",
+          sourceId: spec.sourceId,
+          dependsOnId: spec.dependsOnId,
+          details: {
+            sourceId: spec.sourceId,
+            dependsOnId: spec.dependsOnId,
+            firstIndex: existingIndex,
+            duplicateIndex: spec.index,
+            duplicateKind: "batch",
+          },
+        });
+        continue;
+      }
+
+      if (this.#getDependencyByEdge(spec.sourceId, spec.dependsOnId) !== null) {
+        issues.push({
+          index: spec.index,
+          type: "duplicate",
+          sourceId: spec.sourceId,
+          dependsOnId: spec.dependsOnId,
+          details: {
+            sourceId: spec.sourceId,
+            dependsOnId: spec.dependsOnId,
+            duplicateKind: "existing",
+          },
+        });
+        continue;
+      }
+
+      if (this.#wouldCreateCycleInAdjacency(adjacency, spec.sourceId, spec.dependsOnId)) {
+        issues.push({
+          index: spec.index,
+          type: "cycle",
+          sourceId: spec.sourceId,
+          dependsOnId: spec.dependsOnId,
+          details: {
+            sourceId: spec.sourceId,
+            dependsOnId: spec.dependsOnId,
+          },
+        });
+        continue;
+      }
+
+      const nextNeighbors = adjacency.get(spec.sourceId) ?? new Set<string>();
+      nextNeighbors.add(spec.dependsOnId);
+      adjacency.set(spec.sourceId, nextNeighbors);
+      seenEdges.set(edgeKey, spec.index);
+    }
+
+    return issues.sort((left, right) => left.index - right.index || left.type.localeCompare(right.type));
+  }
+
+  #buildDependencyAdjacency(): Map<string, Set<string>> {
+    const rows = this.#db.query("SELECT source_id, depends_on_id FROM dependencies ORDER BY source_id ASC, depends_on_id ASC;").all() as Array<{
+      source_id: string;
+      depends_on_id: string;
+    }>;
+    const adjacency = new Map<string, Set<string>>();
+
+    for (const row of rows) {
+      const neighbors = adjacency.get(row.source_id) ?? new Set<string>();
+      neighbors.add(row.depends_on_id);
+      adjacency.set(row.source_id, neighbors);
+    }
+
+    return adjacency;
+  }
+
+  #wouldCreateCycleInAdjacency(adjacency: ReadonlyMap<string, ReadonlySet<string>>, sourceId: string, dependsOnId: string): boolean {
+    const visited = new Set<string>();
+    const queue: string[] = [dependsOnId];
+
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (current === undefined || visited.has(current)) {
+        continue;
+      }
+
+      if (current === sourceId) {
+        return true;
+      }
+
+      visited.add(current);
+      const neighbors = adjacency.get(current);
+      if (neighbors === undefined) {
+        continue;
+      }
+
+      for (const neighbor of neighbors) {
+        if (!visited.has(neighbor)) {
+          queue.push(neighbor);
+        }
+      }
+    }
+
+    return false;
+  }
+
   private collectSearchMatches(
     nodes: readonly SearchNode[],
     searchText: string,

package/src/domain/types.ts

@@ -1,5 +1,85 @@
 export type NodeKind = "epic" | "task" | "subtask";
 
+export const COMPACT_TEMP_KEY_PREFIX = "@";
+
+export type CompactTempKey = string;
+
+export interface CompactTempKeyRef {
+  readonly kind: "temp_key";
+  readonly tempKey: CompactTempKey;
+}
+
+export interface CompactEntityIdRef {
+  readonly kind: "id";
+  readonly id: string;
+}
+
+export type CompactEntityRef = CompactTempKeyRef | CompactEntityIdRef;
+
+export interface CompactTaskSpec {
+  readonly tempKey: CompactTempKey;
+  readonly title: string;
+  readonly description: string;
+  readonly status?: string;
+}
+
+export interface CompactSubtaskSpec {
+  readonly parent: CompactEntityRef;
+  readonly tempKey: CompactTempKey;
+  readonly title: string;
+  readonly description: string;
+  readonly status?: string;
+}
+
+export interface CompactDependencySpec {
+  readonly source: CompactEntityRef;
+  readonly dependsOn: CompactEntityRef;
+}
+
+export interface CompactTempKeyMapping<TKind extends Extract<NodeKind, "task" | "subtask"> = Extract<NodeKind, "task" | "subtask">> {
+  readonly kind: TKind;
+  readonly tempKey: CompactTempKey;
+  readonly id: string;
+}
+
+export interface CompactBatchResultContract {
+  readonly mappings: ReadonlyArray<CompactTempKeyMapping>;
+}
+
+export interface CompactTaskBatchCreateResult {
+  readonly tasks: ReadonlyArray<TaskRecord>;
+  readonly result: CompactBatchResultContract;
+}
+
+export interface CompactSubtaskBatchCreateResult {
+  readonly subtasks: ReadonlyArray<SubtaskRecord>;
+  readonly result: CompactBatchResultContract;
+}
+
+export interface CompactDependencyBatchAddResult {
+  readonly dependencies: ReadonlyArray<DependencyRecord>;
+  readonly result: CompactBatchResultContract;
+}
+
+export interface CompactBatchCounts {
+  readonly tasks: number;
+  readonly subtasks: number;
+  readonly dependencies: number;
+}
+
+export interface CompactEpicExpandResult {
+  readonly tasks: ReadonlyArray<TaskRecord>;
+  readonly subtasks: ReadonlyArray<SubtaskRecord>;
+  readonly dependencies: ReadonlyArray<DependencyRecord>;
+  readonly result: CompactBatchResultContract & {
+    readonly counts: CompactBatchCounts;
+  };
+}
+
+export interface CompactEpicCreateResult extends CompactEpicExpandResult {
+  readonly epic: EpicRecord;
+}
+
 export interface EpicRecord {
   readonly id: string;
   readonly title: string;

package/src/sync/service.ts

@@ -401,6 +401,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 +515,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 +641,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(
     `
@@ -727,11 +765,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 +783,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;