ralphctl 0.1.2 → 0.1.4

package/dist/{chunk-EKMZZRWI.mjs → chunk-LFDW6MWF.mjs}

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
+import {
+  unwrapOrThrow
+} from "./chunk-OEUJDSHY.mjs";
 import {
   ConfigSchema,
-  FileNotFoundError,
   SprintSchema,
   TasksSchema,
-  ValidationError,
   appendToFile,
   assertSafeCwd,
   ensureDir,
@@ -20,7 +21,14 @@ import {
   readValidatedJson,
   removeDir,
   writeValidatedJson
-} from "./chunk-6PYTKGB5.mjs";
+} from "./chunk-W3TY22IS.mjs";
+import {
+  LockError,
+  NoCurrentSprintError,
+  SprintNotFoundError,
+  SprintStatusError,
+  StorageError
+} from "./chunk-EDJX7TT6.mjs";
 import {
   log
 } from "./chunk-QBXHAXHI.mjs";
@@ -36,10 +44,10 @@ async function getConfig() {
   if (!await fileExists(configPath)) {
     return DEFAULT_CONFIG;
   }
-  return readValidatedJson(configPath, ConfigSchema);
+  return unwrapOrThrow(await readValidatedJson(configPath, ConfigSchema));
 }
 async function saveConfig(config) {
-  await writeValidatedJson(getConfigPath(), config, ConfigSchema);
+  unwrapOrThrow(await writeValidatedJson(getConfigPath(), config, ConfigSchema));
 }
 async function getCurrentSprint() {
   const config = await getConfig();
@@ -91,14 +99,7 @@ import { execSync } from "child_process";
 // src/utils/file-lock.ts
 import { mkdir, readFile, unlink, writeFile } from "fs/promises";
 import { dirname } from "path";
-var LockAcquisitionError = class extends Error {
-  lockPath;
-  constructor(message, lockPath) {
-    super(message);
-    this.name = "LockAcquisitionError";
-    this.lockPath = lockPath;
-  }
-};
+import { Result } from "typescript-result";
 var parsed = parseInt(process.env["RALPHCTL_LOCK_TIMEOUT_MS"] ?? "", 10);
 var LOCK_TIMEOUT_MS = parsed > 0 && parsed <= 36e5 ? parsed : 3e4;
 var RETRY_DELAY_MS = 50;
@@ -138,12 +139,12 @@ async function acquireLock(filePath) {
     try {
       await mkdir(dirname(lockPath), { recursive: true });
       await writeFile(lockPath, JSON.stringify(lockInfo), { flag: "wx", mode: 384 });
-      return async () => {
+      return Result.ok(async () => {
         try {
           await unlink(lockPath);
         } catch {
         }
-      };
+      });
     } catch (err) {
       if (err instanceof Error && "code" in err && err.code === "EEXIST") {
         if (await isLockStale(lockPath)) {
@@ -157,15 +158,26 @@ async function acquireLock(filePath) {
         await sleep(RETRY_DELAY_MS);
         continue;
       }
-      throw err;
+      return Result.error(
+        new LockError(
+          `Failed to acquire lock: ${err instanceof Error ? err.message : String(err)}`,
+          lockPath,
+          err instanceof Error ? err : void 0
+        )
+      );
     }
   }
-  throw new LockAcquisitionError(`Failed to acquire lock after ${String(MAX_RETRIES)} retries`, lockPath);
+  return Result.error(new LockError(`Failed to acquire lock after ${String(MAX_RETRIES)} retries`, lockPath));
 }
 async function withFileLock(filePath, fn) {
-  const release = await acquireLock(filePath);
+  const lockResult = await acquireLock(filePath);
+  if (!lockResult.ok) {
+    return lockResult;
+  }
+  const release = lockResult.value;
   try {
-    return await fn();
+    const value = await fn();
+    return Result.ok(value);
   } finally {
     await release();
   }
@@ -188,9 +200,11 @@ ${projectMarker}${message}
 
 `;
   const progressPath = getProgressFilePath(id);
-  await withFileLock(progressPath, async () => {
-    await appendToFile(progressPath, entry);
+  const lockResult = await withFileLock(progressPath, async () => {
+    const appendResult = await appendToFile(progressPath, entry);
+    if (!appendResult.ok) throw appendResult.error;
   });
+  if (!lockResult.ok) throw lockResult.error;
 }
 function isExecError(err) {
   return err instanceof Error && typeof err["status"] === "number";
@@ -251,18 +265,19 @@ async function logBaselines(options) {
   lines.push("");
   lines.push("---");
   lines.push("");
-  await appendToFile(getProgressFilePath(sprintId), lines.join("\n"));
+  const appendResult = await appendToFile(getProgressFilePath(sprintId), lines.join("\n"));
+  if (!appendResult.ok) throw appendResult.error;
 }
 async function getProgress(sprintId) {
   const id = await resolveSprintId(sprintId);
-  try {
-    return await readTextFile(getProgressFilePath(id));
-  } catch (err) {
-    if (err instanceof FileNotFoundError) {
+  const result = await readTextFile(getProgressFilePath(id));
+  if (!result.ok) {
+    if (result.error instanceof StorageError && result.error.cause?.code === "ENOENT") {
       return "";
     }
-    throw err;
+    throw result.error;
   }
+  return result.value;
 }
 function summarizeProgressForContext(progress, projectPath, maxEntries = 3) {
   const filtered = filterProgressByProject(progress, projectPath);
@@ -323,30 +338,6 @@ function filterProgressByProject(progress, projectPath) {
 }
 
 // src/store/sprint.ts
-var SprintNotFoundError = class extends Error {
-  sprintId;
-  constructor(sprintId) {
-    super(`Sprint not found: ${sprintId}`);
-    this.name = "SprintNotFoundError";
-    this.sprintId = sprintId;
-  }
-};
-var SprintStatusError = class extends Error {
-  currentStatus;
-  operation;
-  constructor(message, currentStatus, operation) {
-    super(message);
-    this.name = "SprintStatusError";
-    this.currentStatus = currentStatus;
-    this.operation = operation;
-  }
-};
-var NoCurrentSprintError = class extends Error {
-  constructor() {
-    super("No sprint specified and no current sprint set.");
-    this.name = "NoCurrentSprintError";
-  }
-};
 function assertSprintStatus(sprint, allowedStatuses, operation) {
   if (!allowedStatuses.includes(sprint.status)) {
     const statusText = allowedStatuses.join(" or ");
@@ -391,15 +382,21 @@ async function createSprint(name) {
   };
   const sprintDir = getSprintDir(id);
   await ensureDir(sprintDir);
-  await writeValidatedJson(getSprintFilePath(id), sprint, SprintSchema);
-  await writeValidatedJson(getTasksFilePath(id), [], TasksSchema);
-  await appendToFile(getProgressFilePath(id), `# Sprint: ${displayName}
+  const writeSprintResult = await writeValidatedJson(getSprintFilePath(id), sprint, SprintSchema);
+  if (!writeSprintResult.ok) throw writeSprintResult.error;
+  const writeTasksResult = await writeValidatedJson(getTasksFilePath(id), [], TasksSchema);
+  if (!writeTasksResult.ok) throw writeTasksResult.error;
+  const appendResult = await appendToFile(
+    getProgressFilePath(id),
+    `# Sprint: ${displayName}
 
 Created: ${now}
 
 ---
 
-`);
+`
+  );
+  if (!appendResult.ok) throw appendResult.error;
   return sprint;
 }
 async function findActiveSprint() {
@@ -411,25 +408,24 @@ async function getSprint(sprintId) {
   if (!await fileExists(sprintPath)) {
     throw new SprintNotFoundError(sprintId);
   }
-  return readValidatedJson(sprintPath, SprintSchema);
+  const result = await readValidatedJson(sprintPath, SprintSchema);
+  if (!result.ok) throw result.error;
+  return result.value;
 }
 async function saveSprint(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 listSprints() {
   const sprintsDir = getSprintsDir();
   const dirs = await listDirs(sprintsDir);
   const sprints = [];
   for (const dir of dirs) {
-    try {
-      const sprint = await getSprint(dir);
-      sprints.push(sprint);
-    } catch (err) {
-      if (err instanceof ValidationError || err instanceof SprintNotFoundError) {
-        continue;
-      }
-      throw err;
-    }
+    const sprintPath = getSprintFilePath(dir);
+    if (!await fileExists(sprintPath)) continue;
+    const result = await readValidatedJson(sprintPath, SprintSchema);
+    if (!result.ok) continue;
+    sprints.push(result.value);
   }
   return sprints.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
 }
@@ -439,7 +435,9 @@ async function activateSprint(sprintId) {
   sprint.status = "active";
   sprint.activatedAt = (/* @__PURE__ */ new Date()).toISOString();
   await saveSprint(sprint);
-  const tasks = await readValidatedJson(getTasksFilePath(sprintId), TasksSchema);
+  const tasksResult = await readValidatedJson(getTasksFilePath(sprintId), TasksSchema);
+  if (!tasksResult.ok) throw tasksResult.error;
+  const tasks = tasksResult.value;
   const projectPaths = tasks.map((t) => t.projectPath).filter((p) => !!p);
   if (projectPaths.length > 0) {
     await logBaselines({
@@ -503,9 +501,6 @@ export {
   logProgress,
   getProgress,
   summarizeProgressForContext,
-  SprintNotFoundError,
-  SprintStatusError,
-  NoCurrentSprintError,
   assertSprintStatus,
   createSprint,
   findActiveSprint,