trekoon 0.1.8 → 0.2.0

package/src/commands/task.ts

@@ -1,16 +1,21 @@
 import {
+  SEARCH_REPLACE_FIELDS,
+  findUnknownOption,
   hasFlag,
   parseArgs,
+  parseCsvEnumOption,
   parseStrictNonNegativeInt,
   parseStrictPositiveInt,
   readEnumOption,
   readMissingOptionValue,
   readOption,
+  resolvePreviewApplyMode,
+  suggestOptions,
 } from "./arg-parser";
 
 import { MutationService } from "../domain/mutation-service";
 import { TrackerDomain } from "../domain/tracker-domain";
-import { DomainError, type TaskRecord } from "../domain/types";
+import { DomainError, type SearchEntityMatch, 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";
@@ -26,6 +31,8 @@ const DEFAULT_TASK_LIST_LIMIT = 10;
 const DEFAULT_OPEN_TASK_STATUSES = ["in_progress", "in-progress", "todo"] as const;
 const READY_REASON_READY = "all_dependencies_done";
 const READY_REASON_BLOCKED = "blocked_by_dependencies";
+const SEARCH_OPTIONS = ["fields", "preview"] as const;
+const REPLACE_OPTIONS = ["search", "replace", "fields", "preview", "apply"] as const;
 
 interface DependencyBlocker {
   readonly id: string;
@@ -81,6 +88,55 @@ function parseIdsOption(rawIds: string | undefined): string[] {
     .filter((value) => value.length > 0);
 }
 
+function prefixedOptions(options: readonly string[]): string[] {
+  return options.map((option) => `--${option}`);
+}
+
+function unknownOption(command: string, option: string, allowedOptions: readonly string[]): CliResult {
+  const suggestions = suggestOptions(option, allowedOptions).map((suggestion) => `--${suggestion}`);
+  const suggestionMessage = suggestions.length > 0 ? ` Did you mean ${suggestions.join(" or ")}?` : "";
+  return failResult({
+    command,
+    human: `Unknown option --${option}.${suggestionMessage}`,
+    data: {
+      option: `--${option}`,
+      allowedOptions: prefixedOptions(allowedOptions),
+      suggestions,
+    },
+    error: {
+      code: "unknown_option",
+      message: `Unknown option --${option}`,
+    },
+  });
+}
+
+function invalidSearchInput(command: string, human: string, message: string, data: Record<string, unknown>): CliResult {
+  return failResult({
+    command,
+    human,
+    data,
+    error: {
+      code: "invalid_input",
+      message,
+    },
+  });
+}
+
+function formatSearchHuman(matches: readonly SearchEntityMatch[], emptyMessage: string): string {
+  if (matches.length === 0) {
+    return emptyMessage;
+  }
+
+  return matches
+    .map(
+      (match) =>
+        `${match.kind} ${match.id}: ${match.fields
+          .map((field) => `${field.field}(${field.count}) "${field.snippet}"`)
+          .join(", ")}`,
+    )
+    .join("\n");
+}
+
 function parseStatusCsv(rawStatuses: string | undefined): string[] | undefined {
   if (rawStatuses === undefined) {
     return undefined;
@@ -537,7 +593,29 @@ export async function runTask(context: CliContext): Promise<CliResult> {
           command: "task.list",
           human,
           data: { tasks },
-          ...(context.mode === "human" ? {} : { meta: { pagination: listed.pagination } }),
+          ...(context.mode === "human"
+            ? {}
+            : {
+                meta: {
+                  pagination: listed.pagination,
+                  defaults: {
+                    statuses: !includeAll && statuses === undefined ? [...DEFAULT_OPEN_TASK_STATUSES] : null,
+                    limit: !includeAll && parsedLimit === undefined ? DEFAULT_TASK_LIST_LIMIT : null,
+                    cursor: parsedCursor === undefined ? 0 : null,
+                    view: view === undefined ? "table" : null,
+                  },
+                  filters: {
+                    epicId: epicId ?? null,
+                    statuses: selectedStatuses ?? null,
+                    includeAll,
+                  },
+                  truncation: {
+                    applied: listed.pagination.hasMore,
+                    returned: tasks.length,
+                    limit: selectedLimit ?? null,
+                  },
+                },
+              }),
         });
       }
       case "show": {
@@ -593,6 +671,22 @@ export async function runTask(context: CliContext): Promise<CliResult> {
             command: "task.show",
             human: formatTask(task),
             data: { task, includeAll: false },
+            ...(context.mode === "human"
+              ? {}
+              : {
+                  meta: {
+                    defaults: {
+                      view: view === undefined ? effectiveView : null,
+                    },
+                    filters: {
+                      includeAll: false,
+                    },
+                    truncation: {
+                      applied: true,
+                      scope: "compact",
+                    },
+                  },
+                }),
           });
         }
 
@@ -603,6 +697,22 @@ export async function runTask(context: CliContext): Promise<CliResult> {
             command: "task.show",
             human: formatTaskShowTree(taskTree),
             data: { task: taskTree, includeAll: true, subtasksCount: taskTree.subtasks.length },
+            ...(context.mode === "human"
+              ? {}
+              : {
+                  meta: {
+                    defaults: {
+                      view: view === undefined ? effectiveView : null,
+                    },
+                    filters: {
+                      includeAll: true,
+                    },
+                    truncation: {
+                      applied: effectiveView === "tree",
+                      scope: "tree",
+                    },
+                  },
+                }),
           });
         }
 
@@ -610,6 +720,22 @@ export async function runTask(context: CliContext): Promise<CliResult> {
           command: "task.show",
           human: effectiveView === "table" ? formatTaskShowTable(taskTree) : formatTaskShowDetail(taskTree),
           data: { task: taskTree, includeAll: true, subtasksCount: taskTree.subtasks.length },
+          ...(context.mode === "human"
+            ? {}
+            : {
+                meta: {
+                  defaults: {
+                    view: view === undefined ? effectiveView : null,
+                  },
+                  filters: {
+                    includeAll: true,
+                  },
+                  truncation: {
+                    applied: false,
+                    scope: "full",
+                  },
+                },
+              }),
         });
       }
       case "ready": {
@@ -693,6 +819,134 @@ export async function runTask(context: CliContext): Promise<CliResult> {
           },
         });
       }
+      case "search": {
+        const searchUnknownOption = findUnknownOption(parsed, SEARCH_OPTIONS);
+        if (searchUnknownOption !== undefined) {
+          return unknownOption("task.search", searchUnknownOption, SEARCH_OPTIONS);
+        }
+
+        const missingSearchOption = readMissingOptionValue(parsed.missingOptionValues, "fields");
+        if (missingSearchOption !== undefined) {
+          return failMissingOptionValue("task.search", missingSearchOption);
+        }
+
+        const taskId: string = parsed.positional[1] ?? "";
+        const searchText: string = parsed.positional[2] ?? "";
+        if (taskId.length === 0 || searchText.trim().length === 0) {
+          return invalidSearchInput(
+            "task.search",
+            "Usage: trekoon task search <task-id> \"search text\" [--fields <csv>] [--preview]",
+            "Missing search target",
+            {
+              taskId,
+            },
+          );
+        }
+
+        const parsedFields = parseCsvEnumOption(readOption(parsed.options, "fields"), SEARCH_REPLACE_FIELDS);
+        if (parsedFields.empty || parsedFields.invalidValues.length > 0) {
+          return invalidSearchInput("task.search", "Invalid --fields value. Use title, description, or title,description.", "Invalid --fields value", {
+            fields: readOption(parsed.options, "fields"),
+            invalidFields: parsedFields.invalidValues,
+            allowedFields: [...SEARCH_REPLACE_FIELDS],
+          });
+        }
+
+        const { matches, summary } = domain.searchTaskScope(taskId, searchText, parsedFields.values);
+
+        return okResult({
+          command: "task.search",
+          human: formatSearchHuman(matches, "No matches found."),
+          data: {
+            scope: {
+              kind: "task",
+              id: taskId,
+            },
+            query: {
+              search: searchText,
+              fields: parsedFields.values,
+              mode: "preview",
+            },
+            summary,
+            matches,
+          },
+        });
+      }
+      case "replace": {
+        const replaceUnknownOption = findUnknownOption(parsed, REPLACE_OPTIONS);
+        if (replaceUnknownOption !== undefined) {
+          return unknownOption("task.replace", replaceUnknownOption, REPLACE_OPTIONS);
+        }
+
+        const missingReplaceOption =
+          readMissingOptionValue(parsed.missingOptionValues, "search") ??
+          readMissingOptionValue(parsed.missingOptionValues, "replace") ??
+          readMissingOptionValue(parsed.missingOptionValues, "fields");
+        if (missingReplaceOption !== undefined) {
+          return failMissingOptionValue("task.replace", missingReplaceOption);
+        }
+
+        const taskId: string = parsed.positional[1] ?? "";
+        const searchText = readOption(parsed.options, "search") ?? "";
+        const replacementText = readOption(parsed.options, "replace") ?? "";
+        if (taskId.length === 0 || searchText.trim().length === 0) {
+          return invalidSearchInput(
+            "task.replace",
+            "Usage: trekoon task replace <task-id> --search \"text\" --replace \"text\" [--fields <csv>] [--preview|--apply]",
+            "Missing replace target",
+            {
+              taskId,
+              search: searchText,
+            },
+          );
+        }
+
+        const rawFields = readOption(parsed.options, "fields");
+        const parsedFields = parseCsvEnumOption(rawFields, SEARCH_REPLACE_FIELDS);
+        if (parsedFields.empty || parsedFields.invalidValues.length > 0) {
+          return invalidSearchInput("task.replace", "Invalid --fields value. Use title, description, or title,description.", "Invalid --fields value", {
+            fields: rawFields,
+            invalidFields: parsedFields.invalidValues,
+            allowedFields: [...SEARCH_REPLACE_FIELDS],
+          });
+        }
+
+        const previewMode = resolvePreviewApplyMode(parsed.flags);
+        if (previewMode.conflict) {
+          return invalidSearchInput("task.replace", "Use either --preview or --apply, not both.", "Conflicting mode flags", {
+            flags: ["preview", "apply"],
+          });
+        }
+
+        const replacementSummary = previewMode.mode === "apply"
+          ? mutations.applyTaskReplacement(taskId, searchText, replacementText, parsedFields.values)
+          : mutations.previewTaskReplacement(taskId, searchText, replacementText, parsedFields.values);
+        const { matches, summary: matchSummary } = replacementSummary;
+
+        const summary = {
+          ...matchSummary,
+          mode: previewMode.mode,
+        };
+
+        return okResult({
+          command: "task.replace",
+          human: formatSearchHuman(matches, `No ${previewMode.mode === "apply" ? "replacements" : "matches"} found.`),
+          data: {
+            scope: {
+              kind: "task",
+              id: taskId,
+            },
+            query: {
+              search: searchText,
+              replace: replacementText,
+              fields: parsedFields.values,
+              mode: previewMode.mode,
+            },
+            summary,
+            matches,
+          },
+        });
+      }
       case "update": {
         const missingUpdateOption =
           readMissingOptionValue(parsed.missingOptionValues, "ids") ??
@@ -830,7 +1084,7 @@ export async function runTask(context: CliContext): Promise<CliResult> {
       default:
         return failResult({
           command: "task",
-          human: "Usage: trekoon task <create|list|show|ready|next|update|delete>",
+          human: "Usage: trekoon task <create|list|show|ready|next|search|replace|update|delete>",
           data: {
             args: context.args,
           },

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),
+    };
+  }
 }