trekoon 0.1.9 → 0.2.0

package/src/domain/mutation-service.ts

@@ -3,7 +3,83 @@ 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 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;
@@ -153,6 +229,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 +296,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),
+    };
+  }
 }

package/src/domain/tracker-domain.ts

@@ -10,6 +10,11 @@ import {
   type EpicTree,
   type NodeKind,
   type ReverseDependencyNode,
+  type SearchEntityMatch,
+  type SearchField,
+  type SearchFieldMatch,
+  type SearchNode,
+  type SearchSummary,
   type SubtaskRecord,
   type TaskTreeDetailed,
   type TaskRecord,
@@ -125,6 +130,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;
 
@@ -433,6 +487,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) {
@@ -570,6 +707,40 @@ export class TrackerDomain {
     return mapDependency(row);
   }
 
+  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(

package/src/domain/types.ts

@@ -85,6 +85,33 @@ export interface EpicTreeDetailed {
   readonly tasks: ReadonlyArray<TaskTreeDetailed>;
 }
 
+export type SearchField = "title" | "description";
+
+export interface SearchFieldMatch {
+  readonly field: SearchField;
+  readonly count: number;
+  readonly snippet: string;
+}
+
+export interface SearchEntityMatch {
+  readonly kind: NodeKind;
+  readonly id: string;
+  readonly fields: readonly SearchFieldMatch[];
+}
+
+export interface SearchSummary {
+  readonly matchedEntities: number;
+  readonly matchedFields: number;
+  readonly totalMatches: number;
+}
+
+export interface SearchNode {
+  readonly kind: NodeKind;
+  readonly id: string;
+  readonly title: string;
+  readonly description: string;
+}
+
 export interface DomainErrorShape {
   readonly code: string;
   readonly message: string;

package/src/sync/event-writes.ts

@@ -11,11 +11,31 @@ interface EventRecordInput {
   readonly fields: Record<string, unknown>;
 }
 
+function nextEventTimestamp(db: Database): number {
+  const now: number = Date.now();
+  const latestEvent = db
+    .query(
+      `
+      SELECT created_at
+      FROM events
+      ORDER BY created_at DESC, id DESC
+      LIMIT 1;
+      `,
+    )
+    .get() as { created_at: number } | null;
+
+  if (!latestEvent) {
+    return now;
+  }
+
+  return Math.max(now, latestEvent.created_at + 1);
+}
+
 export function appendEventWithGitContext(db: Database, cwd: string, input: EventRecordInput): string {
   const git = resolveGitContext(cwd);
   persistGitContext(db, git);
 
-  const now: number = Date.now();
+  const now: number = nextEventTimestamp(db);
   const eventId: string = randomUUID();
 
   db.query(