ralphctl 0.2.5 → 0.3.1

package/dist/chunk-JOQO4HMM.mjs

@@ -0,0 +1,269 @@
+#!/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/domain/strings.ts
+function truncate(str, max) {
+  if (str.length <= max) return str;
+  if (max <= 1) return "\u2026".slice(0, Math.max(0, max));
+  return str.slice(0, max - 1) + "\u2026";
+}
+
+// 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,
+  truncate,
+  fetchIssueFromUrl,
+  formatIssueContext
+};

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
 };

package/dist/{chunk-JRFOUFD3.mjs → chunk-YCDUVPRT.mjs}

@@ -1,7 +1,10 @@
 #!/usr/bin/env node
+import {
+  log
+} from "./chunk-FKMKOWLA.mjs";
 import {
   unwrapOrThrow
-} from "./chunk-OEUJDSHY.mjs";
+} from "./chunk-IWXBJD2D.mjs";
 import {
   ConfigSchema,
   SprintSchema,
@@ -10,6 +13,7 @@ import {
   assertSafeCwd,
   ensureDir,
   fileExists,
+  generateSprintId,
   getConfigPath,
   getProgressFilePath,
   getSprintDir,
@@ -21,19 +25,16 @@ import {
   readValidatedJson,
   removeDir,
   writeValidatedJson
-} from "./chunk-IB6OCKZW.mjs";
+} from "./chunk-CTP2A436.mjs";
 import {
   LockError,
   NoCurrentSprintError,
   SprintNotFoundError,
   SprintStatusError,
   StorageError
-} from "./chunk-EDJX7TT6.mjs";
-import {
-  log
-} from "./chunk-QBXHAXHI.mjs";
+} from "./chunk-57UWLHRH.mjs";
 
-// src/store/config.ts
+// src/integration/persistence/config.ts
 var DEFAULT_EVALUATION_ITERATIONS = 1;
 var DEFAULT_CONFIG = {
   currentSprint: null,
@@ -87,26 +88,10 @@ async function setEvaluationIterations(iterations) {
   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
+// src/integration/persistence/progress.ts
 import { execSync } from "child_process";
 
-// src/utils/file-lock.ts
+// src/integration/persistence/file-lock.ts
 import { mkdir, readFile, unlink, writeFile } from "fs/promises";
 import { dirname } from "path";
 import { Result } from "typescript-result";
@@ -193,7 +178,7 @@ async function withFileLock(filePath, fn) {
   }
 }
 
-// src/store/progress.ts
+// src/integration/persistence/progress.ts
 async function logProgress(message, options = {}) {
   const id = await resolveSprintId(options.sprintId);
   const sprint = await getSprint(id);
@@ -347,7 +332,7 @@ function filterProgressByProject(progress, projectPath) {
   return filtered.join("\n---\n") + "\n\n---\n\n";
 }
 
-// src/store/sprint.ts
+// src/integration/persistence/sprint.ts
 function assertSprintStatus(sprint, allowedStatuses, operation) {
   if (!allowedStatuses.includes(sprint.status)) {
     const statusText = allowedStatuses.join(" or ");
@@ -375,13 +360,15 @@ Hint: ${hint}` : "";
     );
   }
 }
-async function createSprint(name) {
+async function createSprint(input) {
+  const { projectId, name } = input;
   const id = generateSprintId(name);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const displayName = name ?? id.slice(16);
   const sprint = {
     id,
     name: displayName,
+    projectId,
     status: "draft",
     createdAt: now,
     activatedAt: null,
@@ -409,10 +396,6 @@ Created: ${now}
   if (!appendResult.ok) throw appendResult.error;
   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)) {
@@ -447,17 +430,23 @@ async function activateSprint(sprintId) {
   await saveSprint(sprint);
   const tasksResult = await readValidatedJson(getTasksFilePath(sprintId), TasksSchema);
   if (!tasksResult.ok) throw tasksResult.error;
-  const tasks = tasksResult.value;
-  const projectPaths = tasks.map((t) => t.projectPath).filter((p) => !!p);
-  if (projectPaths.length > 0) {
-    await logBaselines({
-      sprintId,
-      sprintName: sprint.name,
-      projectPaths
-    });
-  }
+  const _tasks = tasksResult.value;
+  void _tasks;
   return sprint;
 }
+async function logSprintBaselines(sprint, resolvePath) {
+  const tasksResult = await readValidatedJson(getTasksFilePath(sprint.id), TasksSchema);
+  if (!tasksResult.ok) throw tasksResult.error;
+  const repoIds = [...new Set(tasksResult.value.map((t) => t.repoId))];
+  const paths = [];
+  for (const repoId of repoIds) {
+    const p = await resolvePath(repoId);
+    if (p) paths.push(p);
+  }
+  if (paths.length > 0) {
+    await logBaselines({ sprintId: sprint.id, sprintName: sprint.name, projectPaths: paths });
+  }
+}
 async function closeSprint(sprintId) {
   const sprint = await getSprint(sprintId);
   assertSprintStatus(sprint, ["active"], "close");
@@ -480,13 +469,6 @@ async function getCurrentSprintOrThrow() {
   }
   return getSprint(currentSprintId);
 }
-async function getActiveSprintOrThrow() {
-  const activeSprint = await findActiveSprint();
-  if (!activeSprint) {
-    throw new NoCurrentSprintError();
-  }
-  return activeSprint;
-}
 async function resolveSprintId(sprintId) {
   if (sprintId) {
     return sprintId;
@@ -499,8 +481,8 @@ async function resolveSprintId(sprintId) {
 }
 
 export {
-  DEFAULT_EVALUATION_ITERATIONS,
   getConfig,
+  saveConfig,
   getCurrentSprint,
   setCurrentSprint,
   getAiProvider,
@@ -509,21 +491,19 @@ export {
   setEditor,
   getEvaluationIterations,
   setEvaluationIterations,
-  generateUuid8,
   withFileLock,
   logProgress,
   getProgress,
   summarizeProgressForContext,
   assertSprintStatus,
   createSprint,
-  findActiveSprint,
   getSprint,
   saveSprint,
   listSprints,
   activateSprint,
+  logSprintBaselines,
   closeSprint,
   deleteSprint,
   getCurrentSprintOrThrow,
-  getActiveSprintOrThrow,
   resolveSprintId
 };