ralphctl 0.1.2 → 0.1.4

package/dist/{add-HGJCLWED.mjs → add-7LBVENXM.mjs}

@@ -2,11 +2,13 @@
 import {
   addSingleTicketInteractive,
   ticketAddCommand
-} from "./chunk-MNMQC36F.mjs";
+} from "./chunk-F2MMCTB5.mjs";
 import "./chunk-7TG3EAQ2.mjs";
-import "./chunk-WGHJI3OI.mjs";
-import "./chunk-EKMZZRWI.mjs";
-import "./chunk-6PYTKGB5.mjs";
+import "./chunk-PDI6HBZ7.mjs";
+import "./chunk-LFDW6MWF.mjs";
+import "./chunk-OEUJDSHY.mjs";
+import "./chunk-W3TY22IS.mjs";
+import "./chunk-EDJX7TT6.mjs";
 import "./chunk-QBXHAXHI.mjs";
 export {
   addSingleTicketInteractive,

package/dist/{add-MRGCS3US.mjs → add-DVEYDCTR.mjs}

@@ -2,11 +2,13 @@
 import {
   addCheckScriptToRepository,
   projectAddCommand
-} from "./chunk-MRKOFVTM.mjs";
-import "./chunk-NTWO2LXB.mjs";
+} from "./chunk-YIB7QYU4.mjs";
+import "./chunk-7LZ6GOGN.mjs";
 import "./chunk-7TG3EAQ2.mjs";
-import "./chunk-WGHJI3OI.mjs";
-import "./chunk-6PYTKGB5.mjs";
+import "./chunk-PDI6HBZ7.mjs";
+import "./chunk-OEUJDSHY.mjs";
+import "./chunk-W3TY22IS.mjs";
+import "./chunk-EDJX7TT6.mjs";
 import "./chunk-QBXHAXHI.mjs";
 export {
   addCheckScriptToRepository,

package/dist/{chunk-NTWO2LXB.mjs → chunk-7LZ6GOGN.mjs}

@@ -1,4 +1,8 @@
 #!/usr/bin/env node
+import {
+  ensureError,
+  wrapAsync
+} from "./chunk-OEUJDSHY.mjs";
 
 // src/interactive/escapable.ts
 import readline from "readline";
@@ -32,19 +36,16 @@ async function escapableSelect(config, options) {
     }
   };
   process.stdin.on("keypress", onKeypress);
-  try {
-    const result = await select(withEscapeHint(config, options?.escLabel ?? "back"), {
-      signal: controller.signal
-    });
-    return result;
-  } catch (err) {
-    if (err instanceof Error && err.name === "AbortPromptError") {
-      return null;
-    }
-    throw err;
-  } finally {
-    process.stdin.removeListener("keypress", onKeypress);
+  const r = await wrapAsync(
+    () => select(withEscapeHint(config, options?.escLabel ?? "back"), { signal: controller.signal }),
+    ensureError
+  );
+  process.stdin.removeListener("keypress", onKeypress);
+  if (!r.ok) {
+    if (r.error.name === "AbortPromptError") return null;
+    throw r.error;
   }
+  return r.value;
 }
 
 export {

package/dist/{chunk-JON4GCLR.mjs → chunk-DZ6HHTM5.mjs}

@@ -2,7 +2,7 @@
 import {
   createSprint,
   setCurrentSprint
-} from "./chunk-EKMZZRWI.mjs";
+} from "./chunk-LFDW6MWF.mjs";
 import {
   emoji,
   field,

package/dist/chunk-EDJX7TT6.mjs

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+
+// src/errors.ts
+var DomainError = class extends Error {
+  cause;
+  constructor(message, cause) {
+    super(message, cause ? { cause } : void 0);
+    this.name = this.constructor.name;
+    this.cause = cause;
+  }
+};
+var IOError = class extends DomainError {
+  code = "IO_ERROR";
+};
+var StorageError = class extends DomainError {
+  code = "STORAGE_ERROR";
+};
+var LockError = class extends DomainError {
+  code = "LOCK_ERROR";
+  lockPath;
+  constructor(message, lockPath, cause) {
+    super(message, cause);
+    this.lockPath = lockPath;
+  }
+};
+var ParseError = class extends DomainError {
+  code = "PARSE_ERROR";
+};
+var ValidationError = class extends DomainError {
+  code = "VALIDATION_ERROR";
+  path;
+  constructor(message, path, cause) {
+    super(message, cause);
+    this.path = path;
+  }
+};
+function detectSpawnRateLimit(stderr) {
+  const patterns = [/rate.?limit/i, /\b429\b/, /too many requests/i, /overloaded/i, /\b529\b/];
+  const isRateLimited = patterns.some((p) => p.test(stderr));
+  if (!isRateLimited) return { rateLimited: false, retryAfterMs: null };
+  const retryMatch = /retry.?after:?\s*(\d+)/i.exec(stderr);
+  const retryAfterMs = retryMatch?.[1] ? parseInt(retryMatch[1], 10) * 1e3 : null;
+  return { rateLimited: true, retryAfterMs };
+}
+var SpawnError = class extends DomainError {
+  code = "SPAWN_ERROR";
+  stderr;
+  exitCode;
+  rateLimited;
+  retryAfterMs;
+  sessionId;
+  constructor(message, stderr, exitCode, sessionId, cause) {
+    super(message, cause);
+    this.stderr = stderr;
+    this.exitCode = exitCode;
+    this.sessionId = sessionId ?? null;
+    const rl = detectSpawnRateLimit(stderr);
+    this.rateLimited = rl.rateLimited;
+    this.retryAfterMs = rl.retryAfterMs;
+  }
+};
+var SprintNotFoundError = class extends DomainError {
+  code = "SPRINT_NOT_FOUND";
+  sprintId;
+  constructor(sprintId) {
+    super(`Sprint not found: ${sprintId}`);
+    this.sprintId = sprintId;
+  }
+};
+var TaskNotFoundError = class extends DomainError {
+  code = "TASK_NOT_FOUND";
+  taskId;
+  constructor(taskId) {
+    super(`Task not found: ${taskId}`);
+    this.taskId = taskId;
+  }
+};
+var TicketNotFoundError = class extends DomainError {
+  code = "TICKET_NOT_FOUND";
+  ticketId;
+  constructor(ticketId) {
+    super(`Ticket not found: ${ticketId}`);
+    this.ticketId = ticketId;
+  }
+};
+var ProjectNotFoundError = class extends DomainError {
+  code = "PROJECT_NOT_FOUND";
+  projectName;
+  constructor(projectName) {
+    super(`Project not found: ${projectName}`);
+    this.projectName = projectName;
+  }
+};
+var ProjectExistsError = class extends DomainError {
+  code = "PROJECT_EXISTS";
+  projectName;
+  constructor(projectName) {
+    super(`Project already exists: ${projectName}`);
+    this.projectName = projectName;
+  }
+};
+var StatusError = class extends DomainError {
+  code = "STATUS_ERROR";
+};
+var SprintStatusError = class extends StatusError {
+  currentStatus;
+  operation;
+  constructor(message, currentStatus, operation) {
+    super(message);
+    this.currentStatus = currentStatus;
+    this.operation = operation;
+  }
+};
+var NoCurrentSprintError = class extends StatusError {
+  constructor() {
+    super("No sprint specified and no current sprint set.");
+  }
+};
+var DependencyCycleError = class extends DomainError {
+  code = "DEPENDENCY_CYCLE";
+  cycle;
+  constructor(cycle) {
+    super(`Dependency cycle detected: ${cycle.join(" \u2192 ")}`);
+    this.cycle = cycle;
+  }
+};
+var IssueFetchError = class extends DomainError {
+  code = "ISSUE_FETCH_ERROR";
+};
+
+export {
+  DomainError,
+  IOError,
+  StorageError,
+  LockError,
+  ParseError,
+  ValidationError,
+  SpawnError,
+  SprintNotFoundError,
+  TaskNotFoundError,
+  TicketNotFoundError,
+  ProjectNotFoundError,
+  ProjectExistsError,
+  SprintStatusError,
+  NoCurrentSprintError,
+  DependencyCycleError,
+  IssueFetchError
+};

package/dist/{chunk-MNMQC36F.mjs → chunk-F2MMCTB5.mjs}

@@ -4,25 +4,33 @@ import {
   exitWithCode
 } from "./chunk-7TG3EAQ2.mjs";
 import {
-  ProjectNotFoundError,
-  getProject,
   listProjects,
   projectExists
-} from "./chunk-WGHJI3OI.mjs";
+} from "./chunk-PDI6HBZ7.mjs";
 import {
-  SprintStatusError,
   assertSprintStatus,
   generateUuid8,
   getEditor,
   resolveSprintId,
   setEditor
-} from "./chunk-EKMZZRWI.mjs";
+} from "./chunk-LFDW6MWF.mjs";
+import {
+  ensureError,
+  unwrapOrThrow,
+  wrapAsync
+} from "./chunk-OEUJDSHY.mjs";
 import {
   SprintSchema,
   getSprintFilePath,
   readValidatedJson,
   writeValidatedJson
-} from "./chunk-6PYTKGB5.mjs";
+} from "./chunk-W3TY22IS.mjs";
+import {
+  IOError,
+  IssueFetchError,
+  SprintStatusError,
+  TicketNotFoundError
+} from "./chunk-EDJX7TT6.mjs";
 import {
   createSpinner,
   emoji,
@@ -41,9 +49,11 @@ import {
 
 // src/commands/ticket/add.ts
 import { confirm, input, select as select2 } from "@inquirer/prompts";
+import { Result as Result3 } from "typescript-result";
 
 // src/utils/editor-input.ts
 import { editor } from "@inquirer/prompts";
+import { Result } from "typescript-result";
 
 // src/utils/editor.ts
 import { select } from "@inquirer/prompts";
@@ -77,7 +87,8 @@ async function resolveEditor() {
 async function editorInput(options) {
   if (!process.stdin.isTTY) {
     const { multilineInput } = await import("./multiline-OHSNFCRG.mjs");
-    return multilineInput({ message: options.message, default: options.default });
+    const value = await multilineInput({ message: options.message, default: options.default });
+    return Result.ok(value);
   }
   const editorCmd = await resolveEditor();
   const prevVisual = process.env["VISUAL"];
@@ -88,7 +99,14 @@ async function editorInput(options) {
       default: options.default,
       postfix: ".md"
     });
-    return result.trim();
+    return Result.ok(result.trim());
+  } catch (err) {
+    return Result.error(
+      new IOError(
+        `Editor failed: ${err instanceof Error ? err.message : String(err)}`,
+        err instanceof Error ? err : void 0
+      )
+    );
   } finally {
     if (prevVisual === void 0) delete process.env["VISUAL"];
     else process.env["VISUAL"] = prevVisual;
@@ -96,33 +114,21 @@ async function editorInput(options) {
 }
 
 // src/store/ticket.ts
-var TicketNotFoundError = class extends Error {
-  ticketId;
-  constructor(ticketId) {
-    super(`Ticket not found: ${ticketId}`);
-    this.name = "TicketNotFoundError";
-    this.ticketId = ticketId;
-  }
-};
 async function getSprintData(sprintId) {
   const id = await resolveSprintId(sprintId);
-  return readValidatedJson(getSprintFilePath(id), SprintSchema);
+  const result = await readValidatedJson(getSprintFilePath(id), SprintSchema);
+  if (!result.ok) throw result.error;
+  return result.value;
 }
 async function saveSprintData(sprint) {
-  await writeValidatedJson(getSprintFilePath(sprint.id), sprint, SprintSchema);
+  const result = await writeValidatedJson(getSprintFilePath(sprint.id), sprint, SprintSchema);
+  if (!result.ok) throw result.error;
 }
 async function addTicket(input2, sprintId) {
   const sprint = await getSprintData(sprintId);
   assertSprintStatus(sprint, ["draft"], "add tickets");
-  try {
-    await getProject(input2.projectName);
-  } catch (err) {
-    if (err instanceof ProjectNotFoundError) {
-      throw new Error(`Project '${input2.projectName}' does not exist. Add it first with 'ralphctl project add'.`, {
-        cause: err
-      });
-    }
-    throw err;
+  if (!await projectExists(input2.projectName)) {
+    throw new Error(`Project '${input2.projectName}' does not exist. Add it first with 'ralphctl project add'.`);
   }
   const ticket = {
     id: generateUuid8(),
@@ -205,6 +211,7 @@ function formatTicketId(ticket) {
 
 // src/utils/issue-fetch.ts
 import { spawnSync } from "child_process";
+import { Result as Result2 } from "typescript-result";
 var MAX_COMMENTS = 20;
 function parseIssueUrl(url) {
   let parsed;
@@ -241,7 +248,7 @@ function parseIssueUrl(url) {
   }
   return null;
 }
-function fetchGitHubIssue(parsed) {
+function fetchGitHubIssueResult(parsed) {
   const result = spawnSync(
     "gh",
     [
@@ -257,7 +264,7 @@ function fetchGitHubIssue(parsed) {
   );
   if (result.status !== 0) {
     const stderr = result.stderr.trim();
-    throw new IssueFetchError(`gh issue view failed: ${stderr || "unknown error"}`);
+    return Result2.error(new IssueFetchError(`gh issue view failed: ${stderr || "unknown error"}`));
   }
   const data = JSON.parse(result.stdout);
   const comments = (data.comments ?? []).slice(-MAX_COMMENTS).map((c) => ({
@@ -265,14 +272,14 @@ function fetchGitHubIssue(parsed) {
     createdAt: c.createdAt ?? "",
     body: c.body ?? ""
   }));
-  return {
+  return Result2.ok({
     title: data.title ?? "",
     body: data.body ?? "",
     comments,
     url: `https://${parsed.hostname}/${parsed.owner}/${parsed.repo}/issues/${String(parsed.number)}`
-  };
+  });
 }
-function fetchGitLabIssue(parsed) {
+function fetchGitLabIssueResult(parsed) {
   const result = spawnSync(
     "glab",
     ["issue", "view", String(parsed.number), "--repo", `${parsed.owner}/${parsed.repo}`, "--output", "json"],
@@ -280,7 +287,7 @@ function fetchGitLabIssue(parsed) {
   );
   if (result.status !== 0) {
     const stderr = result.stderr.trim();
-    throw new IssueFetchError(`glab issue view failed: ${stderr || "unknown error"}`);
+    return Result2.error(new IssueFetchError(`glab issue view failed: ${stderr || "unknown error"}`));
   }
   const data = JSON.parse(result.stdout);
   const notesResult = spawnSync(
@@ -300,18 +307,21 @@ function fetchGitLabIssue(parsed) {
     } catch {
     }
   }
-  return {
+  return Result2.ok({
     title: data.title ?? "",
     body: data.description ?? "",
     comments,
     url: `https://${parsed.hostname}/${parsed.owner}/${parsed.repo}/-/issues/${String(parsed.number)}`
-  };
+  });
 }
-function fetchIssue(parsed) {
+function fetchIssueResult(parsed) {
   if (parsed.host === "github") {
-    return fetchGitHubIssue(parsed);
+    return fetchGitHubIssueResult(parsed);
   }
-  return fetchGitLabIssue(parsed);
+  return fetchGitLabIssueResult(parsed);
+}
+function fetchIssue(parsed) {
+  return unwrapOrThrow(fetchIssueResult(parsed));
 }
 function fetchIssueFromUrl(url) {
   const parsed = parseIssueUrl(url);
@@ -346,30 +356,19 @@ function formatIssueContext(data) {
   }
   return lines.join("\n");
 }
-var IssueFetchError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "IssueFetchError";
-  }
-};
 
 // src/commands/ticket/add.ts
 function tryFetchIssue(url) {
   const spinner = createSpinner("Fetching issue data...");
   spinner.start();
-  let data;
-  try {
-    data = fetchIssueFromUrl(url);
-  } catch (err) {
+  const fetchR = Result3.try(() => fetchIssueFromUrl(url));
+  if (!fetchR.ok) {
     spinner.fail("Could not fetch issue data");
-    if (err instanceof IssueFetchError) {
-      showWarning(err.message);
-    } else if (err instanceof Error) {
-      showWarning(err.message);
-    }
+    showWarning(fetchR.error.message);
     log.newline();
     return void 0;
   }
+  const data = fetchR.value;
   if (!data) {
     spinner.stop();
     return void 0;
@@ -422,17 +421,12 @@ async function addSingleTicketNonInteractive(options) {
   const trimmedLink = options.link?.trim();
   const link = trimmedLink === "" ? void 0 : trimmedLink;
   const projectName = trimmedProject;
-  try {
-    const ticket = await addTicket({
-      title,
-      description,
-      link,
-      projectName
-    });
-    showTicketResult(ticket);
-  } catch (err) {
-    handleTicketError(err);
+  const addR = await wrapAsync(() => addTicket({ title, description, link, projectName }), ensureError);
+  if (!addR.ok) {
+    handleTicketError(addR.error);
+    return;
   }
+  showTicketResult(addR.value);
 }
 async function addSingleTicketInteractive(options) {
   const projects = await listProjects();
@@ -467,26 +461,28 @@ async function addSingleTicketInteractive(options) {
     default: prefill?.title ?? options.title?.trim(),
     validate: (v) => v.trim().length > 0 ? true : "Title is required"
   });
-  const description = await editorInput({
+  const descR = await editorInput({
     message: "Description (recommended):",
     default: prefill?.body ?? options.description?.trim()
   });
+  if (!descR.ok) {
+    showError(`Editor input failed: ${descR.error.message}`);
+    return null;
+  }
+  const description = descR.value;
   title = title.trim();
   const trimmedDescription = description.trim();
   const normalizedDescription = trimmedDescription === "" ? void 0 : trimmedDescription;
-  try {
-    const ticket = await addTicket({
-      title,
-      description: normalizedDescription,
-      link: normalizedLink,
-      projectName
-    });
-    showTicketResult(ticket);
-    return ticket;
-  } catch (err) {
-    handleTicketError(err);
+  const addR = await wrapAsync(
+    () => addTicket({ title, description: normalizedDescription, link: normalizedLink, projectName }),
+    ensureError
+  );
+  if (!addR.ok) {
+    handleTicketError(addR.error);
     return null;
   }
+  showTicketResult(addR.value);
+  return addR.value;
 }
 function showTicketResult(ticket) {
   showSuccess("Ticket added!", [
@@ -536,7 +532,6 @@ async function ticketAddCommand(options = {}) {
 }
 
 export {
-  TicketNotFoundError,
   addTicket,
   updateTicket,
   removeTicket,
@@ -550,7 +545,6 @@ export {
   editorInput,
   fetchIssueFromUrl,
   formatIssueContext,
-  IssueFetchError,
   addSingleTicketInteractive,
   ticketAddCommand
 };