ralphctl 0.1.0 → 0.1.2

package/dist/chunk-EKMZZRWI.mjs

@@ -0,0 +1,521 @@
+#!/usr/bin/env node
+import {
+  ConfigSchema,
+  FileNotFoundError,
+  SprintSchema,
+  TasksSchema,
+  ValidationError,
+  appendToFile,
+  assertSafeCwd,
+  ensureDir,
+  fileExists,
+  getConfigPath,
+  getProgressFilePath,
+  getSprintDir,
+  getSprintFilePath,
+  getSprintsDir,
+  getTasksFilePath,
+  listDirs,
+  readTextFile,
+  readValidatedJson,
+  removeDir,
+  writeValidatedJson
+} from "./chunk-6PYTKGB5.mjs";
+import {
+  log
+} from "./chunk-QBXHAXHI.mjs";
+
+// src/store/config.ts
+var DEFAULT_CONFIG = {
+  currentSprint: null,
+  aiProvider: null,
+  editor: null
+};
+async function getConfig() {
+  const configPath = getConfigPath();
+  if (!await fileExists(configPath)) {
+    return DEFAULT_CONFIG;
+  }
+  return readValidatedJson(configPath, ConfigSchema);
+}
+async function saveConfig(config) {
+  await writeValidatedJson(getConfigPath(), config, ConfigSchema);
+}
+async function getCurrentSprint() {
+  const config = await getConfig();
+  return config.currentSprint;
+}
+async function setCurrentSprint(sprintId) {
+  const config = await getConfig();
+  config.currentSprint = sprintId;
+  await saveConfig(config);
+}
+async function getAiProvider() {
+  const config = await getConfig();
+  return config.aiProvider ?? null;
+}
+async function setAiProvider(provider) {
+  const config = await getConfig();
+  config.aiProvider = provider;
+  await saveConfig(config);
+}
+async function getEditor() {
+  const config = await getConfig();
+  return config.editor ?? null;
+}
+async function setEditor(editor) {
+  const config = await getConfig();
+  config.editor = editor;
+  await saveConfig(config);
+}
+
+// src/utils/ids.ts
+import { randomBytes } from "crypto";
+function generateUuid8() {
+  return randomBytes(4).toString("hex");
+}
+function slugify(input, maxLength = 40) {
+  return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-").slice(0, maxLength).replace(/-$/, "");
+}
+function generateSprintId(name) {
+  const now = /* @__PURE__ */ new Date();
+  const date = now.toISOString().slice(0, 10).replace(/-/g, "");
+  const time = now.toISOString().slice(11, 19).replace(/:/g, "");
+  const slug = name ? slugify(name) : generateUuid8();
+  return `${date}-${time}-${slug || generateUuid8()}`;
+}
+
+// src/store/progress.ts
+import { execSync } from "child_process";
+
+// src/utils/file-lock.ts
+import { mkdir, readFile, unlink, writeFile } from "fs/promises";
+import { dirname } from "path";
+var LockAcquisitionError = class extends Error {
+  lockPath;
+  constructor(message, lockPath) {
+    super(message);
+    this.name = "LockAcquisitionError";
+    this.lockPath = lockPath;
+  }
+};
+var parsed = parseInt(process.env["RALPHCTL_LOCK_TIMEOUT_MS"] ?? "", 10);
+var LOCK_TIMEOUT_MS = parsed > 0 && parsed <= 36e5 ? parsed : 3e4;
+var RETRY_DELAY_MS = 50;
+var MAX_RETRIES = 100;
+function getLockPath(filePath) {
+  return `${filePath}.lock`;
+}
+async function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function isLockStale(lockPath) {
+  try {
+    const content = await readFile(lockPath, "utf-8");
+    const info = JSON.parse(content);
+    const age = Date.now() - info.timestamp;
+    if (age > LOCK_TIMEOUT_MS) {
+      return true;
+    }
+    try {
+      process.kill(info.pid, 0);
+      return false;
+    } catch {
+      return true;
+    }
+  } catch {
+    return true;
+  }
+}
+async function acquireLock(filePath) {
+  const lockPath = getLockPath(filePath);
+  const lockInfo = {
+    pid: process.pid,
+    timestamp: Date.now()
+  };
+  let retries = 0;
+  while (retries < MAX_RETRIES) {
+    try {
+      await mkdir(dirname(lockPath), { recursive: true });
+      await writeFile(lockPath, JSON.stringify(lockInfo), { flag: "wx", mode: 384 });
+      return async () => {
+        try {
+          await unlink(lockPath);
+        } catch {
+        }
+      };
+    } catch (err) {
+      if (err instanceof Error && "code" in err && err.code === "EEXIST") {
+        if (await isLockStale(lockPath)) {
+          try {
+            await unlink(lockPath);
+          } catch {
+          }
+          continue;
+        }
+        retries++;
+        await sleep(RETRY_DELAY_MS);
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw new LockAcquisitionError(`Failed to acquire lock after ${String(MAX_RETRIES)} retries`, lockPath);
+}
+async function withFileLock(filePath, fn) {
+  const release = await acquireLock(filePath);
+  try {
+    return await fn();
+  } finally {
+    await release();
+  }
+}
+
+// src/store/progress.ts
+async function logProgress(message, options = {}) {
+  const id = await resolveSprintId(options.sprintId);
+  const sprint = await getSprint(id);
+  assertSprintStatus(sprint, ["active"], "log progress");
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const projectMarker = options.projectPath ? `**Project:** ${options.projectPath}
+
+` : "";
+  const entry = `## ${timestamp}
+
+${projectMarker}${message}
+
+---
+
+`;
+  const progressPath = getProgressFilePath(id);
+  await withFileLock(progressPath, async () => {
+    await appendToFile(progressPath, entry);
+  });
+}
+function isExecError(err) {
+  return err instanceof Error && typeof err["status"] === "number";
+}
+function isNodeError(err) {
+  return err instanceof Error && typeof err["code"] === "string";
+}
+function getGitCommitInfo(projectPath) {
+  try {
+    assertSafeCwd(projectPath);
+    const output = execSync("git log -1 --pretty=format:%H\\ %s", {
+      cwd: projectPath,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const spaceIndex = output.indexOf(" ");
+    return {
+      hash: output.slice(0, spaceIndex),
+      message: output.slice(spaceIndex + 1)
+    };
+  } catch (err) {
+    if (isExecError(err) && err.status === 128) {
+      return null;
+    }
+    if (isNodeError(err) && err.code === "ENOENT") {
+      return null;
+    }
+    const detail = err instanceof Error ? err.message : String(err);
+    log.warn(`Failed to get git info for ${projectPath}: ${detail}`);
+    return null;
+  }
+}
+async function logBaselines(options) {
+  const { sprintId, sprintName, projectPaths } = options;
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const lines = [
+    `## ${timestamp}`,
+    "",
+    "### Sprint Baseline State",
+    "",
+    `Sprint: ${sprintName} (${sprintId})`,
+    `Activated: ${timestamp}`,
+    "",
+    "#### Project Git State at Activation",
+    ""
+  ];
+  const uniquePaths = [...new Set(projectPaths)];
+  for (const path of uniquePaths) {
+    const commitInfo = getGitCommitInfo(path);
+    if (commitInfo) {
+      lines.push(`- **${path}**`);
+      lines.push(`  \`${commitInfo.hash} ${commitInfo.message}\``);
+    } else {
+      lines.push(`- **${path}**`);
+      lines.push(`  *(not a git repository or unable to retrieve state)*`);
+    }
+  }
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  await appendToFile(getProgressFilePath(sprintId), lines.join("\n"));
+}
+async function getProgress(sprintId) {
+  const id = await resolveSprintId(sprintId);
+  try {
+    return await readTextFile(getProgressFilePath(id));
+  } catch (err) {
+    if (err instanceof FileNotFoundError) {
+      return "";
+    }
+    throw err;
+  }
+}
+function summarizeProgressForContext(progress, projectPath, maxEntries = 3) {
+  const filtered = filterProgressByProject(progress, projectPath);
+  if (!filtered.trim()) {
+    return "";
+  }
+  const entries = filtered.split(/\n---\n/).filter((e) => e.trim());
+  const recent = entries.slice(-maxEntries);
+  const summaries = [];
+  for (const entry of recent) {
+    const headerMatch = /^##\s+(.+)$/m.exec(entry);
+    const header = headerMatch?.[1] ?? "Unknown entry";
+    const learnings = extractSection(entry, "Learnings and Context");
+    const notes = extractSection(entry, "Notes for Next Tasks");
+    if (learnings || notes) {
+      const parts = [`**${header}**`];
+      if (learnings) {
+        parts.push(`**Learnings:** ${learnings}`);
+      }
+      if (notes) {
+        parts.push(`**Notes for next tasks:** ${notes}`);
+      }
+      summaries.push(parts.join("\n"));
+    }
+  }
+  if (summaries.length === 0) {
+    return "";
+  }
+  return summaries.join("\n\n");
+}
+function extractSection(entry, sectionName) {
+  const regex = new RegExp(`###\\s+${sectionName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*\\n([\\s\\S]*?)(?=###|$)`);
+  const match = regex.exec(entry);
+  if (!match?.[1]) return null;
+  const content = match[1].trim();
+  return content || null;
+}
+function filterProgressByProject(progress, projectPath) {
+  if (!progress.trim()) {
+    return "";
+  }
+  const entries = progress.split(/\n---\n/).filter((e) => e.trim());
+  const filtered = entries.filter((entry) => {
+    const visibleMatch = /\*\*Project:\*\*\s*(.+?)(?:\n|$)/.exec(entry);
+    if (visibleMatch?.[1]) {
+      return visibleMatch[1].trim() === projectPath;
+    }
+    const htmlMatch = /<!--\s*project:\s*(.+?)\s*-->/.exec(entry);
+    if (htmlMatch?.[1]) {
+      return htmlMatch[1] === projectPath;
+    }
+    return true;
+  });
+  if (filtered.length === 0) {
+    return "";
+  }
+  return filtered.join("\n---\n") + "\n\n---\n\n";
+}
+
+// src/store/sprint.ts
+var SprintNotFoundError = class extends Error {
+  sprintId;
+  constructor(sprintId) {
+    super(`Sprint not found: ${sprintId}`);
+    this.name = "SprintNotFoundError";
+    this.sprintId = sprintId;
+  }
+};
+var SprintStatusError = class extends Error {
+  currentStatus;
+  operation;
+  constructor(message, currentStatus, operation) {
+    super(message);
+    this.name = "SprintStatusError";
+    this.currentStatus = currentStatus;
+    this.operation = operation;
+  }
+};
+var NoCurrentSprintError = class extends Error {
+  constructor() {
+    super("No sprint specified and no current sprint set.");
+    this.name = "NoCurrentSprintError";
+  }
+};
+function assertSprintStatus(sprint, allowedStatuses, operation) {
+  if (!allowedStatuses.includes(sprint.status)) {
+    const statusText = allowedStatuses.join(" or ");
+    const hints = {
+      "add tickets": "Close the current sprint and create a new one for additional work.",
+      "remove tickets": "Sprint must be in draft status to remove tickets.",
+      "add tasks": "Close the current sprint and create a new one for additional work.",
+      "remove tasks": "Sprint must be in draft status to remove tasks.",
+      "reorder tasks": "Sprint must be in draft status to reorder tasks.",
+      refine: "Refinement can only be done on draft sprints.",
+      plan: "Planning can only be done on draft sprints.",
+      activate: "Sprint must be in draft status to activate.",
+      start: "Sprint must be draft or active to start.",
+      "update task status": "Task status can only be updated during active execution.",
+      "log progress": "Progress can only be logged during active execution.",
+      close: "Sprint must be active to close."
+    };
+    const hint = hints[operation] ?? "";
+    const hintText = hint ? `
+Hint: ${hint}` : "";
+    throw new SprintStatusError(
+      `Cannot ${operation}: sprint status is '${sprint.status}' (must be ${statusText}).${hintText}`,
+      sprint.status,
+      operation
+    );
+  }
+}
+async function createSprint(name) {
+  const id = generateSprintId(name);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const displayName = name ?? id.slice(16);
+  const sprint = {
+    id,
+    name: displayName,
+    status: "draft",
+    createdAt: now,
+    activatedAt: null,
+    closedAt: null,
+    tickets: [],
+    checkRanAt: {},
+    branch: null
+  };
+  const sprintDir = getSprintDir(id);
+  await ensureDir(sprintDir);
+  await writeValidatedJson(getSprintFilePath(id), sprint, SprintSchema);
+  await writeValidatedJson(getTasksFilePath(id), [], TasksSchema);
+  await appendToFile(getProgressFilePath(id), `# Sprint: ${displayName}
+
+Created: ${now}
+
+---
+
+`);
+  return sprint;
+}
+async function findActiveSprint() {
+  const sprints = await listSprints();
+  return sprints.find((s) => s.status === "active") ?? null;
+}
+async function getSprint(sprintId) {
+  const sprintPath = getSprintFilePath(sprintId);
+  if (!await fileExists(sprintPath)) {
+    throw new SprintNotFoundError(sprintId);
+  }
+  return readValidatedJson(sprintPath, SprintSchema);
+}
+async function saveSprint(sprint) {
+  await writeValidatedJson(getSprintFilePath(sprint.id), sprint, SprintSchema);
+}
+async function listSprints() {
+  const sprintsDir = getSprintsDir();
+  const dirs = await listDirs(sprintsDir);
+  const sprints = [];
+  for (const dir of dirs) {
+    try {
+      const sprint = await getSprint(dir);
+      sprints.push(sprint);
+    } catch (err) {
+      if (err instanceof ValidationError || err instanceof SprintNotFoundError) {
+        continue;
+      }
+      throw err;
+    }
+  }
+  return sprints.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+}
+async function activateSprint(sprintId) {
+  const sprint = await getSprint(sprintId);
+  assertSprintStatus(sprint, ["draft"], "activate");
+  sprint.status = "active";
+  sprint.activatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await saveSprint(sprint);
+  const tasks = await readValidatedJson(getTasksFilePath(sprintId), TasksSchema);
+  const projectPaths = tasks.map((t) => t.projectPath).filter((p) => !!p);
+  if (projectPaths.length > 0) {
+    await logBaselines({
+      sprintId,
+      sprintName: sprint.name,
+      projectPaths
+    });
+  }
+  return sprint;
+}
+async function closeSprint(sprintId) {
+  const sprint = await getSprint(sprintId);
+  assertSprintStatus(sprint, ["active"], "close");
+  sprint.status = "closed";
+  sprint.closedAt = (/* @__PURE__ */ new Date()).toISOString();
+  sprint.checkRanAt = {};
+  await saveSprint(sprint);
+  return sprint;
+}
+async function deleteSprint(sprintId) {
+  const sprint = await getSprint(sprintId);
+  const sprintDir = getSprintDir(sprintId);
+  await removeDir(sprintDir);
+  return sprint;
+}
+async function getCurrentSprintOrThrow() {
+  const currentSprintId = await getCurrentSprint();
+  if (!currentSprintId) {
+    throw new Error('No current sprint. Use "ralphctl sprint create" to create one.');
+  }
+  return getSprint(currentSprintId);
+}
+async function getActiveSprintOrThrow() {
+  const activeSprint = await findActiveSprint();
+  if (!activeSprint) {
+    throw new Error('No active sprint. Use "ralphctl sprint start" to start a draft sprint.');
+  }
+  return activeSprint;
+}
+async function resolveSprintId(sprintId) {
+  if (sprintId) {
+    return sprintId;
+  }
+  const currentSprintId = await getCurrentSprint();
+  if (!currentSprintId) {
+    throw new NoCurrentSprintError();
+  }
+  return currentSprintId;
+}
+
+export {
+  getConfig,
+  getCurrentSprint,
+  setCurrentSprint,
+  getAiProvider,
+  setAiProvider,
+  getEditor,
+  setEditor,
+  generateUuid8,
+  withFileLock,
+  logProgress,
+  getProgress,
+  summarizeProgressForContext,
+  SprintNotFoundError,
+  SprintStatusError,
+  NoCurrentSprintError,
+  assertSprintStatus,
+  createSprint,
+  findActiveSprint,
+  getSprint,
+  saveSprint,
+  listSprints,
+  activateSprint,
+  closeSprint,
+  deleteSprint,
+  getCurrentSprintOrThrow,
+  getActiveSprintOrThrow,
+  resolveSprintId
+};

package/dist/chunk-JON4GCLR.mjs

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+import {
+  createSprint,
+  setCurrentSprint
+} from "./chunk-EKMZZRWI.mjs";
+import {
+  emoji,
+  field,
+  formatSprintStatus,
+  icons,
+  showNextStep,
+  showRandomQuote,
+  showSuccess
+} from "./chunk-QBXHAXHI.mjs";
+
+// src/commands/sprint/create.ts
+import { confirm, input } from "@inquirer/prompts";
+async function sprintCreateCommand(options = {}) {
+  let name;
+  if (options.interactive === false) {
+    const trimmed = options.name?.trim();
+    name = trimmed && trimmed.length > 0 ? trimmed : void 0;
+  } else {
+    const inputName = await 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(name);
+  let setAsCurrent = true;
+  if (options.interactive) {
+    setAsCurrent = await 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],
+    ["Status", formatSprintStatus(sprint.status)]
+  ]);
+  showRandomQuote();
+  if (setAsCurrent) {
+    console.log(field("Current", "Yes (this sprint is now active target)"));
+    showNextStep("ralphctl ticket add --project <name>", "add tickets to this sprint");
+  } else {
+    console.log(field("Current", "No"));
+    showNextStep(`ralphctl sprint current ${sprint.id}`, "set as current later");
+  }
+}
+
+export {
+  sprintCreateCommand
+};