ralphctl 0.1.0 → 0.1.2

package/dist/chunk-WGHJI3OI.mjs

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+import {
+  ProjectsSchema,
+  expandTilde,
+  fileExists,
+  getProjectsFilePath,
+  readValidatedJson,
+  validateProjectPath,
+  writeValidatedJson
+} from "./chunk-6PYTKGB5.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;
+  }
+  if (project.paths) {
+    return {
+      name: project.name,
+      displayName: project.displayName,
+      repositories: project.paths.map((p) => ({
+        name: basename(p),
+        path: resolve(expandTilde(p))
+      })),
+      description: project.description
+    };
+  }
+  throw new Error(`Invalid project data: no paths or repositories for ${project.name}`);
+}
+async function listProjects() {
+  const filePath = getProjectsFilePath();
+  if (!await fileExists(filePath)) {
+    return [];
+  }
+  const { readFile } = await import("fs/promises");
+  const content = await readFile(filePath, "utf-8");
+  const rawData = JSON.parse(content);
+  const needsMigration = rawData.some((p) => p.paths && !p.repositories);
+  if (needsMigration) {
+    const migrated = rawData.map(migrateProjectIfNeeded);
+    const validated = ProjectsSchema.parse(migrated);
+    await writeValidatedJson(filePath, validated, ProjectsSchema);
+    return validated;
+  }
+  const projects = await readValidatedJson(filePath, ProjectsSchema);
+  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);
+    await writeValidatedJson(filePath, validated, ProjectsSchema);
+    return validated;
+  }
+  return projects;
+}
+async function getProject(name) {
+  const projects = await listProjects();
+  const project = projects.find((p) => p.name === name);
+  if (!project) {
+    throw new ProjectNotFoundError(name);
+  }
+  return project;
+}
+async function projectExists(name) {
+  const projects = await listProjects();
+  return projects.some((p) => p.name === name);
+}
+async function createProject(project) {
+  const projects = await listProjects();
+  if (projects.some((p) => p.name === project.name)) {
+    throw new ProjectExistsError(project.name);
+  }
+  const pathErrors = [];
+  for (const repo of project.repositories) {
+    const resolved = resolve(expandTilde(repo.path));
+    const validation = await validateProjectPath(resolved);
+    if (validation !== true) {
+      pathErrors.push(`  ${repo.path}: ${validation}`);
+    }
+  }
+  if (pathErrors.length > 0) {
+    throw new Error(`Invalid project paths:
+${pathErrors.join("\n")}`);
+  }
+  const normalizedProject = {
+    ...project,
+    repositories: project.repositories.map((repo) => ({
+      ...repo,
+      name: repo.name || basename(repo.path),
+      path: resolve(expandTilde(repo.path))
+    }))
+  };
+  projects.push(normalizedProject);
+  await writeValidatedJson(getProjectsFilePath(), projects, ProjectsSchema);
+  return normalizedProject;
+}
+async function updateProject(name, updates) {
+  const projects = await listProjects();
+  const index = projects.findIndex((p) => p.name === name);
+  if (index === -1) {
+    throw new ProjectNotFoundError(name);
+  }
+  if (updates.repositories) {
+    const pathErrors = [];
+    for (const repo of updates.repositories) {
+      const resolved = resolve(expandTilde(repo.path));
+      const validation = await validateProjectPath(resolved);
+      if (validation !== true) {
+        pathErrors.push(`  ${repo.path}: ${validation}`);
+      }
+    }
+    if (pathErrors.length > 0) {
+      throw new Error(`Invalid project paths:
+${pathErrors.join("\n")}`);
+    }
+    updates.repositories = updates.repositories.map((repo) => ({
+      ...repo,
+      name: repo.name || basename(repo.path),
+      path: resolve(expandTilde(repo.path))
+    }));
+  }
+  const existingProject = projects[index];
+  if (!existingProject) {
+    throw new ProjectNotFoundError(name);
+  }
+  const updatedProject = {
+    name: existingProject.name,
+    displayName: updates.displayName ?? existingProject.displayName,
+    repositories: updates.repositories ?? existingProject.repositories,
+    description: updates.description ?? existingProject.description
+  };
+  projects[index] = updatedProject;
+  await writeValidatedJson(getProjectsFilePath(), projects, ProjectsSchema);
+  return updatedProject;
+}
+async function removeProject(name) {
+  const projects = await listProjects();
+  const index = projects.findIndex((p) => p.name === name);
+  if (index === -1) {
+    throw new ProjectNotFoundError(name);
+  }
+  projects.splice(index, 1);
+  await writeValidatedJson(getProjectsFilePath(), projects, ProjectsSchema);
+}
+async function getProjectRepos(name) {
+  const project = await getProject(name);
+  return project.repositories;
+}
+async function addProjectRepo(name, repo) {
+  const project = await getProject(name);
+  const resolvedPath = resolve(expandTilde(repo.path));
+  const validation = await validateProjectPath(resolvedPath);
+  if (validation !== true) {
+    throw new Error(`Invalid path ${repo.path}: ${validation}`);
+  }
+  if (project.repositories.some((r) => r.path === resolvedPath)) {
+    return project;
+  }
+  const normalizedRepo = {
+    ...repo,
+    name: repo.name || basename(resolvedPath),
+    path: resolvedPath
+  };
+  return updateProject(name, {
+    repositories: [...project.repositories, normalizedRepo]
+  });
+}
+async function removeProjectRepo(name, path) {
+  const project = await getProject(name);
+  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");
+  }
+  if (newRepos.length === project.repositories.length) {
+    return project;
+  }
+  return updateProject(name, { repositories: newRepos });
+}
+
+export {
+  ProjectNotFoundError,
+  ProjectExistsError,
+  listProjects,
+  getProject,
+  projectExists,
+  createProject,
+  updateProject,
+  removeProject,
+  getProjectRepos,
+  addProjectRepo,
+  removeProjectRepo
+};