trekoon 0.1.9 → 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,
@@ -10,6 +18,11 @@ import {
   type EpicTree,
   type NodeKind,
   type ReverseDependencyNode,
+  type SearchEntityMatch,
+  type SearchField,
+  type SearchFieldMatch,
+  type SearchNode,
+  type SearchSummary,
   type SubtaskRecord,
   type TaskTreeDetailed,
   type TaskRecord,
@@ -57,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) {
@@ -125,6 +179,55 @@ function mapDependency(row: DependencyRow): DependencyRecord {
   };
 }
 
+function countMatches(value: string, searchText: string): number {
+  if (searchText.length === 0) {
+    return 0;
+  }
+
+  let count = 0;
+  let offset = 0;
+  while (offset <= value.length - searchText.length) {
+    const nextIndex = value.indexOf(searchText, offset);
+    if (nextIndex === -1) {
+      return count;
+    }
+
+    count += 1;
+    offset = nextIndex + searchText.length;
+  }
+
+  return count;
+}
+
+function buildMatchSnippet(value: string, searchText: string, contextSize = 24): string {
+  if (searchText.length === 0) {
+    return "";
+  }
+
+  const matchIndex = value.indexOf(searchText);
+  if (matchIndex === -1) {
+    return "";
+  }
+
+  const start = Math.max(0, matchIndex - contextSize);
+  const end = Math.min(value.length, matchIndex + searchText.length + contextSize);
+  const rawSnippet = value.slice(start, end).replace(/\s+/g, " ").trim();
+  const prefix = start > 0 ? "…" : "";
+  const suffix = end < value.length ? "…" : "";
+  return `${prefix}${rawSnippet}${suffix}`;
+}
+
+function summarizeMatches(matches: readonly SearchEntityMatch[]): SearchSummary {
+  return {
+    matchedEntities: matches.length,
+    matchedFields: matches.reduce((total, match) => total + match.fields.length, 0),
+    totalMatches: matches.reduce(
+      (total, match) => total + match.fields.reduce((fieldTotal, field) => fieldTotal + field.count, 0),
+      0,
+    ),
+  };
+}
+
 export class TrackerDomain {
   readonly #db: Database;
 
@@ -217,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);
@@ -299,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);
@@ -433,6 +656,89 @@ export class TrackerDomain {
     };
   }
 
+  collectEpicSearchScope(epicId: string): readonly SearchNode[] {
+    const tree = this.buildEpicTreeDetailed(epicId);
+
+    return [
+      {
+        kind: "epic",
+        id: tree.id,
+        title: tree.title,
+        description: tree.description,
+      },
+      ...tree.tasks.flatMap((task) => [
+        {
+          kind: "task" as const,
+          id: task.id,
+          title: task.title,
+          description: task.description,
+        },
+        ...task.subtasks.map((subtask) => ({
+          kind: "subtask" as const,
+          id: subtask.id,
+          title: subtask.title,
+          description: subtask.description,
+        })),
+      ]),
+    ];
+  }
+
+  collectTaskSearchScope(taskId: string): readonly SearchNode[] {
+    const tree = this.buildTaskTreeDetailed(taskId);
+
+    return [
+      {
+        kind: "task",
+        id: tree.id,
+        title: tree.title,
+        description: tree.description,
+      },
+      ...tree.subtasks.map((subtask) => ({
+        kind: "subtask" as const,
+        id: subtask.id,
+        title: subtask.title,
+        description: subtask.description,
+      })),
+    ];
+  }
+
+  collectSubtaskSearchScope(subtaskId: string): readonly SearchNode[] {
+    const subtask = this.getSubtaskOrThrow(subtaskId);
+
+    return [
+      {
+        kind: "subtask",
+        id: subtask.id,
+        title: subtask.title,
+        description: subtask.description,
+      },
+    ];
+  }
+
+  searchEpicScope(epicId: string, searchText: string, fields: readonly SearchField[]): { readonly matches: readonly SearchEntityMatch[]; readonly summary: SearchSummary } {
+    const matches = this.collectSearchMatches(this.collectEpicSearchScope(epicId), searchText, fields);
+    return {
+      matches,
+      summary: summarizeMatches(matches),
+    };
+  }
+
+  searchTaskScope(taskId: string, searchText: string, fields: readonly SearchField[]): { readonly matches: readonly SearchEntityMatch[]; readonly summary: SearchSummary } {
+    const matches = this.collectSearchMatches(this.collectTaskSearchScope(taskId), searchText, fields);
+    return {
+      matches,
+      summary: summarizeMatches(matches),
+    };
+  }
+
+  searchSubtaskScope(subtaskId: string, searchText: string, fields: readonly SearchField[]): { readonly matches: readonly SearchEntityMatch[]; readonly summary: SearchSummary } {
+    const matches = this.collectSearchMatches(this.collectSubtaskSearchScope(subtaskId), searchText, fields);
+    return {
+      matches,
+      summary: summarizeMatches(matches),
+    };
+  }
+
   resolveNodeKind(id: string): "task" | "subtask" {
     const task = this.getTask(id);
     if (task) {
@@ -496,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);
@@ -570,6 +924,326 @@ 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,
+    fields: readonly SearchField[],
+  ): readonly SearchEntityMatch[] {
+    const matches: SearchEntityMatch[] = [];
+
+    for (const node of nodes) {
+      const matchedFields: SearchFieldMatch[] = [];
+      for (const field of fields) {
+        const count = countMatches(node[field], searchText);
+        if (count > 0) {
+          matchedFields.push({
+            field,
+            count,
+            snippet: buildMatchSnippet(node[field], searchText),
+          });
+        }
+      }
+
+      if (matchedFields.length === 0) {
+        continue;
+      }
+
+      matches.push({
+        kind: node.kind,
+        id: node.id,
+        fields: matchedFields,
+      });
+    }
+
+    return matches;
+  }
+
   private wouldCreateCycle(sourceId: string, dependsOnId: string): boolean {
     const row = this.#db
       .query(