ralphctl 0.1.2 → 0.1.4

package/dist/chunk-OEUJDSHY.mjs

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+// src/utils/result-helpers.ts
+import { Result } from "typescript-result";
+async function wrapAsync(fn, mapError) {
+  try {
+    const value = await fn();
+    return Result.ok(value);
+  } catch (err) {
+    return Result.error(mapError(err));
+  }
+}
+function ensureError(err) {
+  return err instanceof Error ? err : new Error(String(err));
+}
+function unwrapOrThrow(result) {
+  if (result.ok) {
+    return result.value;
+  }
+  throw result.error;
+}
+
+export {
+  wrapAsync,
+  ensureError,
+  unwrapOrThrow
+};

package/dist/{chunk-WGHJI3OI.mjs → chunk-PDI6HBZ7.mjs}

@@ -7,26 +7,16 @@ import {
   readValidatedJson,
   validateProjectPath,
   writeValidatedJson
-} from "./chunk-6PYTKGB5.mjs";
+} from "./chunk-W3TY22IS.mjs";
+import {
+  ParseError,
+  ProjectExistsError,
+  ProjectNotFoundError,
+  ValidationError
+} from "./chunk-EDJX7TT6.mjs";
 
 // src/store/project.ts
 import { basename, resolve } from "path";
-var ProjectNotFoundError = class extends Error {
-  projectName;
-  constructor(projectName) {
-    super(`Project not found: ${projectName}`);
-    this.name = "ProjectNotFoundError";
-    this.projectName = projectName;
-  }
-};
-var ProjectExistsError = class extends Error {
-  projectName;
-  constructor(projectName) {
-    super(`Project already exists: ${projectName}`);
-    this.name = "ProjectExistsError";
-    this.projectName = projectName;
-  }
-};
 function migrateProjectIfNeeded(project) {
   if (project.repositories) {
     return project;
@@ -42,7 +32,7 @@ function migrateProjectIfNeeded(project) {
       description: project.description
     };
   }
-  throw new Error(`Invalid project data: no paths or repositories for ${project.name}`);
+  throw new ParseError(`Invalid project data: no paths or repositories for ${project.name}`);
 }
 async function listProjects() {
   const filePath = getProjectsFilePath();
@@ -56,10 +46,13 @@ async function listProjects() {
   if (needsMigration) {
     const migrated = rawData.map(migrateProjectIfNeeded);
     const validated = ProjectsSchema.parse(migrated);
-    await writeValidatedJson(filePath, validated, ProjectsSchema);
+    const writeResult = await writeValidatedJson(filePath, validated, ProjectsSchema);
+    if (!writeResult.ok) throw writeResult.error;
     return validated;
   }
-  const projects = await readValidatedJson(filePath, ProjectsSchema);
+  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) => ({
@@ -69,7 +62,8 @@ async function listProjects() {
       )
     }));
     const validated = ProjectsSchema.parse(corrected);
-    await writeValidatedJson(filePath, validated, ProjectsSchema);
+    const writeResult = await writeValidatedJson(filePath, validated, ProjectsSchema);
+    if (!writeResult.ok) throw writeResult.error;
     return validated;
   }
   return projects;
@@ -95,13 +89,13 @@ async function createProject(project) {
   for (const repo of project.repositories) {
     const resolved = resolve(expandTilde(repo.path));
     const validation = await validateProjectPath(resolved);
-    if (validation !== true) {
-      pathErrors.push(`  ${repo.path}: ${validation}`);
+    if (!validation.ok) {
+      pathErrors.push(`  ${repo.path}: ${validation.error.message}`);
     }
   }
   if (pathErrors.length > 0) {
-    throw new Error(`Invalid project paths:
-${pathErrors.join("\n")}`);
+    throw new ValidationError(`Invalid project paths:
+${pathErrors.join("\n")}`, "repositories");
   }
   const normalizedProject = {
     ...project,
@@ -112,7 +106,8 @@ ${pathErrors.join("\n")}`);
     }))
   };
   projects.push(normalizedProject);
-  await writeValidatedJson(getProjectsFilePath(), projects, ProjectsSchema);
+  const writeResult = await writeValidatedJson(getProjectsFilePath(), projects, ProjectsSchema);
+  if (!writeResult.ok) throw writeResult.error;
   return normalizedProject;
 }
 async function updateProject(name, updates) {
@@ -126,13 +121,13 @@ async function updateProject(name, updates) {
     for (const repo of updates.repositories) {
       const resolved = resolve(expandTilde(repo.path));
       const validation = await validateProjectPath(resolved);
-      if (validation !== true) {
-        pathErrors.push(`  ${repo.path}: ${validation}`);
+      if (!validation.ok) {
+        pathErrors.push(`  ${repo.path}: ${validation.error.message}`);
       }
     }
     if (pathErrors.length > 0) {
-      throw new Error(`Invalid project paths:
-${pathErrors.join("\n")}`);
+      throw new ValidationError(`Invalid project paths:
+${pathErrors.join("\n")}`, "repositories");
     }
     updates.repositories = updates.repositories.map((repo) => ({
       ...repo,
@@ -151,7 +146,8 @@ ${pathErrors.join("\n")}`);
     description: updates.description ?? existingProject.description
   };
   projects[index] = updatedProject;
-  await writeValidatedJson(getProjectsFilePath(), projects, ProjectsSchema);
+  const writeResult = await writeValidatedJson(getProjectsFilePath(), projects, ProjectsSchema);
+  if (!writeResult.ok) throw writeResult.error;
   return updatedProject;
 }
 async function removeProject(name) {
@@ -161,7 +157,8 @@ async function removeProject(name) {
     throw new ProjectNotFoundError(name);
   }
   projects.splice(index, 1);
-  await writeValidatedJson(getProjectsFilePath(), projects, ProjectsSchema);
+  const writeResult = await writeValidatedJson(getProjectsFilePath(), projects, ProjectsSchema);
+  if (!writeResult.ok) throw writeResult.error;
 }
 async function getProjectRepos(name) {
   const project = await getProject(name);
@@ -171,8 +168,8 @@ async function addProjectRepo(name, repo) {
   const project = await getProject(name);
   const resolvedPath = resolve(expandTilde(repo.path));
   const validation = await validateProjectPath(resolvedPath);
-  if (validation !== true) {
-    throw new Error(`Invalid path ${repo.path}: ${validation}`);
+  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;
@@ -191,7 +188,7 @@ async function removeProjectRepo(name, path) {
   const resolvedPath = resolve(expandTilde(path));
   const newRepos = project.repositories.filter((r) => r.path !== resolvedPath);
   if (newRepos.length === 0) {
-    throw new Error("Cannot remove the last repository from a project");
+    throw new ValidationError("Cannot remove the last repository from a project", "repositories");
   }
   if (newRepos.length === project.repositories.length) {
     return project;
@@ -200,8 +197,6 @@ async function removeProjectRepo(name, path) {
 }
 
 export {
-  ProjectNotFoundError,
-  ProjectExistsError,
   listProjects,
   getProject,
   projectExists,

package/dist/{chunk-6PYTKGB5.mjs → chunk-W3TY22IS.mjs}

@@ -1,4 +1,9 @@
 #!/usr/bin/env node
+import {
+  IOError,
+  StorageError,
+  ValidationError
+} from "./chunk-EDJX7TT6.mjs";
 
 // src/utils/paths.ts
 import { fileURLToPath } from "url";
@@ -6,6 +11,7 @@ import { dirname, isAbsolute, join, resolve, sep } from "path";
 import { existsSync } from "fs";
 import { homedir } from "os";
 import { lstat, realpath, stat } from "fs/promises";
+import { Result } from "typescript-result";
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname(__filename);
 function getRepoRoot() {
@@ -80,38 +86,25 @@ async function validateProjectPath(path) {
       const realPath = await realpath(resolved);
       const realStats = await stat(realPath);
       if (!realStats.isDirectory()) {
-        return "Symlink target is not a directory";
+        return Result.error(new IOError("Symlink target is not a directory"));
       }
-      return true;
+      return Result.ok(true);
     }
     if (!lstats.isDirectory()) {
-      return "Path is not a directory";
+      return Result.error(new IOError("Path is not a directory"));
     }
-    return true;
-  } catch {
-    return "Directory does not exist";
+    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/utils/storage.ts
 import { access, appendFile, mkdir, readdir, readFile, rm, writeFile } from "fs/promises";
 import { dirname as dirname2 } from "path";
-var ValidationError = class extends Error {
-  path;
-  constructor(message, path, cause) {
-    super(message, { cause });
-    this.name = "ValidationError";
-    this.path = path;
-  }
-};
-var FileNotFoundError = class extends Error {
-  path;
-  constructor(message, path) {
-    super(message);
-    this.name = "FileNotFoundError";
-    this.path = path;
-  }
-};
+import { Result as Result2 } from "typescript-result";
 async function ensureDir(dirPath) {
   await mkdir(dirPath, { recursive: true });
 }
@@ -140,46 +133,61 @@ async function readValidatedJson(filePath, schema) {
     content = await readFile(filePath, "utf-8");
   } catch (err) {
     if (err instanceof Error && "code" in err && err.code === "ENOENT") {
-      throw new FileNotFoundError(`File not found: ${filePath}`, filePath);
+      return Result2.error(new StorageError(`File not found: ${filePath}`, err instanceof Error ? err : void 0));
     }
-    throw err;
+    return Result2.error(new StorageError(`Failed to read ${filePath}`, err instanceof Error ? err : void 0));
   }
   let data;
   try {
     data = JSON.parse(content);
   } catch (err) {
-    throw new ValidationError(`Invalid JSON in ${filePath}`, filePath, 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");
-    throw new ValidationError(`Validation failed for ${filePath}:
-${issues}`, filePath, result.error);
+    return Result2.error(new ValidationError(`Validation failed for ${filePath}:
+${issues}`, filePath, result.error));
   }
-  return result.data;
+  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");
-    throw new ValidationError(`Validation failed before writing to ${filePath}:
-${issues}`, filePath, result.error);
+    return Result2.error(
+      new ValidationError(`Validation failed before writing to ${filePath}:
+${issues}`, filePath, result.error)
+    );
   }
-  await ensureDir(dirname2(filePath));
-  await writeFile(filePath, JSON.stringify(result.data, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
+  try {
+    await ensureDir(dirname2(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) {
-  await ensureDir(dirname2(filePath));
-  await appendFile(filePath, content, { encoding: "utf-8", mode: 384 });
+  try {
+    await ensureDir(dirname2(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 {
-    return await readFile(filePath, "utf-8");
+    const content = await readFile(filePath, "utf-8");
+    return Result2.ok(content);
   } catch (err) {
     if (err instanceof Error && "code" in err && err.code === "ENOENT") {
-      throw new FileNotFoundError(`File not found: ${filePath}`, filePath);
+      return Result2.error(new StorageError(`File not found: ${filePath}`, err instanceof Error ? err : void 0));
     }
-    throw err;
+    return Result2.error(new StorageError(`Failed to read ${filePath}`, err instanceof Error ? err : void 0));
   }
 }
 
@@ -292,8 +300,6 @@ export {
   assertSafeCwd,
   expandTilde,
   validateProjectPath,
-  ValidationError,
-  FileNotFoundError,
   ensureDir,
   removeDir,
   fileExists,

package/dist/{chunk-MRKOFVTM.mjs → chunk-YIB7QYU4.mjs}

@@ -1,19 +1,26 @@
 #!/usr/bin/env node
 import {
   escapableSelect
-} from "./chunk-NTWO2LXB.mjs";
+} from "./chunk-7LZ6GOGN.mjs";
 import {
   EXIT_ERROR,
   exitWithCode
 } from "./chunk-7TG3EAQ2.mjs";
 import {
-  ProjectExistsError,
   createProject
-} from "./chunk-WGHJI3OI.mjs";
+} from "./chunk-PDI6HBZ7.mjs";
+import {
+  ensureError,
+  wrapAsync
+} from "./chunk-OEUJDSHY.mjs";
 import {
   expandTilde,
   validateProjectPath
-} from "./chunk-6PYTKGB5.mjs";
+} from "./chunk-W3TY22IS.mjs";
+import {
+  IOError,
+  ProjectExistsError
+} from "./chunk-EDJX7TT6.mjs";
 import {
   createSpinner,
   emoji,
@@ -32,34 +39,27 @@ import {
 import { existsSync as existsSync2, statSync as statSync2 } from "fs";
 import { basename, join as join3, resolve as resolve2 } from "path";
 import { input, select } from "@inquirer/prompts";
+import { Result as Result3 } from "typescript-result";
 
 // src/interactive/file-browser.ts
 import { readdirSync, statSync } from "fs";
 import { homedir } from "os";
 import { dirname, join, resolve } from "path";
+import { Result } from "typescript-result";
 function listDirectories(dirPath) {
-  try {
-    const entries = readdirSync(dirPath, { withFileTypes: true });
-    return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name).sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
-  } catch {
-    return [];
-  }
+  const r = Result.try(() => readdirSync(dirPath, { withFileTypes: true }));
+  if (!r.ok) return [];
+  return r.value.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name).sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
 }
 function hasSubdirectories(dirPath) {
-  try {
-    const entries = readdirSync(dirPath, { withFileTypes: true });
-    return entries.some((e) => e.isDirectory() && !e.name.startsWith("."));
-  } catch {
-    return false;
-  }
+  const r = Result.try(() => readdirSync(dirPath, { withFileTypes: true }));
+  if (!r.ok) return false;
+  return r.value.some((e) => e.isDirectory() && !e.name.startsWith("."));
 }
 function isGitRepo(dirPath) {
-  try {
-    const gitDir = join(dirPath, ".git");
-    return statSync(gitDir).isDirectory();
-  } catch {
-    return false;
-  }
+  const r = Result.try(() => statSync(join(dirPath, ".git")));
+  if (!r.ok) return false;
+  return r.value.isDirectory();
 }
 async function browseDirectory(message = "Browse to directory:", startPath) {
   let currentPath = startPath ? resolve(startPath) : homedir();
@@ -106,36 +106,37 @@ async function browseDirectory(message = "Browse to directory:", startPath) {
       name: muted("Cancel"),
       value: "__CANCEL__"
     });
-    try {
-      const selected = await escapableSelect({
+    const selectResult = await wrapAsync(
+      () => escapableSelect({
         message: `${emoji.donut} ${message}
    ${muted(currentPath)}`,
         choices,
         pageSize: 15,
         loop: false
-      });
-      if (selected === null) {
-        return null;
-      }
-      switch (selected) {
-        case "__SELECT__":
-          return currentPath;
-        case "__PARENT__":
-          currentPath = parentDir;
-          break;
-        case "__HOME__":
-          currentPath = homedir();
-          break;
-        case "__CANCEL__":
-          return null;
-        default:
-          currentPath = selected;
-      }
-    } catch (err) {
-      if (err.name === "ExitPromptError") {
+      }),
+      ensureError
+    );
+    if (!selectResult.ok) {
+      if (selectResult.error.name === "ExitPromptError") return null;
+      throw selectResult.error;
+    }
+    const selected = selectResult.value;
+    if (selected === null) {
+      return null;
+    }
+    switch (selected) {
+      case "__SELECT__":
+        return currentPath;
+      case "__PARENT__":
+        currentPath = parentDir;
+        break;
+      case "__HOME__":
+        currentPath = homedir();
+        break;
+      case "__CANCEL__":
         return null;
-      }
-      throw err;
+      default:
+        currentPath = selected;
     }
   }
 }
@@ -143,6 +144,7 @@ async function browseDirectory(message = "Browse to directory:", startPath) {
 // src/utils/detect-scripts.ts
 import { existsSync, readFileSync } from "fs";
 import { join as join2 } from "path";
+import { Result as Result2 } from "typescript-result";
 function detectNodePackageManager(projectPath) {
   if (existsSync(join2(projectPath, "pnpm-lock.yaml"))) return "pnpm";
   if (existsSync(join2(projectPath, "yarn.lock"))) return "yarn";
@@ -156,15 +158,20 @@ var NODE_PRIMARY_GROUPS = [
 var NODE_FALLBACK_GROUPS = [
   { label: "build", aliases: ["build", "compile"] }
 ];
-function readPackageJsonScripts(projectPath) {
+function safeReadPackageJsonScripts(projectPath) {
   try {
     const raw = readFileSync(join2(projectPath, "package.json"), "utf-8");
     const pkg = JSON.parse(raw);
-    return pkg.scripts ?? {};
+    return Result2.ok(pkg.scripts ?? {});
   } catch {
-    return {};
+    return Result2.error(new IOError("Failed to read package.json"));
   }
 }
+function readPackageJsonScripts(projectPath) {
+  const result = safeReadPackageJsonScripts(projectPath);
+  if (!result.ok) return {};
+  return result.value;
+}
 var nodeDetector = {
   type: "node",
   label: "Node.js",
@@ -285,25 +292,19 @@ function validateSlug(slug) {
   return /^[a-z0-9-]+$/.test(slug);
 }
 function isGitRepo2(path) {
-  try {
-    const gitDir = join3(path, ".git");
-    return existsSync2(gitDir) && statSync2(gitDir).isDirectory();
-  } catch {
-    return false;
-  }
+  const gitDir = join3(path, ".git");
+  const r = Result3.try(() => existsSync2(gitDir) && statSync2(gitDir).isDirectory());
+  return r.ok ? r.value : false;
 }
 function hasAiInstructions(repoPath) {
   return existsSync2(join3(repoPath, "CLAUDE.md")) || existsSync2(join3(repoPath, ".github", "copilot-instructions.md"));
 }
 async function addCheckScriptToRepository(repo) {
   let suggested = null;
-  try {
-    const detection = detectCheckScriptCandidates(repo.path);
-    if (detection) {
-      log.success(`  Detected: ${detection.typeLabel}`);
-      suggested = suggestCheckScript(repo.path);
-    }
-  } catch {
+  const detectR = Result3.try(() => detectCheckScriptCandidates(repo.path));
+  if (detectR.ok && detectR.value) {
+    log.success(`  Detected: ${detectR.value.typeLabel}`);
+    suggested = suggestCheckScript(repo.path);
   }
   const checkInput = await input({
     message: "  Check script (optional):",
@@ -340,8 +341,8 @@ async function projectAddCommand(options = {}) {
       for (const path of options.paths) {
         const resolved = resolve2(expandTilde(path.trim()));
         const validation = await validateProjectPath(resolved);
-        if (validation !== true) {
-          errors.push(`--path ${path}: ${validation}`);
+        if (!validation.ok) {
+          errors.push(`--path ${path}: ${validation.error.message}`);
         }
       }
       spinner?.succeed("Paths validated");
@@ -387,7 +388,7 @@ async function projectAddCommand(options = {}) {
       for (const p of options.paths) {
         const resolved = resolve2(expandTilde(p.trim()));
         const validation = await validateProjectPath(resolved);
-        if (validation === true) {
+        if (validation.ok) {
           repositories.push({ name: basename(resolved), path: resolved });
         }
       }
@@ -417,15 +418,15 @@ async function projectAddCommand(options = {}) {
           default: process.cwd(),
           validate: async (v) => {
             const result = await validateProjectPath(v.trim());
-            return result;
+            return result.ok ? true : result.error.message;
           }
         });
         firstPath = firstPath.trim();
       }
       const resolved = resolve2(expandTilde(firstPath));
       const validation = await validateProjectPath(resolved);
-      if (validation !== true) {
-        showError(`Invalid path: ${validation}`);
+      if (!validation.ok) {
+        showError(`Invalid path: ${validation.error.message}`);
         exitWithCode(EXIT_ERROR);
       }
       repositories.push({ name: basename(resolved), path: resolved });
@@ -459,13 +460,13 @@ Configuring: ${firstRepo.name}`);
         if (browsed) {
           const resolved = resolve2(expandTilde(browsed));
           const validation = await validateProjectPath(resolved);
-          if (validation === true) {
+          if (validation.ok) {
             const newRepo = { name: basename(resolved), path: resolved };
             log.success(`Added: ${newRepo.name}`);
             const repoWithScripts = await addCheckScriptToRepository(newRepo);
             repositories.push(repoWithScripts);
           } else {
-            log.error(`Invalid path: ${validation}`);
+            log.error(`Invalid path: ${validation.error.message}`);
           }
         }
       } else {
@@ -477,13 +478,13 @@ Configuring: ${firstRepo.name}`);
         } else {
           const resolved = resolve2(expandTilde(additionalPath.trim()));
           const validation = await validateProjectPath(resolved);
-          if (validation === true) {
+          if (validation.ok) {
             const newRepo = { name: basename(resolved), path: resolved };
             log.success(`Added: ${newRepo.name}`);
             const repoWithScripts = await addCheckScriptToRepository(newRepo);
             repositories.push(repoWithScripts);
           } else {
-            log.error(`Invalid path: ${validation}`);
+            log.error(`Invalid path: ${validation.error.message}`);
           }
         }
       }
@@ -495,40 +496,41 @@ Configuring: ${firstRepo.name}`);
     const trimmedDescInteractive = description.trim();
     description = trimmedDescInteractive === "" ? void 0 : trimmedDescInteractive;
   }
-  try {
-    const project = {
-      name,
-      displayName,
-      repositories,
-      description
-    };
-    const created = await createProject(project);
-    showSuccess("Project added!", [
-      ["Name", created.name],
-      ["Display Name", created.displayName]
-    ]);
-    if (created.description) {
-      console.log(field("Description", created.description));
-    }
-    console.log(field("Repositories", ""));
-    for (const repo of created.repositories) {
-      log.item(`${repo.name} \u2192 ${repo.path}`);
-      if (repo.checkScript) {
-        console.log(`        Check: ${repo.checkScript}`);
-      } else {
-        console.log(`        Check: ${muted("(not configured)")}`);
-      }
-    }
-    console.log("");
-  } catch (err) {
-    if (err instanceof ProjectExistsError) {
+  const project = {
+    name,
+    displayName,
+    repositories,
+    description
+  };
+  const createR = await wrapAsync(() => createProject(project), ensureError);
+  if (!createR.ok) {
+    if (createR.error instanceof ProjectExistsError) {
       showError(`Project "${name}" already exists.`);
       showNextStep(`ralphctl project remove ${name}`, "remove existing project first");
       log.newline();
     } else {
-      throw err;
+      throw createR.error;
+    }
+    return;
+  }
+  const created = createR.value;
+  showSuccess("Project added!", [
+    ["Name", created.name],
+    ["Display Name", created.displayName]
+  ]);
+  if (created.description) {
+    console.log(field("Description", created.description));
+  }
+  console.log(field("Repositories", ""));
+  for (const repo of created.repositories) {
+    log.item(`${repo.name} \u2192 ${repo.path}`);
+    if (repo.checkScript) {
+      console.log(`        Check: ${repo.checkScript}`);
+    } else {
+      console.log(`        Check: ${muted("(not configured)")}`);
     }
   }
+  console.log("");
 }
 
 export {