ralphctl 0.5.0 → 0.6.0

package/dist/chunk-VAZ3LJBI.mjs

@@ -1,179 +0,0 @@
-#!/usr/bin/env node
-
-// src/domain/errors.ts
-var DomainError = class extends Error {
-  cause;
-  constructor(message, cause) {
-    super(message, cause ? { cause } : void 0);
-    this.name = this.constructor.name;
-    this.cause = cause;
-  }
-};
-var IOError = class extends DomainError {
-  code = "IO_ERROR";
-};
-var StorageError = class extends DomainError {
-  code = "STORAGE_ERROR";
-};
-var LockError = class extends DomainError {
-  code = "LOCK_ERROR";
-  lockPath;
-  constructor(message, lockPath, cause) {
-    super(message, cause);
-    this.lockPath = lockPath;
-  }
-};
-var ParseError = class extends DomainError {
-  code = "PARSE_ERROR";
-};
-var ValidationError = class extends DomainError {
-  code = "VALIDATION_ERROR";
-  path;
-  constructor(message, path, cause) {
-    super(message, cause);
-    this.path = path;
-  }
-};
-function detectSpawnRateLimit(stderr) {
-  const patterns = [/rate.?limit/i, /\b429\b/, /too many requests/i, /overloaded/i, /\b529\b/];
-  const isRateLimited = patterns.some((p) => p.test(stderr));
-  if (!isRateLimited) return { rateLimited: false, retryAfterMs: null };
-  const retryMatch = /retry.?after:?\s*(\d+)/i.exec(stderr);
-  const retryAfterMs = retryMatch?.[1] ? parseInt(retryMatch[1], 10) * 1e3 : null;
-  return { rateLimited: true, retryAfterMs };
-}
-var SpawnError = class extends DomainError {
-  code = "SPAWN_ERROR";
-  stderr;
-  exitCode;
-  rateLimited;
-  retryAfterMs;
-  sessionId;
-  constructor(message, stderr, exitCode, sessionId, cause) {
-    super(message, cause);
-    this.stderr = stderr;
-    this.exitCode = exitCode;
-    this.sessionId = sessionId ?? null;
-    const rl = detectSpawnRateLimit(stderr);
-    this.rateLimited = rl.rateLimited;
-    this.retryAfterMs = rl.retryAfterMs;
-  }
-};
-var SprintNotFoundError = class extends DomainError {
-  code = "SPRINT_NOT_FOUND";
-  sprintId;
-  constructor(sprintId) {
-    super(`Sprint not found: ${sprintId}`);
-    this.sprintId = sprintId;
-  }
-};
-var TaskNotFoundError = class extends DomainError {
-  code = "TASK_NOT_FOUND";
-  taskId;
-  constructor(taskId) {
-    super(`Task not found: ${taskId}`);
-    this.taskId = taskId;
-  }
-};
-var TicketNotFoundError = class extends DomainError {
-  code = "TICKET_NOT_FOUND";
-  ticketId;
-  constructor(ticketId) {
-    super(`Ticket not found: ${ticketId}`);
-    this.ticketId = ticketId;
-  }
-};
-var ProjectNotFoundError = class extends DomainError {
-  code = "PROJECT_NOT_FOUND";
-  projectName;
-  constructor(projectName) {
-    super(`Project not found: ${projectName}`);
-    this.projectName = projectName;
-  }
-};
-var ProjectExistsError = class extends DomainError {
-  code = "PROJECT_EXISTS";
-  projectName;
-  constructor(projectName) {
-    super(`Project already exists: ${projectName}`);
-    this.projectName = projectName;
-  }
-};
-var StatusError = class extends DomainError {
-  code = "STATUS_ERROR";
-};
-var SprintStatusError = class extends StatusError {
-  currentStatus;
-  operation;
-  constructor(message, currentStatus, operation) {
-    super(message);
-    this.currentStatus = currentStatus;
-    this.operation = operation;
-  }
-};
-var NoCurrentSprintError = class extends StatusError {
-  constructor() {
-    super("No sprint specified and no current sprint set.");
-  }
-};
-var DependencyCycleError = class extends DomainError {
-  code = "DEPENDENCY_CYCLE";
-  cycle;
-  constructor(cycle) {
-    super(`Dependency cycle detected: ${cycle.join(" \u2192 ")}`);
-    this.cycle = cycle;
-  }
-};
-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;
-  }
-};
-var ExecutionAlreadyRunningError = class extends DomainError {
-  code = "EXECUTION_ALREADY_RUNNING";
-  projectName;
-  existingExecutionId;
-  constructor(projectName, existingExecutionId) {
-    super(`An execution is already running for project '${projectName}' (id: ${existingExecutionId}).`);
-    this.projectName = projectName;
-    this.existingExecutionId = existingExecutionId;
-  }
-};
-
-export {
-  DomainError,
-  IOError,
-  StorageError,
-  LockError,
-  ParseError,
-  ValidationError,
-  SpawnError,
-  SprintNotFoundError,
-  TaskNotFoundError,
-  TicketNotFoundError,
-  ProjectNotFoundError,
-  ProjectExistsError,
-  SprintStatusError,
-  NoCurrentSprintError,
-  DependencyCycleError,
-  IssueFetchError,
-  StepError,
-  BranchPreflightError,
-  ExecutionAlreadyRunningError
-};

package/dist/chunk-WDMLPXOD.mjs

@@ -1,363 +0,0 @@
-#!/usr/bin/env node
-import {
-  IOError,
-  StorageError,
-  ValidationError
-} from "./chunk-VAZ3LJBI.mjs";
-
-// src/integration/persistence/paths.ts
-import { isAbsolute, join, resolve, sep } from "path";
-import { homedir } from "os";
-import { lstat, realpath, stat } from "fs/promises";
-import { Result } from "typescript-result";
-function getDataDir() {
-  return process.env["RALPHCTL_ROOT"] ?? join(homedir(), ".ralphctl");
-}
-function getConfigPath() {
-  return join(getDataDir(), "config.json");
-}
-function getProjectsFilePath() {
-  return join(getDataDir(), "projects.json");
-}
-function getSprintsDir() {
-  return join(getDataDir(), "sprints");
-}
-function getSprintDir(sprintId) {
-  const sprintsDir = getSprintsDir();
-  const resolved = resolve(sprintsDir, sprintId);
-  if (!resolved.startsWith(sprintsDir + sep) && resolved !== sprintsDir) {
-    throw new Error(`Path traversal detected in sprint ID: ${sprintId}`);
-  }
-  return resolved;
-}
-function getSprintFilePath(sprintId) {
-  return join(getSprintDir(sprintId), "sprint.json");
-}
-function getTasksFilePath(sprintId) {
-  return join(getSprintDir(sprintId), "tasks.json");
-}
-function getProgressFilePath(sprintId) {
-  return join(getSprintDir(sprintId), "progress.md");
-}
-function getEvaluationsDir(sprintId) {
-  return join(getSprintDir(sprintId), "evaluations");
-}
-function getEvaluationFilePath(sprintId, taskId) {
-  assertSafeSegment(taskId, "task ID");
-  return join(getEvaluationsDir(sprintId), `${taskId}.md`);
-}
-function assertSafeSegment(segment, label) {
-  if (!segment || segment.includes("/") || segment.includes("\\") || segment.includes("..") || segment.includes("\0")) {
-    throw new Error(`Path traversal detected in ${label}: ${segment}`);
-  }
-}
-function getRefinementDir(sprintId, ticketId) {
-  assertSafeSegment(ticketId, "ticket ID");
-  return join(getSprintDir(sprintId), "refinement", ticketId);
-}
-function getPlanningDir(sprintId) {
-  return join(getSprintDir(sprintId), "planning");
-}
-function getIdeationDir(sprintId, ticketId) {
-  assertSafeSegment(ticketId, "ticket ID");
-  return join(getSprintDir(sprintId), "ideation", ticketId);
-}
-function assertSafeCwd(path) {
-  if (!path || path.includes("\0") || path.includes("\n") || path.includes("\r")) {
-    throw new Error("Unsafe path for cwd: contains null bytes or newlines");
-  }
-  if (!isAbsolute(path)) {
-    throw new Error(`Unsafe path for cwd: must be absolute, got: ${path}`);
-  }
-}
-function expandTilde(path) {
-  if (path === "~") return homedir();
-  if (path.startsWith("~/")) return homedir() + path.slice(1);
-  return path;
-}
-async function validateProjectPath(path) {
-  try {
-    const resolved = resolve(expandTilde(path));
-    const lstats = await lstat(resolved);
-    if (lstats.isSymbolicLink()) {
-      const realPath = await realpath(resolved);
-      const realStats = await stat(realPath);
-      if (!realStats.isDirectory()) {
-        return Result.error(new IOError("Symlink target is not a directory"));
-      }
-      return Result.ok(true);
-    }
-    if (!lstats.isDirectory()) {
-      return Result.error(new IOError("Path is not a directory"));
-    }
-    return Result.ok(true);
-  } catch (err) {
-    const code = err.code;
-    const message = code === "EACCES" ? "Permission denied" : "Directory does not exist";
-    return Result.error(new IOError(message, err instanceof Error ? err : void 0));
-  }
-}
-
-// src/integration/persistence/storage.ts
-import { access, appendFile, mkdir, readdir, readFile, rm, writeFile } from "fs/promises";
-import { dirname } from "path";
-import { Result as Result2 } from "typescript-result";
-async function ensureDir(dirPath) {
-  await mkdir(dirPath, { recursive: true });
-}
-async function removeDir(dirPath) {
-  await rm(dirPath, { recursive: true, force: true });
-}
-async function fileExists(filePath) {
-  try {
-    await access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function listDirs(dirPath) {
-  try {
-    const entries = await readdir(dirPath, { withFileTypes: true });
-    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
-  } catch {
-    return [];
-  }
-}
-async function readValidatedJson(filePath, schema) {
-  let content;
-  try {
-    content = await readFile(filePath, "utf-8");
-  } catch (err) {
-    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
-      return Result2.error(new StorageError(`File not found: ${filePath}`, err instanceof Error ? err : void 0));
-    }
-    return Result2.error(new StorageError(`Failed to read ${filePath}`, err instanceof Error ? err : void 0));
-  }
-  let data;
-  try {
-    data = JSON.parse(content);
-  } catch (err) {
-    return Result2.error(
-      new ValidationError(`Invalid JSON in ${filePath}`, filePath, err instanceof Error ? err : void 0)
-    );
-  }
-  const result = schema.safeParse(data);
-  if (!result.success) {
-    const issues = result.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
-    return Result2.error(new ValidationError(`Validation failed for ${filePath}:
-${issues}`, filePath, result.error));
-  }
-  return Result2.ok(result.data);
-}
-async function writeValidatedJson(filePath, data, schema) {
-  const result = schema.safeParse(data);
-  if (!result.success) {
-    const issues = result.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
-    return Result2.error(
-      new ValidationError(`Validation failed before writing to ${filePath}:
-${issues}`, filePath, result.error)
-    );
-  }
-  try {
-    await ensureDir(dirname(filePath));
-    await writeFile(filePath, JSON.stringify(result.data, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
-  } catch (err) {
-    return Result2.error(new StorageError(`Failed to write ${filePath}`, err instanceof Error ? err : void 0));
-  }
-  return Result2.ok(void 0);
-}
-async function appendToFile(filePath, content) {
-  try {
-    await ensureDir(dirname(filePath));
-    await appendFile(filePath, content, { encoding: "utf-8", mode: 384 });
-    return Result2.ok(void 0);
-  } catch (err) {
-    return Result2.error(new StorageError(`Failed to append to ${filePath}`, err instanceof Error ? err : void 0));
-  }
-}
-async function readTextFile(filePath) {
-  try {
-    const content = await readFile(filePath, "utf-8");
-    return Result2.ok(content);
-  } catch (err) {
-    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
-      return Result2.error(new StorageError(`File not found: ${filePath}`, err instanceof Error ? err : void 0));
-    }
-    return Result2.error(new StorageError(`Failed to read ${filePath}`, err instanceof Error ? err : void 0));
-  }
-}
-
-// src/domain/models.ts
-import { z } from "zod";
-var SprintStatusSchema = z.enum(["draft", "active", "closed"]);
-var TaskStatusSchema = z.enum(["todo", "in_progress", "done", "cancelled"]);
-var RequirementStatusSchema = z.enum(["pending", "approved"]);
-var EvaluationStatusSchema = z.enum(["passed", "failed", "malformed", "plateau"]);
-var IdSchema = z.string().min(1);
-var CURRENT_ONBOARDING_VERSION = 1;
-var RepositorySchema = z.object({
-  id: IdSchema,
-  // UUID8, stable across renames
-  name: z.string().min(1),
-  // Auto-derived from basename(path)
-  path: z.string().min(1),
-  // Absolute path
-  checkScript: z.string().optional(),
-  // e.g., "pnpm install && pnpm typecheck && pnpm lint && pnpm test"
-  checkTimeout: z.number().positive().optional(),
-  // Per-repo timeout in ms (overrides RALPHCTL_SETUP_TIMEOUT_MS)
-  // Stamped by `project onboard` on success. Absence means the repo was never
-  // onboarded; `doctor` surfaces a hint. A value < CURRENT_ONBOARDING_VERSION
-  // means the contract has drifted and re-onboarding is recommended.
-  onboardingVersion: z.number().int().nonnegative().optional()
-});
-var ProjectSchema = z.object({
-  id: IdSchema,
-  name: z.string().min(1).regex(/^[a-z0-9-]+$/, "Project name must be a slug (lowercase, numbers, hyphens only)"),
-  displayName: z.string().min(1),
-  repositories: z.array(RepositorySchema).min(1),
-  description: z.string().optional()
-});
-var ProjectsSchema = z.array(ProjectSchema);
-var TicketSchema = z.object({
-  id: IdSchema,
-  // UUID8
-  title: z.string().min(1),
-  description: z.string().optional(),
-  link: z.url().optional(),
-  affectedRepoIds: z.array(IdSchema).optional(),
-  // Subset of sprint's project's repos
-  requirementStatus: RequirementStatusSchema.default("pending"),
-  requirements: z.string().optional()
-  // Set during sprint refine
-});
-var TaskSchema = z.object({
-  id: IdSchema,
-  // UUID8
-  name: z.string().min(1),
-  description: z.string().optional(),
-  steps: z.array(z.string()).default([]),
-  verificationCriteria: z.array(z.string()).default([]),
-  status: TaskStatusSchema.default("todo"),
-  order: z.number().int().positive(),
-  ticketId: IdSchema.optional(),
-  blockedBy: z.array(IdSchema).default([]),
-  repoId: IdSchema,
-  // Required — resolves to an absolute path at runtime
-  verified: z.boolean().default(false),
-  verificationOutput: z.string().optional(),
-  evaluated: z.boolean().default(false),
-  evaluationOutput: z.string().optional(),
-  evaluationStatus: EvaluationStatusSchema.optional(),
-  evaluationFile: z.string().optional(),
-  // Planner-emitted extra evaluator dimensions; floor-only when undefined.
-  extraDimensions: z.array(z.string().min(1)).optional()
-});
-var TasksSchema = z.array(TaskSchema);
-var ImportTaskSchema = z.object({
-  id: z.string().optional(),
-  // Local ID for referencing in blockedBy
-  name: z.string().min(1),
-  description: z.string().optional(),
-  steps: z.array(z.string()).optional(),
-  verificationCriteria: z.array(z.string()).optional(),
-  ticketId: z.string().optional(),
-  blockedBy: z.array(z.string()).optional(),
-  repoId: IdSchema,
-  extraDimensions: z.array(z.string().min(1)).optional()
-});
-var ImportTasksSchema = z.array(ImportTaskSchema);
-var RefinedRequirementSchema = z.object({
-  ref: z.string().min(1),
-  requirements: z.string().min(1)
-});
-var RefinedRequirementsSchema = z.array(RefinedRequirementSchema);
-var IdeateOutputSchema = z.object({
-  requirements: z.string().min(1),
-  tasks: ImportTasksSchema
-});
-var SprintSchema = z.object({
-  id: z.string().regex(/^\d{8}-\d{6}-[a-z0-9-]+$/, "Invalid sprint ID format"),
-  name: z.string().min(1),
-  projectId: IdSchema,
-  // Every sprint belongs to exactly one project
-  status: SprintStatusSchema.default("draft"),
-  createdAt: z.iso.datetime(),
-  activatedAt: z.iso.datetime().nullable().default(null),
-  closedAt: z.iso.datetime().nullable().default(null),
-  tickets: z.array(TicketSchema).default([]),
-  checkRanAt: z.record(IdSchema, z.iso.datetime()).default({}),
-  branch: z.string().nullable().default(null)
-});
-var AiProviderSchema = z.enum(["claude", "copilot"]);
-var ConfigSchema = z.object({
-  currentSprint: z.string().nullable().default(null),
-  aiProvider: AiProviderSchema.nullable().default(null),
-  editor: z.string().nullable().default(null),
-  evaluationIterations: z.number().int().min(0).optional(),
-  aiCheckScriptDiscovery: z.boolean().optional()
-});
-function getRequirementsOutputJsonSchema() {
-  return JSON.stringify(z.toJSONSchema(RefinedRequirementsSchema), null, 2);
-}
-function getTaskImportJsonSchema() {
-  return JSON.stringify(z.toJSONSchema(ImportTasksSchema), null, 2);
-}
-
-// src/domain/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()}`;
-}
-
-export {
-  getDataDir,
-  getConfigPath,
-  getProjectsFilePath,
-  getSprintsDir,
-  getSprintDir,
-  getSprintFilePath,
-  getTasksFilePath,
-  getProgressFilePath,
-  getEvaluationFilePath,
-  getRefinementDir,
-  getPlanningDir,
-  getIdeationDir,
-  assertSafeCwd,
-  expandTilde,
-  validateProjectPath,
-  ensureDir,
-  removeDir,
-  fileExists,
-  listDirs,
-  readValidatedJson,
-  writeValidatedJson,
-  appendToFile,
-  readTextFile,
-  SprintStatusSchema,
-  TaskStatusSchema,
-  RequirementStatusSchema,
-  CURRENT_ONBOARDING_VERSION,
-  ProjectsSchema,
-  TasksSchema,
-  ImportTasksSchema,
-  RefinedRequirementsSchema,
-  IdeateOutputSchema,
-  SprintSchema,
-  ConfigSchema,
-  getRequirementsOutputJsonSchema,
-  getTaskImportJsonSchema,
-  generateUuid8,
-  generateSprintId
-};