trekoon 0.2.0 → 0.2.1

package/src/commands/task.ts

@@ -2,24 +2,29 @@ import {
   SEARCH_REPLACE_FIELDS,
   findUnknownOption,
   hasFlag,
+  isValidCompactTempKey,
   parseArgs,
+  parseCompactFields,
   parseCsvEnumOption,
   parseStrictNonNegativeInt,
   parseStrictPositiveInt,
   readEnumOption,
   readMissingOptionValue,
   readOption,
+  readOptions,
+  readUnexpectedPositionals,
   resolvePreviewApplyMode,
   suggestOptions,
 } from "./arg-parser";
+import { unexpectedFailureResult } from "./error-utils";
 
 import { MutationService } from "../domain/mutation-service";
 import { TrackerDomain } from "../domain/tracker-domain";
-import { DomainError, type SearchEntityMatch, type TaskRecord } from "../domain/types";
+import { type CompactBatchResultContract, type CompactTaskSpec, 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";
-import { openTrekoonDatabase } from "../storage/database";
+import { openTrekoonDatabase, type TrekoonDatabase } from "../storage/database";
 
 function formatTask(task: TaskRecord): string {
   return `${task.id} | epic=${task.epicId} | ${task.title} | ${task.status}`;
@@ -33,6 +38,7 @@ 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;
+const CREATE_MANY_OPTIONS = ["epic", "e", "task"] as const;
 
 interface DependencyBlocker {
   readonly id: string;
@@ -383,29 +389,9 @@ function formatTaskShowTable(taskTree: {
 }
 
 function failFromError(error: unknown): CliResult {
-  if (error instanceof DomainError) {
-    return failResult({
-      command: "task",
-      human: error.message,
-      data: {
-        code: error.code,
-        ...(error.details ?? {}),
-      },
-      error: {
-        code: error.code,
-        message: error.message,
-      },
-    });
-  }
-
-  return failResult({
+  return unexpectedFailureResult(error, {
     command: "task",
     human: "Unexpected task command failure",
-    data: {},
-    error: {
-      code: "internal_error",
-      message: "Unexpected task command failure",
-    },
   });
 }
 
@@ -424,10 +410,145 @@ function failMissingOptionValue(command: string, option: string): CliResult {
   });
 }
 
+function failBatchSpec(command: string, human: string, data: Record<string, unknown>): CliResult {
+  return failResult({
+    command,
+    human,
+    data,
+    error: {
+      code: "invalid_input",
+      message: human,
+    },
+  });
+}
+
+function failUnexpectedPositionals(command: string, unexpected: readonly string[]): CliResult {
+  return failBatchSpec(command, `Unexpected positional arguments: ${unexpected.join(", ")}.`, {
+    unexpectedPositionals: unexpected,
+  });
+}
+
+function failEmptyCompactField(command: string, option: string, index: number, rawSpec: string, field: string): CliResult {
+  return failBatchSpec(command, `${option === "task" ? "Task" : "Spec"} spec ${index + 1} is missing a ${field}.`, {
+    option,
+    index,
+    rawSpec,
+    field,
+  });
+}
+
+function parseTaskCreateManySpecs(rawSpecs: readonly string[]): { specs: CompactTaskSpec[]; error?: CliResult } {
+  const specs: CompactTaskSpec[] = [];
+  const seenTempKeys = new Set<string>();
+
+  for (const [index, rawSpec] of rawSpecs.entries()) {
+    const parsed = parseCompactFields(rawSpec);
+    if (parsed.invalidEscape !== null) {
+      return {
+        specs: [],
+        error: failBatchSpec("task.create-many", `Invalid escape sequence ${parsed.invalidEscape} in --task spec ${index + 1}.`, {
+          option: "task",
+          index,
+          rawSpec,
+          invalidEscape: parsed.invalidEscape,
+        }),
+      };
+    }
+
+    if (parsed.hasDanglingEscape) {
+      return {
+        specs: [],
+        error: failBatchSpec("task.create-many", `Trailing escape in --task spec ${index + 1}.`, {
+          option: "task",
+          index,
+          rawSpec,
+        }),
+      };
+    }
+
+    if (parsed.fields.length !== 4) {
+      return {
+        specs: [],
+        error: failBatchSpec("task.create-many", `Task specs must use <temp-key>|<title>|<description>|<status> in --task spec ${index + 1}.`, {
+          option: "task",
+          index,
+          rawSpec,
+          fields: parsed.fields,
+        }),
+      };
+    }
+
+    const tempKey = parsed.fields[0] ?? "";
+    const title = parsed.fields[1] ?? "";
+    const description = parsed.fields[2] ?? "";
+    const status = parsed.fields[3] ?? "";
+    if (!tempKey || !isValidCompactTempKey(tempKey)) {
+      return {
+        specs: [],
+        error: failBatchSpec("task.create-many", `Task spec ${index + 1} must start with a temp key like seed-1.`, {
+          option: "task",
+          index,
+          rawSpec,
+          tempKey,
+        }),
+      };
+    }
+
+    if (seenTempKeys.has(tempKey)) {
+      return {
+        specs: [],
+        error: failBatchSpec("task.create-many", `Duplicate temp key '${tempKey}' in --task specs.`, {
+          option: "task",
+          index,
+          rawSpec,
+          tempKey,
+        }),
+      };
+    }
+
+    if (!title || title.trim().length === 0) {
+      return {
+        specs: [],
+        error: failBatchSpec("task.create-many", `Task spec ${index + 1} is missing a title.`, {
+          option: "task",
+          index,
+          rawSpec,
+        }),
+      };
+    }
+
+    if (description.trim().length === 0) {
+      return {
+        specs: [],
+        error: failEmptyCompactField("task.create-many", "task", index, rawSpec, "description"),
+      };
+    }
+
+    seenTempKeys.add(tempKey);
+    const spec: CompactTaskSpec = status.length > 0
+      ? {
+          tempKey,
+          title,
+          description,
+          status,
+        }
+      : {
+          tempKey,
+          title,
+          description,
+        };
+
+    specs.push(spec);
+  }
+
+  return { specs };
+}
+
 export async function runTask(context: CliContext): Promise<CliResult> {
-  const database = openTrekoonDatabase(context.cwd);
+  let database: TrekoonDatabase | undefined;
 
   try {
+    database = openTrekoonDatabase(context.cwd);
     const parsed = parseArgs(context.args);
     const subcommand: string | undefined = parsed.positional[0];
     const domain = new TrackerDomain(database.db);
@@ -460,6 +581,56 @@ export async function runTask(context: CliContext): Promise<CliResult> {
           data: { task },
         });
       }
+      case "create-many": {
+        const createManyUnknownOption = findUnknownOption(parsed, CREATE_MANY_OPTIONS);
+        if (createManyUnknownOption !== undefined) {
+          return unknownOption("task.create-many", createManyUnknownOption, CREATE_MANY_OPTIONS);
+        }
+
+        const missingCreateManyOption = readMissingOptionValue(parsed.missingOptionValues, "epic", "e", "task");
+        if (missingCreateManyOption !== undefined) {
+          return failMissingOptionValue("task.create-many", missingCreateManyOption);
+        }
+
+        const unexpectedPositionals = readUnexpectedPositionals(parsed, 1);
+        if (unexpectedPositionals.length > 0) {
+          return failUnexpectedPositionals("task.create-many", unexpectedPositionals);
+        }
+
+        const epicId = readOption(parsed.options, "epic", "e");
+        if (epicId === undefined || epicId.trim().length === 0) {
+          return failBatchSpec("task.create-many", "Provide --epic for task create-many.", {
+            option: "epic",
+          });
+        }
+
+        const rawSpecs = readOptions(parsed.optionEntries, "task");
+        if (rawSpecs.length === 0) {
+          return failBatchSpec("task.create-many", "Provide at least one --task spec.", {
+            option: "task",
+          });
+        }
+
+        const specResult = parseTaskCreateManySpecs(rawSpecs);
+        if (specResult.error !== undefined) {
+          return specResult.error;
+        }
+
+        const created = mutations.createTaskBatch({
+          epicId,
+          specs: specResult.specs,
+        });
+        const result: CompactBatchResultContract = created.result;
+        return okResult({
+          command: "task.create-many",
+          human: `Created ${created.tasks.length} task(s): ${created.tasks.map(formatTask).join("\n")}`,
+          data: {
+            epicId,
+            tasks: created.tasks,
+            result,
+          },
+        });
+      }
       case "list": {
         const missingListOption =
           readMissingOptionValue(parsed.missingOptionValues, "view") ??
@@ -1084,7 +1255,7 @@ export async function runTask(context: CliContext): Promise<CliResult> {
       default:
         return failResult({
           command: "task",
-          human: "Usage: trekoon task <create|list|show|ready|next|search|replace|update|delete>",
+          human: "Usage: trekoon task <create|create-many|list|show|ready|next|search|replace|update|delete>",
           data: {
             args: context.args,
           },
@@ -1097,6 +1268,6 @@ export async function runTask(context: CliContext): Promise<CliResult> {
   } catch (error: unknown) {
     return failFromError(error);
   } finally {
-    database.close();
+    database?.close();
   }
 }

package/src/domain/mutation-service.ts

@@ -4,6 +4,14 @@ import { appendEventWithGitContext } from "../sync/event-writes";
 import { ENTITY_OPERATIONS } from "./mutation-operations";
 import { TrackerDomain } from "./tracker-domain";
 import {
+  type CompactEpicCreateResult,
+  type CompactEpicExpandResult,
+  type CompactDependencyBatchAddResult,
+  type CompactDependencySpec,
+  type CompactSubtaskBatchCreateResult,
+  type CompactSubtaskSpec,
+  type CompactTaskBatchCreateResult,
+  type CompactTaskSpec,
   type DependencyRecord,
   type EpicRecord,
   type SearchEntityMatch,
@@ -104,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 },
@@ -139,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 },
@@ -180,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 },
@@ -216,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);