trekoon 0.1.0

package/src/commands/subtask.ts

@@ -0,0 +1,187 @@
+import { parseArgs, readEnumOption, readMissingOptionValue, readOption } from "./arg-parser";
+
+import { DomainError, type SubtaskRecord } from "../domain/types";
+import { TrackerDomain } from "../domain/tracker-domain";
+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";
+
+function formatSubtask(subtask: SubtaskRecord): string {
+  return `${subtask.id} | task=${subtask.taskId} | ${subtask.title} | ${subtask.status}`;
+}
+
+const VIEW_MODES = ["table", "compact"] as const;
+
+function formatSubtaskListTable(subtasks: readonly SubtaskRecord[]): string {
+  return formatHumanTable(
+    ["ID", "TASK", "TITLE", "STATUS"],
+    subtasks.map((subtask) => [subtask.id, subtask.taskId, subtask.title, subtask.status]),
+    { wrapColumns: [2] },
+  );
+}
+
+function failFromError(error: unknown): CliResult {
+  if (error instanceof DomainError) {
+    return failResult({
+      command: "subtask",
+      human: error.message,
+      data: {
+        code: error.code,
+        ...(error.details ?? {}),
+      },
+      error: {
+        code: error.code,
+        message: error.message,
+      },
+    });
+  }
+
+  return failResult({
+    command: "subtask",
+    human: "Unexpected subtask command failure",
+    data: {},
+    error: {
+      code: "internal_error",
+      message: "Unexpected subtask command failure",
+    },
+  });
+}
+
+function failMissingOptionValue(command: string, option: string): CliResult {
+  return failResult({
+    command,
+    human: `Option --${option} requires a value.`,
+    data: {
+      code: "invalid_input",
+      option,
+    },
+    error: {
+      code: "invalid_input",
+      message: `Option --${option} requires a value`,
+    },
+  });
+}
+
+export async function runSubtask(context: CliContext): Promise<CliResult> {
+  const database = openTrekoonDatabase(context.cwd);
+
+  try {
+    const parsed = parseArgs(context.args);
+    const subcommand: string | undefined = parsed.positional[0];
+    const domain = new TrackerDomain(database.db);
+
+    switch (subcommand) {
+      case "create": {
+        const missingCreateOption =
+          readMissingOptionValue(parsed.missingOptionValues, "task", "t") ??
+          readMissingOptionValue(parsed.missingOptionValues, "description", "d") ??
+          readMissingOptionValue(parsed.missingOptionValues, "status", "s");
+        if (missingCreateOption !== undefined) {
+          return failMissingOptionValue("subtask.create", missingCreateOption);
+        }
+
+        const taskId: string | undefined = readOption(parsed.options, "task", "t") ?? parsed.positional[1];
+        const title: string | undefined = readOption(parsed.options, "title") ?? parsed.positional[2];
+        const description: string | undefined = readOption(parsed.options, "description", "d");
+        const status: string | undefined = readOption(parsed.options, "status", "s");
+        const subtask = domain.createSubtask({
+          taskId: taskId ?? "",
+          title: title ?? "",
+          description,
+          status,
+        });
+
+        return okResult({
+          command: "subtask.create",
+          human: `Created subtask ${formatSubtask(subtask)}`,
+          data: { subtask },
+        });
+      }
+      case "list": {
+        const missingListOption =
+          readMissingOptionValue(parsed.missingOptionValues, "view") ??
+          readMissingOptionValue(parsed.missingOptionValues, "task", "t");
+        if (missingListOption !== undefined) {
+          return failMissingOptionValue("subtask.list", missingListOption);
+        }
+
+        const rawView: string | undefined = readOption(parsed.options, "view");
+        const view = readEnumOption(parsed.options, VIEW_MODES, "view");
+        if (rawView !== undefined && view === undefined) {
+          return failResult({
+            command: "subtask.list",
+            human: "Invalid --view value. Use: table, compact",
+            data: { view: rawView, allowedViews: VIEW_MODES },
+            error: {
+              code: "invalid_input",
+              message: "Invalid --view value",
+            },
+          });
+        }
+
+        const taskId: string | undefined = readOption(parsed.options, "task", "t") ?? parsed.positional[1];
+        const subtasks = domain.listSubtasks(taskId);
+        const listView = view ?? "table";
+        const human =
+          subtasks.length === 0
+            ? "No subtasks found."
+            : listView === "compact"
+              ? subtasks.map(formatSubtask).join("\n")
+              : formatSubtaskListTable(subtasks);
+
+        return okResult({
+          command: "subtask.list",
+          human,
+          data: { subtasks },
+        });
+      }
+      case "update": {
+        const missingUpdateOption =
+          readMissingOptionValue(parsed.missingOptionValues, "description", "d") ??
+          readMissingOptionValue(parsed.missingOptionValues, "status", "s");
+        if (missingUpdateOption !== undefined) {
+          return failMissingOptionValue("subtask.update", missingUpdateOption);
+        }
+
+        const subtaskId: string = parsed.positional[1] ?? "";
+        const title: string | undefined = readOption(parsed.options, "title");
+        const description: string | undefined = readOption(parsed.options, "description", "d");
+        const status: string | undefined = readOption(parsed.options, "status", "s");
+        const subtask = domain.updateSubtask(subtaskId, { title, description, status });
+
+        return okResult({
+          command: "subtask.update",
+          human: `Updated subtask ${formatSubtask(subtask)}`,
+          data: { subtask },
+        });
+      }
+      case "delete": {
+        const subtaskId: string = parsed.positional[1] ?? "";
+        domain.deleteSubtask(subtaskId);
+
+        return okResult({
+          command: "subtask.delete",
+          human: `Deleted subtask ${subtaskId}`,
+          data: { id: subtaskId },
+        });
+      }
+      default:
+        return failResult({
+          command: "subtask",
+          human: "Usage: trekoon subtask <create|list|update|delete>",
+          data: {
+            args: context.args,
+          },
+          error: {
+            code: "invalid_subcommand",
+            message: "Invalid subtask subcommand",
+          },
+        });
+    }
+  } catch (error: unknown) {
+    return failFromError(error);
+  } finally {
+    database.close();
+  }
+}

package/src/commands/sync.ts

@@ -0,0 +1,128 @@
+import { failResult, okResult } from "../io/output";
+import { type CliContext, type CliResult } from "../runtime/command-types";
+import { MissingBranchDatabaseError } from "../sync/branch-db";
+import { syncPull, syncResolve, syncStatus } from "../sync/service";
+import { type SyncResolution } from "../sync/types";
+
+function parseOption(args: readonly string[], option: string): string | null {
+  const index: number = args.indexOf(option);
+  if (index < 0) {
+    return null;
+  }
+
+  const value: string | undefined = args[index + 1];
+  return value && !value.startsWith("--") ? value : null;
+}
+
+function usage(message: string): CliResult {
+  return failResult({
+    command: "sync",
+    human: `${message}\nUsage: trekoon sync <status|pull|resolve> [options]`,
+    data: { message },
+    error: {
+      code: "invalid_args",
+      message,
+    },
+  });
+}
+
+function statusMessage(sourceBranch: string, ahead: number, behind: number, conflicts: number): string {
+  return [
+    `Sync status against '${sourceBranch}'`,
+    `Ahead: ${ahead}`,
+    `Behind: ${behind}`,
+    `Pending conflicts: ${conflicts}`,
+  ].join("\n");
+}
+
+export async function runSync(context: CliContext): Promise<CliResult> {
+  const subcommand: string | undefined = context.args[0];
+
+  if (!subcommand) {
+    return usage("Missing sync subcommand.");
+  }
+
+  try {
+    if (subcommand === "status") {
+      const sourceBranch: string = parseOption(context.args, "--from") ?? "main";
+      const summary = syncStatus(context.cwd, sourceBranch);
+
+      return okResult({
+        command: "sync status",
+        human: statusMessage(summary.sourceBranch, summary.ahead, summary.behind, summary.pendingConflicts),
+        data: summary,
+      });
+    }
+
+    if (subcommand === "pull") {
+      const sourceBranch: string | null = parseOption(context.args, "--from");
+      if (!sourceBranch) {
+        return usage("sync pull requires --from <branch>.");
+      }
+
+      const summary = syncPull(context.cwd, sourceBranch);
+
+      return okResult({
+        command: "sync pull",
+        human: [
+          `Pulled from '${summary.sourceBranch}'`,
+          `Scanned events: ${summary.scannedEvents}`,
+          `Applied events: ${summary.appliedEvents}`,
+          `Created conflicts: ${summary.createdConflicts}`,
+        ].join("\n"),
+        data: summary,
+      });
+    }
+
+    if (subcommand === "resolve") {
+      const conflictId: string | undefined = context.args[1];
+      const rawResolution: string | null = parseOption(context.args, "--use");
+
+      if (!conflictId || !rawResolution) {
+        return usage("sync resolve requires <conflict-id> --use ours|theirs.");
+      }
+
+      if (rawResolution !== "ours" && rawResolution !== "theirs") {
+        return usage("sync resolve --use only accepts ours|theirs.");
+      }
+
+      const summary = syncResolve(context.cwd, conflictId, rawResolution as SyncResolution);
+
+      return okResult({
+        command: "sync resolve",
+        human: `Resolved ${summary.conflictId} using ${summary.resolution}.`,
+        data: summary,
+      });
+    }
+
+    return usage(`Unknown sync subcommand '${subcommand}'.`);
+  } catch (error) {
+    if (error instanceof MissingBranchDatabaseError) {
+      return failResult({
+        command: "sync",
+        human: error.message,
+        data: {
+          reason: "missing_branch_db",
+        },
+        error: {
+          code: "missing_branch_db",
+          message: error.message,
+        },
+      });
+    }
+
+    const message = error instanceof Error ? error.message : "Unknown sync error.";
+
+    return failResult({
+      command: "sync",
+      human: message,
+      data: {
+        reason: "sync_failed",
+      },
+      error: {
+        code: "sync_failed",
+        message,
+      },
+    });
+  }
+}