trekoon 0.4.1 → 0.4.3

package/src/domain/types.ts

@@ -97,6 +97,7 @@ export interface EpicRecord {
   readonly status: string;
   readonly createdAt: number;
   readonly updatedAt: number;
+  readonly version: number;
 }
 
 export interface TaskRecord {
@@ -108,6 +109,7 @@ export interface TaskRecord {
   readonly owner: string | null;
   readonly createdAt: number;
   readonly updatedAt: number;
+  readonly version: number;
 }
 
 export interface SubtaskRecord {
@@ -119,6 +121,7 @@ export interface SubtaskRecord {
   readonly owner: string | null;
   readonly createdAt: number;
   readonly updatedAt: number;
+  readonly version: number;
 }
 
 export interface DependencyRecord {
@@ -255,14 +258,65 @@ export interface StatusCascadePlan {
   readonly counts: StatusCascadeCounts;
 }
 
+export const ERROR_CODES = {
+  ALREADY_DONE: "already_done",
+  ALREADY_RESOLVED: "already_resolved",
+  AMBIGUOUS_LEGACY_STATE: "ambiguous_legacy_state",
+  BACKPRESSURE: "backpressure",
+  BACKUP_ALREADY_EXISTS: "backup_already_exists",
+  BACKUP_DATABASE_MISSING: "backup_database_missing",
+  BACKUP_FAILED: "backup_failed",
+  CANCELLED: "cancelled",
+  CONFIRMATION_REQUIRED: "confirmation_required",
+  CONFLICT_SET_CHANGED: "conflict_set_changed",
+  DAEMON_START_FAILED: "daemon_start_failed",
+  DATABASE_BUSY: "database_busy",
+  DEPENDENCY_BLOCKED: "dependency_blocked",
+  DISALLOWED_FIELD: "disallowed_field",
+  EVENTS_FAILED: "events_failed",
+  INSTALL_FAILED: "install_failed",
+  INTERNAL_ERROR: "internal_error",
+  INVALID_ARGS: "invalid_args",
+  INVALID_DEPENDENCY: "invalid_dependency",
+  INVALID_INPUT: "invalid_input",
+  INVALID_PATH: "invalid_path",
+  INVALID_SOURCE: "invalid_source",
+  INVALID_STATE: "invalid_state",
+  INVALID_SUBCOMMAND: "invalid_subcommand",
+  LEGACY_IMPORT_FAILED: "legacy_import_failed",
+  MIGRATE_FAILED: "migrate_failed",
+  MIGRATION_DOWN_UNSUPPORTED: "migration_down_unsupported",
+  MISSING_ASSET: "missing_asset",
+  NO_MATCHING_CONFLICTS: "no_matching_conflicts",
+  NOT_FOUND: "not_found",
+  ORPHANED_EXTERNAL_NODE: "orphaned_external_node",
+  OUTSIDE_REPO_TARGET: "outside_repo_target",
+  PERMISSION_DENIED: "permission_denied",
+  PRECONDITION_FAILED: "precondition_failed",
+  ROW_NOT_FOUND: "row_not_found",
+  STATUS_TRANSITION_INVALID: "status_transition_invalid",
+  STREAM_UNAVAILABLE: "stream_unavailable",
+  SYNC_FAILED: "sync_failed",
+  TRACKED_IGNORED_MISMATCH: "tracked_ignored_mismatch",
+  UNAUTHORIZED: "unauthorized",
+  UNHANDLED_COMMAND: "unhandled_command",
+  UNKNOWN_COMMAND: "unknown_command",
+  UNKNOWN_OPTION: "unknown_option",
+  UNSUPPORTED_ENTITY_KIND: "unsupported_entity_kind",
+  UPDATE_FAILED: "update_failed",
+  WRONG_ENTITY_TYPE: "wrong_entity_type",
+} as const;
+
+export type ErrorCode = (typeof ERROR_CODES)[keyof typeof ERROR_CODES];
+
 export interface DomainErrorShape {
-  readonly code: string;
+  readonly code: ErrorCode;
   readonly message: string;
   readonly details?: Record<string, unknown>;
 }
 
 export class DomainError extends Error {
-  readonly code: string;
+  readonly code: ErrorCode;
   readonly details?: Record<string, unknown>;
 
   constructor(input: DomainErrorShape) {

package/src/export/render-markdown.ts

@@ -124,8 +124,7 @@ function renderTaskIndex(lines: string[], bundle: ExportBundle): void {
   lines.push("| # | Title | Status | Subtasks |");
   lines.push("|---|-------|--------|----------|");
 
-  for (let i = 0; i < bundle.tasks.length; i++) {
-    const task = bundle.tasks[i];
+  for (const [i, task] of bundle.tasks.entries()) {
     const subtaskCount = bundle.subtasks.filter((s) => s.taskId === task.id).length;
     const anchor = taskAnchor(task);
     lines.push(`| ${i + 1} | [${escapeTableCell(escapeInlineText(task.title))}](#${anchor}) | ${task.status} | ${subtaskCount} |`);

package/src/index.ts

@@ -4,6 +4,43 @@ import { executeShell, parseInvocation, renderShellResult } from "./runtime/cli-
 
 export async function run(argv: readonly string[] = process.argv.slice(2)): Promise<void> {
   const parsed = parseInvocation(argv);
+
+  // Daemon path is opt-in (TREKOON_DAEMON=1 or --daemon). The `serve`
+  // subcommand always runs in-process so it can host the daemon.
+  const daemonRequested: boolean = parsed.wantsDaemon || process.env.TREKOON_DAEMON === "1";
+  if (daemonRequested && parsed.command !== "serve") {
+    const { tryDaemonDispatch, PostWriteError } = await import("./runtime/daemon");
+    // Strip --daemon from the argv we forward (the server has its own dispatch).
+    const forwarded: readonly string[] = argv.filter((token: string): boolean => token !== "--daemon");
+    try {
+      const daemonResult = await tryDaemonDispatch(forwarded);
+      if (daemonResult !== null) {
+        if (daemonResult.stdout.length > 0) {
+          process.stdout.write(daemonResult.stdout);
+        }
+        if (daemonResult.stderr.length > 0) {
+          process.stderr.write(daemonResult.stderr);
+        }
+        process.exitCode = daemonResult.exitCode;
+        return;
+      }
+      // Fall through to one-shot CLI when no daemon is reachable (pre-write
+      // transport failure — request never made it onto the wire).
+    } catch (error: unknown) {
+      // Post-write failure: the request bytes were already flushed to the
+      // daemon. The mutation may have committed. Refuse to silently re-run
+      // the command in-process; exit non-zero so the caller can decide.
+      if (error instanceof PostWriteError) {
+        process.stderr.write(
+          `trekoon: daemon may have committed; do not retry: ${error.message}\n`,
+        );
+        process.exitCode = 1;
+        return;
+      }
+      throw error;
+    }
+  }
+
   const result = await executeShell(parsed);
   const rendered: string = renderShellResult(result, parsed.mode, parsed.compatibilityMode, { compact: parsed.compact });
 

package/src/runtime/cli-shell.ts

@@ -36,6 +36,7 @@ const SUPPORTED_ROOT_COMMANDS: readonly string[] = [
   "suggest",
   "update",
   "wipe",
+  "serve",
 ];
 
 export interface ParsedInvocation {
@@ -48,6 +49,7 @@ export interface ParsedInvocation {
   readonly args: readonly string[];
   readonly wantsHelp: boolean;
   readonly wantsVersion: boolean;
+  readonly wantsDaemon: boolean;
 }
 
 export interface ParseInvocationOptions {
@@ -62,6 +64,7 @@ export function parseInvocation(argv: readonly string[], options: ParseInvocatio
   let compatibilityModeMissingValue = false;
   let wantsHelp = false;
   let wantsVersion = false;
+  let wantsDaemon = false;
   const positionals: string[] = [];
 
   for (let index = 0; index < argv.length; index += 1) {
@@ -95,6 +98,11 @@ export function parseInvocation(argv: readonly string[], options: ParseInvocatio
       continue;
     }
 
+    if (token === "--daemon") {
+      wantsDaemon = true;
+      continue;
+    }
+
     if (token === "--compat") {
       const maybeValue: string | undefined = argv[index + 1];
       if (!maybeValue || maybeValue.startsWith("--")) {
@@ -123,6 +131,7 @@ export function parseInvocation(argv: readonly string[], options: ParseInvocatio
     args: positionals.slice(1),
     wantsHelp,
     wantsVersion,
+    wantsDaemon,
   };
 }
 
@@ -403,6 +412,11 @@ export async function executeShell(parsed: ParsedInvocation, cwd: string = proce
       // Route `trekoon update` to `trekoon skills update` internally.
       result = await runSkills({ ...context, args: ["update", ...context.args] });
       break;
+    case "serve":
+      // Experimental: run the daemon in the foreground. Loaded lazily so the
+      // default cold path stays free of node:net imports.
+      result = await runServe(context);
+      break;
     default:
       result = failResult({
         command: "shell",
@@ -418,3 +432,33 @@ export async function executeShell(parsed: ParsedInvocation, cwd: string = proce
 
   return withStorageRootDiagnostics(result, cwd);
 }
+
+async function runServe(context: CliContext): Promise<CliResult> {
+  // Lazy import keeps node:net out of the normal one-shot dispatch path.
+  const { runDaemonForeground, resolveDaemonSocketPath } = await import("./daemon");
+  const socketPath: string = resolveDaemonSocketPath(context.cwd);
+
+  try {
+    await runDaemonForeground({ cwd: context.cwd, silent: context.mode !== "human" });
+    return okResult({
+      command: "serve",
+      human: `Daemon stopped (socket: ${socketPath})`,
+      data: {
+        socketPath,
+        status: "stopped",
+        experimental: true,
+      },
+    });
+  } catch (error: unknown) {
+    const message: string = error instanceof Error ? error.message : String(error);
+    return failResult({
+      command: "serve",
+      human: `Daemon failed to start: ${message}`,
+      data: { socketPath },
+      error: {
+        code: "daemon_start_failed",
+        message,
+      },
+    });
+  }
+}