ralphctl 0.1.1 → 0.1.3

package/dist/chunk-OEUJDSHY.mjs

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+// src/utils/result-helpers.ts
+import { Result } from "typescript-result";
+async function wrapAsync(fn, mapError) {
+  try {
+    const value = await fn();
+    return Result.ok(value);
+  } catch (err) {
+    return Result.error(mapError(err));
+  }
+}
+function ensureError(err) {
+  return err instanceof Error ? err : new Error(String(err));
+}
+function unwrapOrThrow(result) {
+  if (result.ok) {
+    return result.value;
+  }
+  throw result.error;
+}
+
+export {
+  wrapAsync,
+  ensureError,
+  unwrapOrThrow
+};

package/dist/{chunk-35KGXPBU.mjs → chunk-PDI6HBZ7.mjs}

@@ -1,31 +1,22 @@
 #!/usr/bin/env node
 import {
   ProjectsSchema,
+  expandTilde,
   fileExists,
   getProjectsFilePath,
   readValidatedJson,
   validateProjectPath,
   writeValidatedJson
-} from "./chunk-4C24UQ3X.mjs";
+} from "./chunk-W3TY22IS.mjs";
+import {
+  ParseError,
+  ProjectExistsError,
+  ProjectNotFoundError,
+  ValidationError
+} from "./chunk-EDJX7TT6.mjs";
 
 // src/store/project.ts
 import { basename, resolve } from "path";
-var ProjectNotFoundError = class extends Error {
-  projectName;
-  constructor(projectName) {
-    super(`Project not found: ${projectName}`);
-    this.name = "ProjectNotFoundError";
-    this.projectName = projectName;
-  }
-};
-var ProjectExistsError = class extends Error {
-  projectName;
-  constructor(projectName) {
-    super(`Project already exists: ${projectName}`);
-    this.name = "ProjectExistsError";
-    this.projectName = projectName;
-  }
-};
 function migrateProjectIfNeeded(project) {
   if (project.repositories) {
     return project;
@@ -36,12 +27,12 @@ function migrateProjectIfNeeded(project) {
       displayName: project.displayName,
       repositories: project.paths.map((p) => ({
         name: basename(p),
-        path: p
+        path: resolve(expandTilde(p))
       })),
       description: project.description
     };
   }
-  throw new Error(`Invalid project data: no paths or repositories for ${project.name}`);
+  throw new ParseError(`Invalid project data: no paths or repositories for ${project.name}`);
 }
 async function listProjects() {
   const filePath = getProjectsFilePath();
@@ -55,10 +46,27 @@ async function listProjects() {
   if (needsMigration) {
     const migrated = rawData.map(migrateProjectIfNeeded);
     const validated = ProjectsSchema.parse(migrated);
-    await writeValidatedJson(filePath, validated, ProjectsSchema);
+    const writeResult = await writeValidatedJson(filePath, validated, ProjectsSchema);
+    if (!writeResult.ok) throw writeResult.error;
+    return validated;
+  }
+  const result = await readValidatedJson(filePath, ProjectsSchema);
+  if (!result.ok) throw result.error;
+  const projects = result.value;
+  const hasTildePaths = projects.some((p) => p.repositories.some((r) => r.path.startsWith("~")));
+  if (hasTildePaths) {
+    const corrected = projects.map((project) => ({
+      ...project,
+      repositories: project.repositories.map(
+        (repo) => repo.path.startsWith("~") ? { ...repo, path: resolve(expandTilde(repo.path)) } : repo
+      )
+    }));
+    const validated = ProjectsSchema.parse(corrected);
+    const writeResult = await writeValidatedJson(filePath, validated, ProjectsSchema);
+    if (!writeResult.ok) throw writeResult.error;
     return validated;
   }
-  return readValidatedJson(filePath, ProjectsSchema);
+  return projects;
 }
 async function getProject(name) {
   const projects = await listProjects();
@@ -79,26 +87,27 @@ async function createProject(project) {
   }
   const pathErrors = [];
   for (const repo of project.repositories) {
-    const resolved = resolve(repo.path);
+    const resolved = resolve(expandTilde(repo.path));
     const validation = await validateProjectPath(resolved);
-    if (validation !== true) {
-      pathErrors.push(`  ${repo.path}: ${validation}`);
+    if (!validation.ok) {
+      pathErrors.push(`  ${repo.path}: ${validation.error.message}`);
     }
   }
   if (pathErrors.length > 0) {
-    throw new Error(`Invalid project paths:
-${pathErrors.join("\n")}`);
+    throw new ValidationError(`Invalid project paths:
+${pathErrors.join("\n")}`, "repositories");
   }
   const normalizedProject = {
     ...project,
     repositories: project.repositories.map((repo) => ({
       ...repo,
       name: repo.name || basename(repo.path),
-      path: resolve(repo.path)
+      path: resolve(expandTilde(repo.path))
     }))
   };
   projects.push(normalizedProject);
-  await writeValidatedJson(getProjectsFilePath(), projects, ProjectsSchema);
+  const writeResult = await writeValidatedJson(getProjectsFilePath(), projects, ProjectsSchema);
+  if (!writeResult.ok) throw writeResult.error;
   return normalizedProject;
 }
 async function updateProject(name, updates) {
@@ -110,20 +119,20 @@ async function updateProject(name, updates) {
   if (updates.repositories) {
     const pathErrors = [];
     for (const repo of updates.repositories) {
-      const resolved = resolve(repo.path);
+      const resolved = resolve(expandTilde(repo.path));
       const validation = await validateProjectPath(resolved);
-      if (validation !== true) {
-        pathErrors.push(`  ${repo.path}: ${validation}`);
+      if (!validation.ok) {
+        pathErrors.push(`  ${repo.path}: ${validation.error.message}`);
       }
     }
     if (pathErrors.length > 0) {
-      throw new Error(`Invalid project paths:
-${pathErrors.join("\n")}`);
+      throw new ValidationError(`Invalid project paths:
+${pathErrors.join("\n")}`, "repositories");
     }
     updates.repositories = updates.repositories.map((repo) => ({
       ...repo,
       name: repo.name || basename(repo.path),
-      path: resolve(repo.path)
+      path: resolve(expandTilde(repo.path))
     }));
   }
   const existingProject = projects[index];
@@ -137,7 +146,8 @@ ${pathErrors.join("\n")}`);
     description: updates.description ?? existingProject.description
   };
   projects[index] = updatedProject;
-  await writeValidatedJson(getProjectsFilePath(), projects, ProjectsSchema);
+  const writeResult = await writeValidatedJson(getProjectsFilePath(), projects, ProjectsSchema);
+  if (!writeResult.ok) throw writeResult.error;
   return updatedProject;
 }
 async function removeProject(name) {
@@ -147,7 +157,8 @@ async function removeProject(name) {
     throw new ProjectNotFoundError(name);
   }
   projects.splice(index, 1);
-  await writeValidatedJson(getProjectsFilePath(), projects, ProjectsSchema);
+  const writeResult = await writeValidatedJson(getProjectsFilePath(), projects, ProjectsSchema);
+  if (!writeResult.ok) throw writeResult.error;
 }
 async function getProjectRepos(name) {
   const project = await getProject(name);
@@ -155,10 +166,10 @@ async function getProjectRepos(name) {
 }
 async function addProjectRepo(name, repo) {
   const project = await getProject(name);
-  const resolvedPath = resolve(repo.path);
+  const resolvedPath = resolve(expandTilde(repo.path));
   const validation = await validateProjectPath(resolvedPath);
-  if (validation !== true) {
-    throw new Error(`Invalid path ${repo.path}: ${validation}`);
+  if (!validation.ok) {
+    throw new ValidationError(`Invalid path ${repo.path}: ${validation.error.message}`, repo.path);
   }
   if (project.repositories.some((r) => r.path === resolvedPath)) {
     return project;
@@ -174,10 +185,10 @@ async function addProjectRepo(name, repo) {
 }
 async function removeProjectRepo(name, path) {
   const project = await getProject(name);
-  const resolvedPath = resolve(path);
+  const resolvedPath = resolve(expandTilde(path));
   const newRepos = project.repositories.filter((r) => r.path !== resolvedPath);
   if (newRepos.length === 0) {
-    throw new Error("Cannot remove the last repository from a project");
+    throw new ValidationError("Cannot remove the last repository from a project", "repositories");
   }
   if (newRepos.length === project.repositories.length) {
     return project;
@@ -186,8 +197,6 @@ async function removeProjectRepo(name, path) {
 }
 
 export {
-  ProjectNotFoundError,
-  ProjectExistsError,
   listProjects,
   getProject,
   projectExists,

package/dist/{chunk-4C24UQ3X.mjs → chunk-W3TY22IS.mjs}

@@ -1,4 +1,9 @@
 #!/usr/bin/env node
+import {
+  IOError,
+  StorageError,
+  ValidationError
+} from "./chunk-EDJX7TT6.mjs";
 
 // src/utils/paths.ts
 import { fileURLToPath } from "url";
@@ -6,6 +11,7 @@ import { dirname, isAbsolute, join, resolve, sep } from "path";
 import { existsSync } from "fs";
 import { homedir } from "os";
 import { lstat, realpath, stat } from "fs/promises";
+import { Result } from "typescript-result";
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname(__filename);
 function getRepoRoot() {
@@ -67,46 +73,38 @@ function assertSafeCwd(path) {
     throw new Error(`Unsafe path for cwd: must be absolute, got: ${path}`);
   }
 }
+function expandTilde(path) {
+  if (path === "~") return homedir();
+  if (path.startsWith("~/")) return homedir() + path.slice(1);
+  return path;
+}
 async function validateProjectPath(path) {
   try {
-    const resolved = resolve(path);
+    const resolved = resolve(expandTilde(path));
     const lstats = await lstat(resolved);
     if (lstats.isSymbolicLink()) {
       const realPath = await realpath(resolved);
       const realStats = await stat(realPath);
       if (!realStats.isDirectory()) {
-        return "Symlink target is not a directory";
+        return Result.error(new IOError("Symlink target is not a directory"));
       }
-      return true;
+      return Result.ok(true);
     }
     if (!lstats.isDirectory()) {
-      return "Path is not a directory";
+      return Result.error(new IOError("Path is not a directory"));
     }
-    return true;
-  } catch {
-    return "Directory does not exist";
+    return Result.ok(true);
+  } catch (err) {
+    const code = err.code;
+    const message = code === "EACCES" ? "Permission denied" : "Directory does not exist";
+    return Result.error(new IOError(message, err instanceof Error ? err : void 0));
   }
 }
 
 // src/utils/storage.ts
 import { access, appendFile, mkdir, readdir, readFile, rm, writeFile } from "fs/promises";
 import { dirname as dirname2 } from "path";
-var ValidationError = class extends Error {
-  path;
-  constructor(message, path, cause) {
-    super(message, { cause });
-    this.name = "ValidationError";
-    this.path = path;
-  }
-};
-var FileNotFoundError = class extends Error {
-  path;
-  constructor(message, path) {
-    super(message);
-    this.name = "FileNotFoundError";
-    this.path = path;
-  }
-};
+import { Result as Result2 } from "typescript-result";
 async function ensureDir(dirPath) {
   await mkdir(dirPath, { recursive: true });
 }
@@ -135,46 +133,61 @@ async function readValidatedJson(filePath, schema) {
     content = await readFile(filePath, "utf-8");
   } catch (err) {
     if (err instanceof Error && "code" in err && err.code === "ENOENT") {
-      throw new FileNotFoundError(`File not found: ${filePath}`, filePath);
+      return Result2.error(new StorageError(`File not found: ${filePath}`, err instanceof Error ? err : void 0));
     }
-    throw err;
+    return Result2.error(new StorageError(`Failed to read ${filePath}`, err instanceof Error ? err : void 0));
   }
   let data;
   try {
     data = JSON.parse(content);
   } catch (err) {
-    throw new ValidationError(`Invalid JSON in ${filePath}`, filePath, err);
+    return Result2.error(
+      new ValidationError(`Invalid JSON in ${filePath}`, filePath, err instanceof Error ? err : void 0)
+    );
   }
   const result = schema.safeParse(data);
   if (!result.success) {
     const issues = result.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
-    throw new ValidationError(`Validation failed for ${filePath}:
-${issues}`, filePath, result.error);
+    return Result2.error(new ValidationError(`Validation failed for ${filePath}:
+${issues}`, filePath, result.error));
   }
-  return result.data;
+  return Result2.ok(result.data);
 }
 async function writeValidatedJson(filePath, data, schema) {
   const result = schema.safeParse(data);
   if (!result.success) {
     const issues = result.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
-    throw new ValidationError(`Validation failed before writing to ${filePath}:
-${issues}`, filePath, result.error);
+    return Result2.error(
+      new ValidationError(`Validation failed before writing to ${filePath}:
+${issues}`, filePath, result.error)
+    );
+  }
+  try {
+    await ensureDir(dirname2(filePath));
+    await writeFile(filePath, JSON.stringify(result.data, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
+  } catch (err) {
+    return Result2.error(new StorageError(`Failed to write ${filePath}`, err instanceof Error ? err : void 0));
   }
-  await ensureDir(dirname2(filePath));
-  await writeFile(filePath, JSON.stringify(result.data, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
+  return Result2.ok(void 0);
 }
 async function appendToFile(filePath, content) {
-  await ensureDir(dirname2(filePath));
-  await appendFile(filePath, content, { encoding: "utf-8", mode: 384 });
+  try {
+    await ensureDir(dirname2(filePath));
+    await appendFile(filePath, content, { encoding: "utf-8", mode: 384 });
+    return Result2.ok(void 0);
+  } catch (err) {
+    return Result2.error(new StorageError(`Failed to append to ${filePath}`, err instanceof Error ? err : void 0));
+  }
 }
 async function readTextFile(filePath) {
   try {
-    return await readFile(filePath, "utf-8");
+    const content = await readFile(filePath, "utf-8");
+    return Result2.ok(content);
   } catch (err) {
     if (err instanceof Error && "code" in err && err.code === "ENOENT") {
-      throw new FileNotFoundError(`File not found: ${filePath}`, filePath);
+      return Result2.error(new StorageError(`File not found: ${filePath}`, err instanceof Error ? err : void 0));
     }
-    throw err;
+    return Result2.error(new StorageError(`Failed to read ${filePath}`, err instanceof Error ? err : void 0));
   }
 }
 
@@ -285,9 +298,8 @@ export {
   getIdeateDir,
   getSchemaPath,
   assertSafeCwd,
+  expandTilde,
   validateProjectPath,
-  ValidationError,
-  FileNotFoundError,
   ensureDir,
   removeDir,
   fileExists,