trekoon 0.1.9 → 0.2.1

package/src/domain/mutation-service.ts

@@ -3,7 +3,91 @@ 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";
+import {
+  type CompactEpicCreateResult,
+  type CompactEpicExpandResult,
+  type CompactDependencyBatchAddResult,
+  type CompactDependencySpec,
+  type CompactSubtaskBatchCreateResult,
+  type CompactSubtaskSpec,
+  type CompactTaskBatchCreateResult,
+  type CompactTaskSpec,
+  type DependencyRecord,
+  type EpicRecord,
+  type SearchEntityMatch,
+  type SearchField,
+  type SearchNode,
+  type SearchSummary,
+  type SubtaskRecord,
+  type TaskRecord,
+} from "./types";
+
+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 replaceMatches(value: string, searchText: string, replacement: string): string {
+  return searchText.length === 0 ? value : value.split(searchText).join(replacement);
+}
+
+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 buildReplacementSnippet(value: string, replacementIndex: number, replacementLength: number, contextSize = 24): string {
+  const start = Math.max(0, replacementIndex - contextSize);
+  const end = Math.min(value.length, replacementIndex + replacementLength + 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,
+    ),
+  };
+}
+
+interface ScopeReplacementResult {
+  readonly matches: readonly SearchEntityMatch[];
+  readonly summary: SearchSummary;
+}
 
 export class MutationService {
   readonly #db: Database;
@@ -28,6 +112,66 @@ export class MutationService {
     })();
   }
 
+  createEpicGraph(input: {
+    title: string;
+    description: string;
+    status?: string | undefined;
+    taskSpecs: readonly CompactTaskSpec[];
+    subtaskSpecs: readonly CompactSubtaskSpec[];
+    dependencySpecs: readonly CompactDependencySpec[];
+  }): CompactEpicCreateResult {
+    return this.#db.transaction((): CompactEpicCreateResult => {
+      const epic = this.#domain.createEpic(input);
+      const created = this.#domain.expandEpic({
+        epicId: epic.id,
+        taskSpecs: input.taskSpecs,
+        subtaskSpecs: input.subtaskSpecs,
+        dependencySpecs: input.dependencySpecs,
+      });
+
+      this.#appendEntityEvent("epic", epic.id, ENTITY_OPERATIONS.epic.created, {
+        title: epic.title,
+        description: epic.description,
+        status: epic.status,
+      });
+
+      for (const task of created.tasks) {
+        this.#appendEntityEvent("task", task.id, ENTITY_OPERATIONS.task.created, {
+          epic_id: task.epicId,
+          title: task.title,
+          description: task.description,
+          status: task.status,
+        });
+      }
+
+      for (const subtask of created.subtasks) {
+        this.#appendEntityEvent("subtask", subtask.id, ENTITY_OPERATIONS.subtask.created, {
+          task_id: subtask.taskId,
+          title: subtask.title,
+          description: subtask.description,
+          status: subtask.status,
+        });
+      }
+
+      for (const dependency of created.dependencies) {
+        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 {
+        epic,
+        tasks: created.tasks,
+        subtasks: created.subtasks,
+        dependencies: created.dependencies,
+        result: created.result,
+      };
+    })();
+  }
+
   updateEpic(
     id: string,
     input: { title?: string | undefined; description?: string | undefined; status?: string | undefined },
@@ -63,6 +207,60 @@ export class MutationService {
     })();
   }
 
+  createTaskBatch(input: { epicId: string; specs: readonly CompactTaskSpec[] }): CompactTaskBatchCreateResult {
+    return this.#db.transaction((): CompactTaskBatchCreateResult => {
+      const created = this.#domain.createTaskBatch(input);
+      for (const task of created.tasks) {
+        this.#appendEntityEvent("task", task.id, ENTITY_OPERATIONS.task.created, {
+          epic_id: task.epicId,
+          title: task.title,
+          description: task.description,
+          status: task.status,
+        });
+      }
+      return created;
+    })();
+  }
+
+  expandEpic(input: {
+    epicId: string;
+    taskSpecs: readonly CompactTaskSpec[];
+    subtaskSpecs: readonly CompactSubtaskSpec[];
+    dependencySpecs: readonly CompactDependencySpec[];
+  }): CompactEpicExpandResult {
+    return this.#db.transaction((): CompactEpicExpandResult => {
+      const created = this.#domain.expandEpic(input);
+      for (const task of created.tasks) {
+        this.#appendEntityEvent("task", task.id, ENTITY_OPERATIONS.task.created, {
+          epic_id: task.epicId,
+          title: task.title,
+          description: task.description,
+          status: task.status,
+        });
+      }
+
+      for (const subtask of created.subtasks) {
+        this.#appendEntityEvent("subtask", subtask.id, ENTITY_OPERATIONS.subtask.created, {
+          task_id: subtask.taskId,
+          title: subtask.title,
+          description: subtask.description,
+          status: subtask.status,
+        });
+      }
+
+      for (const dependency of created.dependencies) {
+        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 created;
+    })();
+  }
+
   updateTask(
     id: string,
     input: { title?: string | undefined; description?: string | undefined; status?: string | undefined },
@@ -104,6 +302,21 @@ export class MutationService {
     })();
   }
 
+  createSubtaskBatch(input: { taskId: string; specs: readonly CompactSubtaskSpec[] }): CompactSubtaskBatchCreateResult {
+    return this.#db.transaction((): CompactSubtaskBatchCreateResult => {
+      const created = this.#domain.createSubtaskBatch(input);
+      for (const subtask of created.subtasks) {
+        this.#appendEntityEvent("subtask", subtask.id, ENTITY_OPERATIONS.subtask.created, {
+          task_id: subtask.taskId,
+          title: subtask.title,
+          description: subtask.description,
+          status: subtask.status,
+        });
+      }
+      return created;
+    })();
+  }
+
   updateSubtask(
     id: string,
     input: { title?: string | undefined; description?: string | undefined; status?: string | undefined },
@@ -140,6 +353,21 @@ export class MutationService {
     })();
   }
 
+  addDependencyBatch(input: { specs: readonly CompactDependencySpec[] }): CompactDependencyBatchAddResult {
+    return this.#db.transaction((): CompactDependencyBatchAddResult => {
+      const created = this.#domain.addDependencyBatch(input);
+      for (const dependency of created.dependencies) {
+        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 created;
+    })();
+  }
+
   removeDependency(sourceId: string, dependsOnId: string): number {
     return this.#db.transaction((): number => {
       const removed = this.#domain.removeDependency(sourceId, dependsOnId);
@@ -153,6 +381,60 @@ export class MutationService {
     })();
   }
 
+  previewEpicReplacement(
+    epicId: string,
+    searchText: string,
+    replacementText: string,
+    fields: readonly SearchField[],
+  ): ScopeReplacementResult {
+    return this.#previewScopeReplacement(this.#domain.collectEpicSearchScope(epicId), searchText, replacementText, fields);
+  }
+
+  applyEpicReplacement(
+    epicId: string,
+    searchText: string,
+    replacementText: string,
+    fields: readonly SearchField[],
+  ): ScopeReplacementResult {
+    return this.#applyScopeReplacement(this.#domain.collectEpicSearchScope(epicId), searchText, replacementText, fields);
+  }
+
+  previewTaskReplacement(
+    taskId: string,
+    searchText: string,
+    replacementText: string,
+    fields: readonly SearchField[],
+  ): ScopeReplacementResult {
+    return this.#previewScopeReplacement(this.#domain.collectTaskSearchScope(taskId), searchText, replacementText, fields);
+  }
+
+  applyTaskReplacement(
+    taskId: string,
+    searchText: string,
+    replacementText: string,
+    fields: readonly SearchField[],
+  ): ScopeReplacementResult {
+    return this.#applyScopeReplacement(this.#domain.collectTaskSearchScope(taskId), searchText, replacementText, fields);
+  }
+
+  previewSubtaskReplacement(
+    subtaskId: string,
+    searchText: string,
+    replacementText: string,
+    fields: readonly SearchField[],
+  ): ScopeReplacementResult {
+    return this.#previewScopeReplacement(this.#domain.collectSubtaskSearchScope(subtaskId), searchText, replacementText, fields);
+  }
+
+  applySubtaskReplacement(
+    subtaskId: string,
+    searchText: string,
+    replacementText: string,
+    fields: readonly SearchField[],
+  ): ScopeReplacementResult {
+    return this.#applyScopeReplacement(this.#domain.collectSubtaskSearchScope(subtaskId), searchText, replacementText, fields);
+  }
+
   #appendEntityEvent(
     entityKind: "epic" | "task" | "subtask" | "dependency",
     entityId: string,
@@ -166,4 +448,115 @@ export class MutationService {
       fields,
     });
   }
+
+  #previewScopeReplacement(
+    nodes: readonly SearchNode[],
+    searchText: string,
+    replacementText: string,
+    fields: readonly SearchField[],
+  ): ScopeReplacementResult {
+    return this.#buildScopeReplacementResult(nodes, searchText, replacementText, fields);
+  }
+
+  #applyScopeReplacement(
+    nodes: readonly SearchNode[],
+    searchText: string,
+    replacementText: string,
+    fields: readonly SearchField[],
+  ): ScopeReplacementResult {
+    const result = this.#buildScopeReplacementResult(nodes, searchText, replacementText, fields, "apply");
+
+    this.#db.transaction((): void => {
+      for (const node of nodes) {
+        const nextTitle = fields.includes("title") ? replaceMatches(node.title, searchText, replacementText) : node.title;
+        const nextDescription = fields.includes("description")
+          ? replaceMatches(node.description, searchText, replacementText)
+          : node.description;
+
+        if (nextTitle === node.title && nextDescription === node.description) {
+          continue;
+        }
+
+        if (node.kind === "epic") {
+          const epic = this.#domain.updateEpic(node.id, { title: nextTitle, description: nextDescription });
+          this.#appendEntityEvent("epic", epic.id, ENTITY_OPERATIONS.epic.updated, {
+            title: epic.title,
+            description: epic.description,
+            status: epic.status,
+          });
+          continue;
+        }
+
+        if (node.kind === "task") {
+          const task = this.#domain.updateTask(node.id, { title: nextTitle, description: nextDescription });
+          this.#appendEntityEvent("task", task.id, ENTITY_OPERATIONS.task.updated, {
+            epic_id: task.epicId,
+            title: task.title,
+            description: task.description,
+            status: task.status,
+          });
+          continue;
+        }
+
+        const subtask = this.#domain.updateSubtask(node.id, { title: nextTitle, description: nextDescription });
+        this.#appendEntityEvent("subtask", subtask.id, ENTITY_OPERATIONS.subtask.updated, {
+          task_id: subtask.taskId,
+          title: subtask.title,
+          description: subtask.description,
+          status: subtask.status,
+        });
+      }
+    })();
+
+    return result;
+  }
+
+  #buildScopeReplacementResult(
+    nodes: readonly SearchNode[],
+    searchText: string,
+    replacementText: string,
+    fields: readonly SearchField[],
+    mode: "preview" | "apply" = "preview",
+  ): ScopeReplacementResult {
+    const matches: SearchEntityMatch[] = [];
+
+    for (const node of nodes) {
+      const fieldMatches = fields
+        .map((field) => {
+          const value = field === "title" ? node.title : node.description;
+          const matchIndex = value.indexOf(searchText);
+          const nextValue = replaceMatches(value, searchText, replacementText);
+          const count = nextValue === value ? 0 : countMatches(value, searchText);
+
+          if (count === 0) {
+            return null;
+          }
+
+          return {
+            field,
+            count,
+            snippet:
+              mode === "apply"
+                ? buildReplacementSnippet(nextValue, matchIndex, replacementText.length)
+                : buildMatchSnippet(value, searchText),
+          };
+        })
+        .filter((fieldMatch) => fieldMatch !== null);
+
+      if (fieldMatches.length === 0) {
+        continue;
+      }
+
+      matches.push({
+        kind: node.kind,
+        id: node.id,
+        fields: fieldMatches,
+      });
+    }
+
+    return {
+      matches,
+      summary: summarizeMatches(matches),
+    };
+  }
 }