ralphctl 0.1.0 → 0.1.2

package/dist/chunk-MNMQC36F.mjs

@@ -0,0 +1,556 @@
+#!/usr/bin/env node
+import {
+  EXIT_ERROR,
+  exitWithCode
+} from "./chunk-7TG3EAQ2.mjs";
+import {
+  ProjectNotFoundError,
+  getProject,
+  listProjects,
+  projectExists
+} from "./chunk-WGHJI3OI.mjs";
+import {
+  SprintStatusError,
+  assertSprintStatus,
+  generateUuid8,
+  getEditor,
+  resolveSprintId,
+  setEditor
+} from "./chunk-EKMZZRWI.mjs";
+import {
+  SprintSchema,
+  getSprintFilePath,
+  readValidatedJson,
+  writeValidatedJson
+} from "./chunk-6PYTKGB5.mjs";
+import {
+  createSpinner,
+  emoji,
+  error,
+  field,
+  fieldMultiline,
+  icons,
+  log,
+  muted,
+  renderCard,
+  showEmpty,
+  showError,
+  showSuccess,
+  showWarning
+} from "./chunk-QBXHAXHI.mjs";
+
+// src/commands/ticket/add.ts
+import { confirm, input, select as select2 } from "@inquirer/prompts";
+
+// src/utils/editor-input.ts
+import { editor } from "@inquirer/prompts";
+
+// src/utils/editor.ts
+import { select } from "@inquirer/prompts";
+async function resolveEditor() {
+  const stored = await getEditor();
+  if (stored) return stored;
+  const choice = await select({
+    message: `${emoji.donut} Which editor should open for multiline input?`,
+    choices: [
+      { name: "Sublime Text", value: "subl -w" },
+      { name: "VS Code", value: "code --wait" },
+      { name: "Vim", value: "vim" },
+      { name: "Nano", value: "nano" },
+      { name: "Use $EDITOR env var", value: "__env__" }
+    ]
+  });
+  if (choice === "__env__") {
+    const envEditor = process.env["VISUAL"] ?? process.env["EDITOR"];
+    if (!envEditor) {
+      await setEditor("vim");
+      return "vim";
+    }
+    await setEditor(envEditor);
+    return envEditor;
+  }
+  await setEditor(choice);
+  return choice;
+}
+
+// src/utils/editor-input.ts
+async function editorInput(options) {
+  if (!process.stdin.isTTY) {
+    const { multilineInput } = await import("./multiline-OHSNFCRG.mjs");
+    return multilineInput({ message: options.message, default: options.default });
+  }
+  const editorCmd = await resolveEditor();
+  const prevVisual = process.env["VISUAL"];
+  process.env["VISUAL"] = editorCmd;
+  try {
+    const result = await editor({
+      message: options.message,
+      default: options.default,
+      postfix: ".md"
+    });
+    return result.trim();
+  } finally {
+    if (prevVisual === void 0) delete process.env["VISUAL"];
+    else process.env["VISUAL"] = prevVisual;
+  }
+}
+
+// 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);
+}
+async function saveSprintData(sprint) {
+  await writeValidatedJson(getSprintFilePath(sprint.id), sprint, SprintSchema);
+}
+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;
+  }
+  const ticket = {
+    id: generateUuid8(),
+    title: input2.title,
+    description: input2.description,
+    link: input2.link,
+    projectName: input2.projectName,
+    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 groupTicketsByProject(tickets) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const ticket of tickets) {
+    const existing = grouped.get(ticket.projectName) ?? [];
+    existing.push(ticket);
+    grouped.set(ticket.projectName, existing);
+  }
+  return grouped;
+}
+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}`;
+}
+function formatTicketId(ticket) {
+  return ticket.id;
+}
+
+// src/utils/issue-fetch.ts
+import { spawnSync } from "child_process";
+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 fetchGitHubIssue(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();
+    throw 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 {
+    title: data.title ?? "",
+    body: data.body ?? "",
+    comments,
+    url: `https://${parsed.hostname}/${parsed.owner}/${parsed.repo}/issues/${String(parsed.number)}`
+  };
+}
+function fetchGitLabIssue(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();
+    throw 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 {
+    title: data.title ?? "",
+    body: data.description ?? "",
+    comments,
+    url: `https://${parsed.hostname}/${parsed.owner}/${parsed.repo}/-/issues/${String(parsed.number)}`
+  };
+}
+function fetchIssue(parsed) {
+  if (parsed.host === "github") {
+    return fetchGitHubIssue(parsed);
+  }
+  return fetchGitLabIssue(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");
+}
+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) {
+    spinner.fail("Could not fetch issue data");
+    if (err instanceof IssueFetchError) {
+      showWarning(err.message);
+    } else if (err instanceof Error) {
+      showWarning(err.message);
+    }
+    log.newline();
+    return void 0;
+  }
+  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();
+  const trimmedProject = options.project?.trim();
+  if (!trimmedTitle) {
+    errors.push("--title is required");
+  }
+  if (!trimmedProject) {
+    errors.push("--project is required");
+  } else if (!await projectExists(trimmedProject)) {
+    errors.push(`Project '${trimmedProject}' does not exist. Add it first with 'ralphctl project add'.`);
+  }
+  if (options.link && !validateUrl(options.link)) {
+    errors.push("--link must be a valid URL");
+  }
+  if (errors.length > 0 || !trimmedTitle || !trimmedProject) {
+    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 projectName = trimmedProject;
+  try {
+    const ticket = await addTicket({
+      title,
+      description,
+      link,
+      projectName
+    });
+    showTicketResult(ticket);
+  } catch (err) {
+    handleTicketError(err);
+  }
+}
+async function addSingleTicketInteractive(options) {
+  const projects = await listProjects();
+  if (projects.length === 0) {
+    showEmpty("projects", "Add one first with: ralphctl project add");
+    return null;
+  }
+  const projectName = await select2({
+    message: `${icons.project} Project:`,
+    default: options.project ?? projects[0]?.name,
+    choices: projects.map((p) => ({
+      name: `${icons.project} ${p.name} ${muted(`- ${p.displayName}`)}`,
+      value: p.name
+    }))
+  });
+  const link = await 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 input({
+    message: `${icons.ticket} Title:`,
+    default: prefill?.title ?? options.title?.trim(),
+    validate: (v) => v.trim().length > 0 ? true : "Title is required"
+  });
+  const description = await editorInput({
+    message: "Description (recommended):",
+    default: prefill?.body ?? options.description?.trim()
+  });
+  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);
+    return null;
+  }
+}
+function showTicketResult(ticket) {
+  showSuccess("Ticket added!", [
+    ["ID", ticket.id],
+    ["Title", ticket.title],
+    ["Project", ticket.projectName]
+  ]);
+  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;
+  let lastProjectName = options.project;
+  while (true) {
+    const ticket = await addSingleTicketInteractive({ ...options, project: lastProjectName });
+    if (ticket) {
+      count++;
+      lastProjectName = ticket.projectName;
+      log.dim(`${String(count)} ticket(s) added in this session`);
+    } else {
+      break;
+    }
+    const another = await confirm({
+      message: `${emoji.donut} Add another ticket?`,
+      default: true
+    });
+    if (!another) break;
+  }
+}
+
+export {
+  TicketNotFoundError,
+  addTicket,
+  updateTicket,
+  removeTicket,
+  listTickets,
+  getTicket,
+  groupTicketsByProject,
+  allRequirementsApproved,
+  getPendingRequirements,
+  formatTicketDisplay,
+  formatTicketId,
+  editorInput,
+  fetchIssueFromUrl,
+  formatIssueContext,
+  IssueFetchError,
+  addSingleTicketInteractive,
+  ticketAddCommand
+};