ralphctl 0.4.6 → 0.6.0

package/dist/chunk-BSB4EDGR.mjs

@@ -1,260 +0,0 @@
-#!/usr/bin/env node
-import {
-  ProjectsSchema,
-  expandTilde,
-  fileExists,
-  generateUuid8,
-  getProjectsFilePath,
-  readValidatedJson,
-  validateProjectPath,
-  writeValidatedJson
-} from "./chunk-WDMLPXOD.mjs";
-import {
-  ParseError,
-  ProjectExistsError,
-  ProjectNotFoundError,
-  ValidationError
-} from "./chunk-VAZ3LJBI.mjs";
-
-// src/integration/persistence/project.ts
-import { basename, resolve } from "path";
-function migrateProjectIfNeeded(project) {
-  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() {
-  const filePath = getProjectsFilePath();
-  if (!await fileExists(filePath)) {
-    return [];
-  }
-  const { readFile } = await import("fs/promises");
-  const content = await readFile(filePath, "utf-8");
-  const rawData = JSON.parse(content);
-  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);
-    const writeResult = await writeValidatedJson(filePath, validated, ProjectsSchema);
-    if (!writeResult.ok) throw writeResult.error;
-    return validated;
-  }
-  const result = await readValidatedJson(filePath, ProjectsSchema);
-  if (!result.ok) throw result.error;
-  const projects = result.value;
-  const hasTildePaths = projects.some((p) => p.repositories.some((r) => r.path.startsWith("~")));
-  if (hasTildePaths) {
-    const corrected = projects.map((project) => ({
-      ...project,
-      repositories: project.repositories.map(
-        (repo) => repo.path.startsWith("~") ? { ...repo, path: resolve(expandTilde(repo.path)) } : repo
-      )
-    }));
-    const validated = ProjectsSchema.parse(corrected);
-    const writeResult = await writeValidatedJson(filePath, validated, ProjectsSchema);
-    if (!writeResult.ok) throw writeResult.error;
-    return validated;
-  }
-  return projects;
-}
-async function getProject(name) {
-  const projects = await listProjects();
-  const project = projects.find((p) => p.name === name);
-  if (!project) {
-    throw new ProjectNotFoundError(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(input) {
-  const projects = await listProjects();
-  if (projects.some((p) => p.name === input.name)) {
-    throw new ProjectExistsError(input.name);
-  }
-  const pathErrors = [];
-  for (const repo of input.repositories) {
-    const resolved = resolve(expandTilde(repo.path));
-    const validation = await validateProjectPath(resolved);
-    if (!validation.ok) {
-      pathErrors.push(`  ${repo.path}: ${validation.error.message}`);
-    }
-  }
-  if (pathErrors.length > 0) {
-    throw new ValidationError(`Invalid project paths:
-${pathErrors.join("\n")}`, "repositories");
-  }
-  const normalizedProject = {
-    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);
-  if (!writeResult.ok) throw writeResult.error;
-  return normalizedProject;
-}
-async function updateProject(name, updates) {
-  const projects = await listProjects();
-  const index = projects.findIndex((p) => p.name === name);
-  if (index === -1) {
-    throw new ProjectNotFoundError(name);
-  }
-  if (updates.repositories) {
-    const pathErrors = [];
-    for (const repo of updates.repositories) {
-      const resolved = resolve(expandTilde(repo.path));
-      const validation = await validateProjectPath(resolved);
-      if (!validation.ok) {
-        pathErrors.push(`  ${repo.path}: ${validation.error.message}`);
-      }
-    }
-    if (pathErrors.length > 0) {
-      throw new ValidationError(`Invalid project paths:
-${pathErrors.join("\n")}`, "repositories");
-    }
-    updates.repositories = updates.repositories.map((repo) => ({
-      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];
-  if (!existingProject) {
-    throw new ProjectNotFoundError(name);
-  }
-  const updatedProject = {
-    id: existingProject.id,
-    name: existingProject.name,
-    displayName: updates.displayName ?? existingProject.displayName,
-    repositories: updates.repositories ?? existingProject.repositories,
-    description: updates.description ?? existingProject.description
-  };
-  projects[index] = updatedProject;
-  const writeResult = await writeValidatedJson(getProjectsFilePath(), projects, ProjectsSchema);
-  if (!writeResult.ok) throw writeResult.error;
-  return updatedProject;
-}
-async function removeProject(name) {
-  const projects = await listProjects();
-  const index = projects.findIndex((p) => p.name === name);
-  if (index === -1) {
-    throw new ProjectNotFoundError(name);
-  }
-  projects.splice(index, 1);
-  const writeResult = await writeValidatedJson(getProjectsFilePath(), projects, ProjectsSchema);
-  if (!writeResult.ok) throw writeResult.error;
-}
-async function addProjectRepo(name, repo) {
-  const project = await getProject(name);
-  const resolvedPath = resolve(expandTilde(repo.path));
-  const validation = await validateProjectPath(resolvedPath);
-  if (!validation.ok) {
-    throw new ValidationError(`Invalid path ${repo.path}: ${validation.error.message}`, repo.path);
-  }
-  if (project.repositories.some((r) => r.path === resolvedPath)) {
-    return project;
-  }
-  const normalizedRepo = {
-    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]
-  });
-}
-async function removeProjectRepo(name, path) {
-  const project = await getProject(name);
-  const resolvedPath = resolve(expandTilde(path));
-  const newRepos = project.repositories.filter((r) => r.path !== resolvedPath);
-  if (newRepos.length === 0) {
-    throw new ValidationError("Cannot remove the last repository from a project", "repositories");
-  }
-  if (newRepos.length === project.repositories.length) {
-    return project;
-  }
-  return updateProject(name, { repositories: newRepos });
-}
-
-export {
-  listProjects,
-  getProject,
-  getProjectById,
-  getRepoById,
-  resolveRepoPath,
-  projectExists,
-  createProject,
-  updateProject,
-  removeProject,
-  addProjectRepo,
-  removeProjectRepo
-};

package/dist/chunk-CBMFRQ4Y.mjs

@@ -1,441 +0,0 @@
-#!/usr/bin/env node
-import {
-  getCurrentSprint,
-  log
-} from "./chunk-XN2UIHBY.mjs";
-import {
-  SprintSchema,
-  TasksSchema,
-  appendToFile,
-  assertSafeCwd,
-  ensureDir,
-  fileExists,
-  generateSprintId,
-  getProgressFilePath,
-  getSprintDir,
-  getSprintFilePath,
-  getSprintsDir,
-  getTasksFilePath,
-  listDirs,
-  readTextFile,
-  readValidatedJson,
-  removeDir,
-  writeValidatedJson
-} from "./chunk-WDMLPXOD.mjs";
-import {
-  LockError,
-  NoCurrentSprintError,
-  SprintNotFoundError,
-  SprintStatusError,
-  StorageError
-} from "./chunk-VAZ3LJBI.mjs";
-
-// src/integration/persistence/progress.ts
-import { execSync } from "child_process";
-
-// src/integration/persistence/file-lock.ts
-import { mkdir, readFile, unlink, writeFile } from "fs/promises";
-import { dirname } from "path";
-import { Result } from "typescript-result";
-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 Result.ok(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;
-      }
-      return Result.error(
-        new LockError(
-          `Failed to acquire lock: ${err instanceof Error ? err.message : String(err)}`,
-          lockPath,
-          err instanceof Error ? err : void 0
-        )
-      );
-    }
-  }
-  return Result.error(new LockError(`Failed to acquire lock after ${String(MAX_RETRIES)} retries`, lockPath));
-}
-async function withFileLock(filePath, fn) {
-  const lockResult = await acquireLock(filePath);
-  if (!lockResult.ok) {
-    return lockResult;
-  }
-  const release = lockResult.value;
-  try {
-    const value = await fn();
-    return Result.ok(value);
-  } finally {
-    await release();
-  }
-}
-
-// src/integration/persistence/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);
-  const lockResult = await withFileLock(progressPath, async () => {
-    const appendResult = await appendToFile(progressPath, entry);
-    if (!appendResult.ok) throw appendResult.error;
-  });
-  if (!lockResult.ok) throw lockResult.error;
-}
-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("");
-  const appendResult = await appendToFile(getProgressFilePath(sprintId), lines.join("\n"));
-  if (!appendResult.ok) throw appendResult.error;
-}
-async function getProgress(sprintId) {
-  const id = await resolveSprintId(sprintId);
-  const result = await readTextFile(getProgressFilePath(id));
-  if (!result.ok) {
-    if (result.error instanceof StorageError && result.error.cause && "code" in result.error.cause && result.error.cause.code === "ENOENT") {
-      return "";
-    }
-    throw result.error;
-  }
-  return result.value;
-}
-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/integration/persistence/sprint.ts
-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(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,
-    closedAt: null,
-    tickets: [],
-    checkRanAt: {},
-    branch: null
-  };
-  const sprintDir = getSprintDir(id);
-  await ensureDir(sprintDir);
-  const writeSprintResult = await writeValidatedJson(getSprintFilePath(id), sprint, SprintSchema);
-  if (!writeSprintResult.ok) throw writeSprintResult.error;
-  const writeTasksResult = await writeValidatedJson(getTasksFilePath(id), [], TasksSchema);
-  if (!writeTasksResult.ok) throw writeTasksResult.error;
-  const appendResult = await appendToFile(
-    getProgressFilePath(id),
-    `# Sprint: ${displayName}
-
-Created: ${now}
-
----
-
-`
-  );
-  if (!appendResult.ok) throw appendResult.error;
-  return sprint;
-}
-async function getSprint(sprintId) {
-  const sprintPath = getSprintFilePath(sprintId);
-  if (!await fileExists(sprintPath)) {
-    throw new SprintNotFoundError(sprintId);
-  }
-  const result = await readValidatedJson(sprintPath, SprintSchema);
-  if (!result.ok) throw result.error;
-  return result.value;
-}
-async function saveSprint(sprint) {
-  const result = await writeValidatedJson(getSprintFilePath(sprint.id), sprint, SprintSchema);
-  if (!result.ok) throw result.error;
-}
-async function listSprints() {
-  const sprintsDir = getSprintsDir();
-  const dirs = await listDirs(sprintsDir);
-  const sprints = [];
-  for (const dir of dirs) {
-    const sprintPath = getSprintFilePath(dir);
-    if (!await fileExists(sprintPath)) continue;
-    const result = await readValidatedJson(sprintPath, SprintSchema);
-    if (!result.ok) continue;
-    sprints.push(result.value);
-  }
-  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 tasksResult = await readValidatedJson(getTasksFilePath(sprintId), TasksSchema);
-  if (!tasksResult.ok) throw tasksResult.error;
-  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");
-  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 NoCurrentSprintError();
-  }
-  return getSprint(currentSprintId);
-}
-async function resolveSprintId(sprintId) {
-  if (sprintId) {
-    return sprintId;
-  }
-  const currentSprintId = await getCurrentSprint();
-  if (!currentSprintId) {
-    throw new NoCurrentSprintError();
-  }
-  return currentSprintId;
-}
-
-export {
-  withFileLock,
-  logProgress,
-  getProgress,
-  summarizeProgressForContext,
-  assertSprintStatus,
-  createSprint,
-  getSprint,
-  saveSprint,
-  listSprints,
-  activateSprint,
-  logSprintBaselines,
-  closeSprint,
-  deleteSprint,
-  getCurrentSprintOrThrow,
-  resolveSprintId
-};

package/dist/chunk-CFUVE2BP.mjs

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