ralphctl 0.2.5 → 0.3.1

package/dist/add-CIM72NE3.mjs

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+import {
+  addSingleTicketInteractive,
+  ticketAddCommand
+} from "./chunk-7JLZQICD.mjs";
+import "./chunk-NUYQK5MN.mjs";
+import "./chunk-JOQO4HMM.mjs";
+import "./chunk-CFUVE2BP.mjs";
+import "./chunk-747KW2RW.mjs";
+import "./chunk-YCDUVPRT.mjs";
+import "./chunk-FKMKOWLA.mjs";
+import "./chunk-IWXBJD2D.mjs";
+import "./chunk-CTP2A436.mjs";
+import "./chunk-57UWLHRH.mjs";
+export {
+  addSingleTicketInteractive,
+  ticketAddCommand
+};

package/dist/add-GX7P7XTT.mjs

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import {
+  addCheckScriptToRepository,
+  projectAddCommand
+} from "./chunk-D2YGPLIV.mjs";
+import "./chunk-NUYQK5MN.mjs";
+import "./chunk-CFUVE2BP.mjs";
+import "./chunk-747KW2RW.mjs";
+import "./chunk-FKMKOWLA.mjs";
+import "./chunk-IWXBJD2D.mjs";
+import "./chunk-CTP2A436.mjs";
+import "./chunk-57UWLHRH.mjs";
+export {
+  addCheckScriptToRepository,
+  projectAddCommand
+};

package/dist/bootstrap-FMHG6DRY.mjs

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import {
+  getPrompt,
+  getSharedDeps,
+  setSharedDeps
+} from "./chunk-747KW2RW.mjs";
+export {
+  getPrompt,
+  getSharedDeps,
+  setSharedDeps
+};

package/dist/chunk-3QBEBKMZ.mjs

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+import {
+  listProjects
+} from "./chunk-NUYQK5MN.mjs";
+import {
+  EXIT_ERROR,
+  exitWithCode
+} from "./chunk-CFUVE2BP.mjs";
+import {
+  getPrompt
+} from "./chunk-747KW2RW.mjs";
+import {
+  createSprint,
+  setCurrentSprint
+} from "./chunk-YCDUVPRT.mjs";
+import {
+  emoji,
+  field,
+  formatSprintStatus,
+  icons,
+  showError,
+  showNextStep,
+  showRandomQuote,
+  showSuccess
+} from "./chunk-FKMKOWLA.mjs";
+
+// src/integration/cli/commands/sprint/create.ts
+async function sprintCreateCommand(options = {}) {
+  const projects = await listProjects();
+  if (projects.length === 0) {
+    showError("No projects configured.");
+    showNextStep("ralphctl project add", "add a project first");
+    if (options.interactive === false) exitWithCode(EXIT_ERROR);
+    return;
+  }
+  let projectId;
+  const projectFlag = options.project?.trim();
+  if (projectFlag) {
+    const match = projects.find((p) => p.name === projectFlag || p.id === projectFlag);
+    if (!match) {
+      showError(`Project not found: ${projectFlag}`);
+      if (options.interactive === false) exitWithCode(EXIT_ERROR);
+      return;
+    }
+    projectId = match.id;
+  } else if (options.interactive === false) {
+    showError("--project is required in non-interactive mode");
+    exitWithCode(EXIT_ERROR);
+  } else if (projects.length === 1 && projects[0]) {
+    projectId = projects[0].id;
+  } else {
+    projectId = await getPrompt().select({
+      message: `${icons.project} Project:`,
+      choices: projects.map((p) => ({ label: p.displayName, value: p.id, description: p.description }))
+    });
+  }
+  if (!projectId) {
+    showError("No project selected.");
+    return;
+  }
+  const pickedProject = projects.find((p) => p.id === projectId);
+  let name;
+  if (options.interactive === false) {
+    const trimmed = options.name?.trim();
+    name = trimmed && trimmed.length > 0 ? trimmed : void 0;
+  } else {
+    const inputName = await getPrompt().input({
+      message: `${icons.sprint} Sprint name (optional):`,
+      default: options.name?.trim()
+    });
+    const trimmed = inputName.trim();
+    name = trimmed.length > 0 ? trimmed : void 0;
+  }
+  const sprint = await createSprint({ projectId, name });
+  let setAsCurrent = true;
+  if (options.interactive) {
+    setAsCurrent = await getPrompt().confirm({
+      message: `${emoji.donut} Set as current sprint?`,
+      default: true
+    });
+  }
+  if (setAsCurrent) {
+    await setCurrentSprint(sprint.id);
+  }
+  showSuccess("Sprint created!", [
+    ["ID", sprint.id],
+    ["Name", sprint.name],
+    ["Project", pickedProject ? `${pickedProject.displayName} (${pickedProject.name})` : projectId],
+    ["Status", formatSprintStatus(sprint.status)]
+  ]);
+  showRandomQuote();
+  if (setAsCurrent) {
+    console.log(field("Current", "Yes (this sprint is now active target)"));
+    showNextStep("ralphctl ticket add", "add tickets to this sprint");
+  } else {
+    console.log(field("Current", "No"));
+    showNextStep(`ralphctl sprint current ${sprint.id}`, "set as current later");
+  }
+}
+
+export {
+  sprintCreateCommand
+};

package/dist/{chunk-EDJX7TT6.mjs → chunk-57UWLHRH.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-// src/errors.ts
+// src/domain/errors.ts
 var DomainError = class extends Error {
   cause;
   constructor(message, cause) {
@@ -127,6 +127,24 @@ var DependencyCycleError = class extends DomainError {
 var IssueFetchError = class extends DomainError {
   code = "ISSUE_FETCH_ERROR";
 };
+var StepError = class extends DomainError {
+  code = "STEP_ERROR";
+  stepName;
+  constructor(message, stepName, cause) {
+    super(message, cause);
+    this.stepName = stepName;
+  }
+};
+var BranchPreflightError = class extends DomainError {
+  code = "BRANCH_PREFLIGHT_ERROR";
+  projectPath;
+  expectedBranch;
+  constructor(projectPath, expectedBranch, cause) {
+    super(`Branch verification failed: expected '${expectedBranch}' in ${projectPath}`, cause);
+    this.projectPath = projectPath;
+    this.expectedBranch = expectedBranch;
+  }
+};
 
 export {
   DomainError,
@@ -144,5 +162,7 @@ export {
   SprintStatusError,
   NoCurrentSprintError,
   DependencyCycleError,
-  IssueFetchError
+  IssueFetchError,
+  StepError,
+  BranchPreflightError
 };

package/dist/chunk-747KW2RW.mjs

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+
+// src/integration/bootstrap.ts
+var _shared = null;
+function getSharedDeps() {
+  if (!_shared) {
+    throw new Error(
+      "SharedDeps not initialised \u2014 the application entrypoint must call setSharedDeps() before any CLI command runs."
+    );
+  }
+  return _shared;
+}
+function setSharedDeps(deps) {
+  _shared = deps;
+}
+function getPrompt() {
+  return getSharedDeps().prompt;
+}
+
+export {
+  getSharedDeps,
+  setSharedDeps,
+  getPrompt
+};

package/dist/chunk-7JLZQICD.mjs

@@ -0,0 +1,228 @@
+#!/usr/bin/env node
+import {
+  getProjectById
+} from "./chunk-NUYQK5MN.mjs";
+import {
+  addTicket,
+  fetchIssueFromUrl,
+  truncate
+} from "./chunk-JOQO4HMM.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 = truncate(data.body, 200);
+  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-7TG3EAQ2.mjs → chunk-CFUVE2BP.mjs}

@@ -1,20 +1,16 @@
 #!/usr/bin/env node
 
-// src/utils/exit-codes.ts
-var EXIT_SUCCESS = 0;
+// src/domain/exit-codes.ts
 var EXIT_ERROR = 1;
 var EXIT_NO_TASKS = 2;
-var EXIT_ALL_BLOCKED = 3;
 var EXIT_INTERRUPTED = 130;
 function exitWithCode(code) {
   process.exit(code);
 }
 
 export {
-  EXIT_SUCCESS,
   EXIT_ERROR,
   EXIT_NO_TASKS,
-  EXIT_ALL_BLOCKED,
   EXIT_INTERRUPTED,
   exitWithCode
 };