ralphctl 0.2.5 → 0.3.0

package/dist/chunk-HL4ZMHCQ.mjs

@@ -0,0 +1,261 @@
+#!/usr/bin/env node
+import {
+  assertSprintStatus,
+  resolveSprintId
+} from "./chunk-YCDUVPRT.mjs";
+import {
+  unwrapOrThrow
+} from "./chunk-IWXBJD2D.mjs";
+import {
+  SprintSchema,
+  generateUuid8,
+  getSprintFilePath,
+  readValidatedJson,
+  writeValidatedJson
+} from "./chunk-CTP2A436.mjs";
+import {
+  IssueFetchError,
+  TicketNotFoundError
+} from "./chunk-57UWLHRH.mjs";
+
+// src/integration/persistence/ticket.ts
+async function getSprintData(sprintId) {
+  const id = await resolveSprintId(sprintId);
+  const result = await readValidatedJson(getSprintFilePath(id), SprintSchema);
+  if (!result.ok) throw result.error;
+  return result.value;
+}
+async function saveSprintData(sprint) {
+  const result = await writeValidatedJson(getSprintFilePath(sprint.id), sprint, SprintSchema);
+  if (!result.ok) throw result.error;
+}
+async function addTicket(input, sprintId) {
+  const sprint = await getSprintData(sprintId);
+  assertSprintStatus(sprint, ["draft"], "add tickets");
+  const ticket = {
+    id: generateUuid8(),
+    title: input.title,
+    description: input.description,
+    link: input.link,
+    affectedRepoIds: input.affectedRepoIds,
+    requirementStatus: "pending"
+  };
+  sprint.tickets.push(ticket);
+  await saveSprintData(sprint);
+  return ticket;
+}
+async function updateTicket(ticketId, updates, sprintId) {
+  const sprint = await getSprintData(sprintId);
+  assertSprintStatus(sprint, ["draft"], "update tickets");
+  const ticketIdx = sprint.tickets.findIndex((t) => t.id === ticketId);
+  if (ticketIdx === -1) {
+    throw new TicketNotFoundError(ticketId);
+  }
+  const ticket = sprint.tickets[ticketIdx];
+  if (!ticket) {
+    throw new TicketNotFoundError(ticketId);
+  }
+  if (updates.title !== void 0) {
+    ticket.title = updates.title;
+  }
+  if (updates.description !== void 0) {
+    ticket.description = updates.description || void 0;
+  }
+  if (updates.link !== void 0) {
+    ticket.link = updates.link || void 0;
+  }
+  await saveSprintData(sprint);
+  return ticket;
+}
+async function removeTicket(ticketId, sprintId) {
+  const sprint = await getSprintData(sprintId);
+  assertSprintStatus(sprint, ["draft"], "remove tickets");
+  const index = sprint.tickets.findIndex((t) => t.id === ticketId);
+  if (index === -1) {
+    throw new TicketNotFoundError(ticketId);
+  }
+  sprint.tickets.splice(index, 1);
+  await saveSprintData(sprint);
+}
+async function listTickets(sprintId) {
+  const sprint = await getSprintData(sprintId);
+  return sprint.tickets;
+}
+async function getTicket(ticketId, sprintId) {
+  const sprint = await getSprintData(sprintId);
+  const ticket = sprint.tickets.find((t) => t.id === ticketId);
+  if (!ticket) {
+    throw new TicketNotFoundError(ticketId);
+  }
+  return ticket;
+}
+function allRequirementsApproved(tickets) {
+  return tickets.length > 0 && tickets.every((t) => t.requirementStatus === "approved");
+}
+function getPendingRequirements(tickets) {
+  return tickets.filter((t) => t.requirementStatus === "pending");
+}
+function formatTicketDisplay(ticket) {
+  return `[${ticket.id}] ${ticket.title}`;
+}
+
+// src/integration/external/issue-fetch.ts
+import { spawnSync } from "child_process";
+import { Result } from "typescript-result";
+var MAX_COMMENTS = 20;
+function parseIssueUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return null;
+  }
+  if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+    return null;
+  }
+  const segments = parsed.pathname.split("/").filter(Boolean);
+  if (parsed.hostname === "github.com") {
+    const owner = segments[0];
+    const repo = segments[1];
+    if (segments.length >= 4 && segments[2] === "issues" && owner && repo) {
+      const num = Number(segments[3]);
+      if (Number.isInteger(num) && num > 0) {
+        return { host: "github", hostname: parsed.hostname, owner, repo, number: num };
+      }
+    }
+    return null;
+  }
+  const dashIdx = segments.indexOf("-");
+  if (dashIdx >= 2 && segments[dashIdx + 1] === "issues") {
+    const num = Number(segments[dashIdx + 2]);
+    if (Number.isInteger(num) && num > 0) {
+      const repo = segments[dashIdx - 1];
+      if (repo) {
+        const owner = segments.slice(0, dashIdx - 1).join("/");
+        return { host: "gitlab", hostname: parsed.hostname, owner, repo, number: num };
+      }
+    }
+  }
+  return null;
+}
+function fetchGitHubIssueResult(parsed) {
+  const result = spawnSync(
+    "gh",
+    [
+      "issue",
+      "view",
+      String(parsed.number),
+      "--repo",
+      `${parsed.owner}/${parsed.repo}`,
+      "--json",
+      "title,body,comments"
+    ],
+    { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 3e4 }
+  );
+  if (result.status !== 0) {
+    const stderr = result.stderr.trim();
+    return Result.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) => ({
+    author: c.author?.login ?? "unknown",
+    createdAt: c.createdAt ?? "",
+    body: c.body ?? ""
+  }));
+  return Result.ok({
+    title: data.title ?? "",
+    body: data.body ?? "",
+    comments,
+    url: `https://${parsed.hostname}/${parsed.owner}/${parsed.repo}/issues/${String(parsed.number)}`
+  });
+}
+function fetchGitLabIssueResult(parsed) {
+  const result = spawnSync(
+    "glab",
+    ["issue", "view", String(parsed.number), "--repo", `${parsed.owner}/${parsed.repo}`, "--output", "json"],
+    { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 3e4 }
+  );
+  if (result.status !== 0) {
+    const stderr = result.stderr.trim();
+    return Result.error(new IssueFetchError(`glab issue view failed: ${stderr || "unknown error"}`));
+  }
+  const data = JSON.parse(result.stdout);
+  const notesResult = spawnSync(
+    "glab",
+    ["issue", "note", "list", String(parsed.number), "--repo", `${parsed.owner}/${parsed.repo}`, "--output", "json"],
+    { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 3e4 }
+  );
+  let comments = [];
+  if (notesResult.status === 0 && notesResult.stdout.trim()) {
+    try {
+      const notes = JSON.parse(notesResult.stdout);
+      comments = notes.slice(-MAX_COMMENTS).map((n) => ({
+        author: n.author?.username ?? "unknown",
+        createdAt: n.created_at ?? "",
+        body: n.body ?? ""
+      }));
+    } catch {
+    }
+  }
+  return Result.ok({
+    title: data.title ?? "",
+    body: data.description ?? "",
+    comments,
+    url: `https://${parsed.hostname}/${parsed.owner}/${parsed.repo}/-/issues/${String(parsed.number)}`
+  });
+}
+function fetchIssueResult(parsed) {
+  if (parsed.host === "github") {
+    return fetchGitHubIssueResult(parsed);
+  }
+  return fetchGitLabIssueResult(parsed);
+}
+function fetchIssue(parsed) {
+  return unwrapOrThrow(fetchIssueResult(parsed));
+}
+function fetchIssueFromUrl(url) {
+  const parsed = parseIssueUrl(url);
+  if (!parsed) return null;
+  return fetchIssue(parsed);
+}
+function formatIssueContext(data) {
+  const lines = [];
+  lines.push("## Source Issue Data");
+  lines.push("");
+  lines.push(`> Fetched live from ${data.url}`);
+  lines.push("");
+  lines.push(`**Title:** ${data.title}`);
+  lines.push("");
+  if (data.body) {
+    lines.push("**Body:**");
+    lines.push("");
+    lines.push(data.body);
+    lines.push("");
+  }
+  if (data.comments.length > 0) {
+    lines.push(`**Comments (${String(data.comments.length)}):**`);
+    lines.push("");
+    for (const comment of data.comments) {
+      const timestamp = comment.createdAt ? ` (${comment.createdAt})` : "";
+      lines.push(`---`);
+      lines.push(`**@${comment.author}**${timestamp}:`);
+      lines.push("");
+      lines.push(comment.body);
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+
+export {
+  addTicket,
+  updateTicket,
+  removeTicket,
+  listTickets,
+  getTicket,
+  allRequirementsApproved,
+  getPendingRequirements,
+  formatTicketDisplay,
+  fetchIssueFromUrl,
+  formatIssueContext
+};

package/dist/{chunk-OEUJDSHY.mjs → chunk-IWXBJD2D.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-// src/utils/result-helpers.ts
+// src/integration/utils/result-helpers.ts
 import { Result } from "typescript-result";
 async function wrapAsync(fn, mapError) {
   try {

package/dist/chunk-JXMHLW42.mjs

@@ -0,0 +1,227 @@
+#!/usr/bin/env node
+import {
+  getProjectById
+} from "./chunk-NUYQK5MN.mjs";
+import {
+  addTicket,
+  fetchIssueFromUrl
+} from "./chunk-HL4ZMHCQ.mjs";
+import {
+  EXIT_ERROR,
+  exitWithCode
+} from "./chunk-CFUVE2BP.mjs";
+import {
+  getPrompt
+} from "./chunk-747KW2RW.mjs";
+import {
+  getCurrentSprintOrThrow
+} from "./chunk-YCDUVPRT.mjs";
+import {
+  createSpinner,
+  emoji,
+  error,
+  field,
+  fieldMultiline,
+  icons,
+  log,
+  renderCard,
+  showError,
+  showSuccess,
+  showWarning
+} from "./chunk-FKMKOWLA.mjs";
+import {
+  ensureError,
+  wrapAsync
+} from "./chunk-IWXBJD2D.mjs";
+import {
+  IOError,
+  SprintStatusError
+} from "./chunk-57UWLHRH.mjs";
+
+// src/integration/cli/commands/ticket/add.ts
+import { Result as Result2 } from "typescript-result";
+
+// src/integration/ui/prompts/editor-input.ts
+import { Result } from "typescript-result";
+async function editorInput(options) {
+  try {
+    const result = await getPrompt().editor({
+      message: options.message,
+      default: options.default,
+      kind: "markdown"
+    });
+    if (result === null) {
+      return Result.error(new IOError("Editor cancelled"));
+    }
+    return Result.ok(result);
+  } catch (err) {
+    return Result.error(
+      new IOError(
+        `Editor failed: ${err instanceof Error ? err.message : String(err)}`,
+        err instanceof Error ? err : void 0
+      )
+    );
+  }
+}
+
+// src/integration/cli/commands/ticket/add.ts
+function tryFetchIssue(url) {
+  const spinner = createSpinner("Fetching issue data...");
+  spinner.start();
+  const fetchR = Result2.try(() => fetchIssueFromUrl(url));
+  if (!fetchR.ok) {
+    spinner.fail("Could not fetch issue data");
+    showWarning(fetchR.error.message);
+    log.newline();
+    return void 0;
+  }
+  const data = fetchR.value;
+  if (!data) {
+    spinner.stop();
+    return void 0;
+  }
+  spinner.succeed("Issue data fetched");
+  log.newline();
+  const bodyPreview = data.body.length > 200 ? data.body.slice(0, 200) + "..." : data.body;
+  const cardLines = [`Title: ${data.title}`, "", bodyPreview];
+  if (data.comments.length > 0) {
+    cardLines.push("", `${String(data.comments.length)} comment(s)`);
+  }
+  console.log(renderCard(`${icons.info} Fetched Issue`, cardLines));
+  log.newline();
+  return data;
+}
+function validateUrl(url) {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function addSingleTicketNonInteractive(options) {
+  const errors = [];
+  const trimmedTitle = options.title?.trim();
+  if (!trimmedTitle) {
+    errors.push("--title is required");
+  }
+  if (options.link && !validateUrl(options.link)) {
+    errors.push("--link must be a valid URL");
+  }
+  if (errors.length > 0 || !trimmedTitle) {
+    showError("Validation failed");
+    for (const e of errors) {
+      log.item(error(e));
+    }
+    log.newline();
+    exitWithCode(EXIT_ERROR);
+  }
+  const title = trimmedTitle;
+  const trimmedDesc = options.description?.trim();
+  const description = trimmedDesc === "" ? void 0 : trimmedDesc;
+  const trimmedLink = options.link?.trim();
+  const link = trimmedLink === "" ? void 0 : trimmedLink;
+  const addR = await wrapAsync(() => addTicket({ title, description, link }), ensureError);
+  if (!addR.ok) {
+    handleTicketError(addR.error);
+    return;
+  }
+  await showTicketResult(addR.value);
+}
+async function addSingleTicketInteractive(options) {
+  const link = await getPrompt().input({
+    message: `${icons.info} Issue link (optional):`,
+    default: options.link?.trim(),
+    validate: (v) => {
+      if (!v) return true;
+      return validateUrl(v) ? true : "Invalid URL format";
+    }
+  });
+  const trimmedLink = link.trim();
+  const normalizedLink = trimmedLink === "" ? void 0 : trimmedLink;
+  let prefill;
+  if (normalizedLink) {
+    prefill = tryFetchIssue(normalizedLink);
+  }
+  let title = await getPrompt().input({
+    message: `${icons.ticket} Title:`,
+    default: prefill?.title ?? options.title?.trim(),
+    validate: (v) => v.trim().length > 0 ? true : "Title is required"
+  });
+  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;
+  const addR = await wrapAsync(
+    () => addTicket({ title, description: normalizedDescription, link: normalizedLink }),
+    ensureError
+  );
+  if (!addR.ok) {
+    handleTicketError(addR.error);
+    return null;
+  }
+  await showTicketResult(addR.value);
+  return addR.value;
+}
+async function showTicketResult(ticket) {
+  const sprintR = await wrapAsync(() => getCurrentSprintOrThrow(), ensureError);
+  const projectLabel = sprintR.ok ? await wrapAsync(() => getProjectById(sprintR.value.projectId), ensureError).then(
+    (r) => r.ok ? `${r.value.displayName} (${r.value.name})` : sprintR.value.projectId
+  ) : "unknown";
+  showSuccess("Ticket added!", [
+    ["ID", ticket.id],
+    ["Title", ticket.title],
+    ["Project", projectLabel]
+  ]);
+  if (ticket.description) {
+    console.log(fieldMultiline("Description", ticket.description));
+  }
+  if (ticket.link) {
+    console.log(field("Link", ticket.link));
+  }
+  console.log("");
+}
+function handleTicketError(err) {
+  if (err instanceof SprintStatusError) {
+    showError(err.message);
+  } else if (err instanceof Error && err.message.includes("does not exist")) {
+    showError(err.message);
+  } else {
+    throw err;
+  }
+}
+async function ticketAddCommand(options = {}) {
+  if (options.interactive === false) {
+    await addSingleTicketNonInteractive(options);
+    return;
+  }
+  let count = 0;
+  while (true) {
+    const ticket = await addSingleTicketInteractive(options);
+    if (ticket) {
+      count++;
+      log.dim(`${String(count)} ticket(s) added in this session`);
+    } else {
+      break;
+    }
+    const another = await getPrompt().confirm({
+      message: `${emoji.donut} Add another ticket?`,
+      default: true
+    });
+    if (!another) break;
+  }
+}
+
+export {
+  editorInput,
+  addSingleTicketInteractive,
+  ticketAddCommand
+};

package/dist/{chunk-EUNAUHC3.mjs → chunk-NUYQK5MN.mjs}

@@ -3,35 +3,51 @@ import {
   ProjectsSchema,
   expandTilde,
   fileExists,
+  generateUuid8,
   getProjectsFilePath,
   readValidatedJson,
   validateProjectPath,
   writeValidatedJson
-} from "./chunk-IB6OCKZW.mjs";
+} from "./chunk-CTP2A436.mjs";
 import {
   ParseError,
   ProjectExistsError,
   ProjectNotFoundError,
   ValidationError
-} from "./chunk-EDJX7TT6.mjs";
+} from "./chunk-57UWLHRH.mjs";
 
-// src/store/project.ts
+// src/integration/persistence/project.ts
 import { basename, resolve } from "path";
 function migrateProjectIfNeeded(project) {
-  if (project.repositories) {
-    return project;
-  }
-  if (project.paths) {
+  const id = project.id ?? generateUuid8();
+  if (project.paths && !project.repositories) {
     return {
+      id,
       name: project.name,
       displayName: project.displayName,
       repositories: project.paths.map((p) => ({
+        id: generateUuid8(),
         name: basename(p),
         path: resolve(expandTilde(p))
       })),
       description: project.description
     };
   }
+  if (project.repositories) {
+    return {
+      id,
+      name: project.name,
+      displayName: project.displayName,
+      repositories: project.repositories.map((r) => ({
+        id: r.id ?? generateUuid8(),
+        name: r.name,
+        path: r.path,
+        checkScript: r.checkScript,
+        checkTimeout: r.checkTimeout
+      })),
+      description: project.description
+    };
+  }
   throw new ParseError(`Invalid project data: no paths or repositories for ${project.name}`);
 }
 async function listProjects() {
@@ -42,7 +58,11 @@ async function listProjects() {
   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);
+  const needsMigration = rawData.some((p) => {
+    if (!p.id) return true;
+    if (p.paths && !p.repositories) return true;
+    return (p.repositories ?? []).some((r) => !r.id);
+  });
   if (needsMigration) {
     const migrated = rawData.map(migrateProjectIfNeeded);
     const validated = ProjectsSchema.parse(migrated);
@@ -76,17 +96,37 @@ async function getProject(name) {
   }
   return project;
 }
+async function getProjectById(id) {
+  const projects = await listProjects();
+  const project = projects.find((p) => p.id === id);
+  if (!project) {
+    throw new ProjectNotFoundError(id);
+  }
+  return project;
+}
+async function getRepoById(repoId) {
+  const projects = await listProjects();
+  for (const project of projects) {
+    const repo = project.repositories.find((r) => r.id === repoId);
+    if (repo) return { project, repo };
+  }
+  throw new ValidationError(`Repository not found: ${repoId}`, "repoId");
+}
+async function resolveRepoPath(repoId) {
+  const { repo } = await getRepoById(repoId);
+  return repo.path;
+}
 async function projectExists(name) {
   const projects = await listProjects();
   return projects.some((p) => p.name === name);
 }
-async function createProject(project) {
+async function createProject(input) {
   const projects = await listProjects();
-  if (projects.some((p) => p.name === project.name)) {
-    throw new ProjectExistsError(project.name);
+  if (projects.some((p) => p.name === input.name)) {
+    throw new ProjectExistsError(input.name);
   }
   const pathErrors = [];
-  for (const repo of project.repositories) {
+  for (const repo of input.repositories) {
     const resolved = resolve(expandTilde(repo.path));
     const validation = await validateProjectPath(resolved);
     if (!validation.ok) {
@@ -98,12 +138,20 @@ async function createProject(project) {
 ${pathErrors.join("\n")}`, "repositories");
   }
   const normalizedProject = {
-    ...project,
-    repositories: project.repositories.map((repo) => ({
-      ...repo,
-      name: repo.name || basename(repo.path),
-      path: resolve(expandTilde(repo.path))
-    }))
+    id: input.id ?? generateUuid8(),
+    name: input.name,
+    displayName: input.displayName,
+    description: input.description,
+    repositories: input.repositories.map((repo) => {
+      const resolvedPath = resolve(expandTilde(repo.path));
+      return {
+        id: repo.id ?? generateUuid8(),
+        name: repo.name && repo.name.length > 0 ? repo.name : basename(resolvedPath),
+        path: resolvedPath,
+        checkScript: repo.checkScript,
+        checkTimeout: repo.checkTimeout
+      };
+    })
   };
   projects.push(normalizedProject);
   const writeResult = await writeValidatedJson(getProjectsFilePath(), projects, ProjectsSchema);
@@ -130,9 +178,11 @@ async function updateProject(name, updates) {
 ${pathErrors.join("\n")}`, "repositories");
     }
     updates.repositories = updates.repositories.map((repo) => ({
-      ...repo,
-      name: repo.name || basename(repo.path),
-      path: resolve(expandTilde(repo.path))
+      id: repo.id.length > 0 ? repo.id : generateUuid8(),
+      name: repo.name && repo.name.length > 0 ? repo.name : basename(resolve(expandTilde(repo.path))),
+      path: resolve(expandTilde(repo.path)),
+      checkScript: repo.checkScript,
+      checkTimeout: repo.checkTimeout
     }));
   }
   const existingProject = projects[index];
@@ -140,6 +190,7 @@ ${pathErrors.join("\n")}`, "repositories");
     throw new ProjectNotFoundError(name);
   }
   const updatedProject = {
+    id: existingProject.id,
     name: existingProject.name,
     displayName: updates.displayName ?? existingProject.displayName,
     repositories: updates.repositories ?? existingProject.repositories,
@@ -160,10 +211,6 @@ async function removeProject(name) {
   const writeResult = await writeValidatedJson(getProjectsFilePath(), projects, ProjectsSchema);
   if (!writeResult.ok) throw writeResult.error;
 }
-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));
@@ -175,9 +222,11 @@ async function addProjectRepo(name, repo) {
     return project;
   }
   const normalizedRepo = {
-    ...repo,
-    name: repo.name || basename(resolvedPath),
-    path: resolvedPath
+    id: repo.id ?? generateUuid8(),
+    name: repo.name && repo.name.length > 0 ? repo.name : basename(resolvedPath),
+    path: resolvedPath,
+    checkScript: repo.checkScript,
+    checkTimeout: repo.checkTimeout
   };
   return updateProject(name, {
     repositories: [...project.repositories, normalizedRepo]
@@ -199,11 +248,13 @@ async function removeProjectRepo(name, path) {
 export {
   listProjects,
   getProject,
+  getProjectById,
+  getRepoById,
+  resolveRepoPath,
   projectExists,
   createProject,
   updateProject,
   removeProject,
-  getProjectRepos,
   addProjectRepo,
   removeProjectRepo
 };