ralphctl 0.1.0 → 0.1.2

package/dist/chunk-MRKOFVTM.mjs

@@ -0,0 +1,537 @@
+#!/usr/bin/env node
+import {
+  escapableSelect
+} from "./chunk-NTWO2LXB.mjs";
+import {
+  EXIT_ERROR,
+  exitWithCode
+} from "./chunk-7TG3EAQ2.mjs";
+import {
+  ProjectExistsError,
+  createProject
+} from "./chunk-WGHJI3OI.mjs";
+import {
+  expandTilde,
+  validateProjectPath
+} from "./chunk-6PYTKGB5.mjs";
+import {
+  createSpinner,
+  emoji,
+  error,
+  field,
+  log,
+  muted,
+  showError,
+  showNextStep,
+  showSuccess,
+  showTip,
+  showWarning
+} from "./chunk-QBXHAXHI.mjs";
+
+// src/commands/project/add.ts
+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";
+
+// src/interactive/file-browser.ts
+import { readdirSync, statSync } from "fs";
+import { homedir } from "os";
+import { dirname, join, resolve } from "path";
+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 [];
+  }
+}
+function hasSubdirectories(dirPath) {
+  try {
+    const entries = readdirSync(dirPath, { withFileTypes: true });
+    return entries.some((e) => e.isDirectory() && !e.name.startsWith("."));
+  } catch {
+    return false;
+  }
+}
+function isGitRepo(dirPath) {
+  try {
+    const gitDir = join(dirPath, ".git");
+    return statSync(gitDir).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function browseDirectory(message = "Browse to directory:", startPath) {
+  let currentPath = startPath ? resolve(startPath) : homedir();
+  while (true) {
+    const dirs = listDirectories(currentPath);
+    const choices = [];
+    choices.push({
+      name: `${emoji.donut} Select this directory`,
+      value: "__SELECT__",
+      description: currentPath
+    });
+    const parentDir = dirname(currentPath);
+    if (parentDir !== currentPath) {
+      choices.push({
+        name: "\u2191 Parent directory",
+        value: "__PARENT__",
+        description: parentDir
+      });
+    }
+    if (currentPath !== homedir()) {
+      choices.push({
+        name: "\u2302 Home directory",
+        value: "__HOME__",
+        description: homedir()
+      });
+    }
+    for (const dir of dirs) {
+      const fullPath = join(currentPath, dir);
+      const hasChildren = hasSubdirectories(fullPath);
+      const isRepo = isGitRepo(fullPath);
+      let icon = "  ";
+      if (isRepo) {
+        icon = "\u2699 ";
+      } else if (hasChildren) {
+        icon = "\u25B8 ";
+      }
+      choices.push({
+        name: `${icon}${dir}`,
+        value: fullPath,
+        description: isRepo ? "git repo" : void 0
+      });
+    }
+    choices.push({
+      name: muted("Cancel"),
+      value: "__CANCEL__"
+    });
+    try {
+      const selected = await 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") {
+        return null;
+      }
+      throw err;
+    }
+  }
+}
+
+// src/utils/detect-scripts.ts
+import { existsSync, readFileSync } from "fs";
+import { join as join2 } from "path";
+function detectNodePackageManager(projectPath) {
+  if (existsSync(join2(projectPath, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(join2(projectPath, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+var NODE_PRIMARY_GROUPS = [
+  { label: "linting", aliases: ["lint", "eslint", "lint:check"] },
+  { label: "type checking", aliases: ["typecheck", "type-check", "tsc", "check-types"] },
+  { label: "tests", aliases: ["test", "test:unit", "test:run", "vitest", "jest"] }
+];
+var NODE_FALLBACK_GROUPS = [
+  { label: "build", aliases: ["build", "compile"] }
+];
+function readPackageJsonScripts(projectPath) {
+  try {
+    const raw = readFileSync(join2(projectPath, "package.json"), "utf-8");
+    const pkg = JSON.parse(raw);
+    return pkg.scripts ?? {};
+  } catch {
+    return {};
+  }
+}
+var nodeDetector = {
+  type: "node",
+  label: "Node.js",
+  detect: (path) => existsSync(join2(path, "package.json")),
+  getInstallCommand: (path) => {
+    const pm = detectNodePackageManager(path);
+    return `${pm} install`;
+  },
+  getCandidates: (path) => {
+    const scripts = readPackageJsonScripts(path);
+    const pm = detectNodePackageManager(path);
+    const run = pm === "npm" ? "npm run" : pm;
+    const candidates = [];
+    for (const group of NODE_PRIMARY_GROUPS) {
+      const match = group.aliases.find((name) => name in scripts);
+      if (match) {
+        candidates.push({ label: group.label, command: `${run} ${match}`, selected: true });
+      }
+    }
+    if (candidates.length === 0) {
+      for (const group of NODE_FALLBACK_GROUPS) {
+        const match = group.aliases.find((name) => name in scripts);
+        if (match) {
+          candidates.push({ label: group.label, command: `${run} ${match}`, selected: false });
+        }
+      }
+    }
+    return candidates;
+  }
+};
+var pythonDetector = {
+  type: "python",
+  label: "Python",
+  detect: (path) => existsSync(join2(path, "pyproject.toml")) || existsSync(join2(path, "setup.py")),
+  getInstallCommand: (path) => {
+    if (existsSync(join2(path, "uv.lock"))) return "uv sync";
+    if (existsSync(join2(path, "requirements.txt"))) return "pip install -r requirements.txt";
+    if (existsSync(join2(path, "pyproject.toml"))) return "pip install -e .";
+    return null;
+  },
+  getCandidates: () => [{ label: "tests", command: "pytest", selected: true }]
+};
+var goDetector = {
+  type: "go",
+  label: "Go",
+  detect: (path) => existsSync(join2(path, "go.mod")),
+  getInstallCommand: () => "go mod download",
+  getCandidates: () => [
+    { label: "tests", command: "go test ./...", selected: true },
+    { label: "vet", command: "go vet ./...", selected: true }
+  ]
+};
+var rustDetector = {
+  type: "rust",
+  label: "Rust",
+  detect: (path) => existsSync(join2(path, "Cargo.toml")),
+  getInstallCommand: () => "cargo build",
+  getCandidates: () => [
+    { label: "tests", command: "cargo test", selected: true },
+    { label: "clippy", command: "cargo clippy", selected: false }
+  ]
+};
+var gradleDetector = {
+  type: "java-gradle",
+  label: "Java (Gradle)",
+  detect: (path) => existsSync(join2(path, "build.gradle")) || existsSync(join2(path, "build.gradle.kts")),
+  getInstallCommand: () => null,
+  getCandidates: () => [{ label: "clean build", command: "./gradlew clean build", selected: true }]
+};
+var mavenDetector = {
+  type: "java-maven",
+  label: "Java (Maven)",
+  detect: (path) => existsSync(join2(path, "pom.xml")),
+  getInstallCommand: () => null,
+  getCandidates: () => [{ label: "clean install", command: "mvn clean install", selected: true }]
+};
+var makefileDetector = {
+  type: "makefile",
+  label: "Makefile",
+  detect: (path) => existsSync(join2(path, "Makefile")),
+  getInstallCommand: () => null,
+  getCandidates: () => [{ label: "check/test", command: "make check || make test", selected: true }]
+};
+var ECOSYSTEM_REGISTRY = [
+  nodeDetector,
+  pythonDetector,
+  goDetector,
+  rustDetector,
+  gradleDetector,
+  mavenDetector,
+  makefileDetector
+];
+function detectCheckScriptCandidates(projectPath) {
+  for (const detector of ECOSYSTEM_REGISTRY) {
+    if (detector.detect(projectPath)) {
+      return {
+        type: detector.type,
+        typeLabel: detector.label,
+        installCommand: detector.getInstallCommand(projectPath),
+        candidates: detector.getCandidates(projectPath)
+      };
+    }
+  }
+  return null;
+}
+function suggestCheckScript(projectPath) {
+  const result = detectCheckScriptCandidates(projectPath);
+  if (!result) return null;
+  const parts = [];
+  if (result.installCommand) parts.push(result.installCommand);
+  const selected = result.candidates.filter((c) => c.selected).map((c) => c.command);
+  parts.push(...selected);
+  return parts.length > 0 ? parts.join(" && ") : null;
+}
+
+// src/commands/project/add.ts
+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;
+  }
+}
+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 checkInput = await input({
+    message: "  Check script (optional):",
+    default: suggested ?? void 0
+  });
+  const checkScript = checkInput.trim() || void 0;
+  return {
+    ...repo,
+    checkScript
+  };
+}
+async function projectAddCommand(options = {}) {
+  let name;
+  let displayName;
+  let repositories;
+  let description;
+  if (options.interactive === false) {
+    const errors = [];
+    const trimmedName = options.name?.trim();
+    const trimmedDisplayName = options.displayName?.trim();
+    if (!trimmedName) {
+      errors.push("--name is required");
+    } else if (!validateSlug(trimmedName)) {
+      errors.push("--name must be a slug (lowercase, numbers, hyphens only)");
+    }
+    if (!trimmedDisplayName) {
+      errors.push("--display-name is required");
+    }
+    if (!options.paths || options.paths.length === 0) {
+      errors.push("--path is required (at least one)");
+    }
+    if (options.paths) {
+      const spinner = options.paths.length > 1 ? createSpinner("Validating repository paths...").start() : null;
+      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}`);
+        }
+      }
+      spinner?.succeed("Paths validated");
+    }
+    if (errors.length > 0 || !trimmedName || !trimmedDisplayName || !options.paths) {
+      showError("Validation failed");
+      for (const e of errors) {
+        log.item(error(e));
+      }
+      console.log("");
+      exitWithCode(EXIT_ERROR);
+    }
+    name = trimmedName;
+    displayName = trimmedDisplayName;
+    repositories = options.paths.map((p) => {
+      const resolved = resolve2(expandTilde(p.trim()));
+      const repo = { name: basename(resolved), path: resolved };
+      if (options.checkScript) repo.checkScript = options.checkScript;
+      return repo;
+    });
+    const trimmedDesc = options.description?.trim();
+    description = trimmedDesc === "" ? void 0 : trimmedDesc;
+  } else {
+    name = await input({
+      message: "Project name (slug):",
+      default: options.name?.trim(),
+      validate: (v) => {
+        const trimmed = v.trim();
+        if (trimmed.length === 0) return "Name is required";
+        if (!validateSlug(trimmed)) return "Must be lowercase with hyphens only";
+        return true;
+      }
+    });
+    name = name.trim();
+    displayName = await input({
+      message: "Display name:",
+      default: options.displayName?.trim() ?? name,
+      validate: (v) => v.trim().length > 0 ? true : "Display name is required"
+    });
+    displayName = displayName.trim();
+    repositories = [];
+    if (options.paths) {
+      for (const p of options.paths) {
+        const resolved = resolve2(expandTilde(p.trim()));
+        const validation = await validateProjectPath(resolved);
+        if (validation === true) {
+          repositories.push({ name: basename(resolved), path: resolved });
+        }
+      }
+    }
+    if (repositories.length === 0) {
+      const pathMethod = await select({
+        message: `${emoji.donut} How to specify repository path?`,
+        choices: [
+          { name: "Browse filesystem", value: "browse", description: "Navigate from home folder" },
+          { name: "Use current directory", value: "cwd", description: process.cwd() },
+          { name: "Type path manually", value: "manual" }
+        ]
+      });
+      let firstPath;
+      if (pathMethod === "browse") {
+        const browsed = await browseDirectory("Select repository directory:");
+        if (!browsed) {
+          showError("No directory selected");
+          exitWithCode(EXIT_ERROR);
+        }
+        firstPath = browsed;
+      } else if (pathMethod === "cwd") {
+        firstPath = process.cwd();
+      } else {
+        firstPath = await input({
+          message: "Repository path:",
+          default: process.cwd(),
+          validate: async (v) => {
+            const result = await validateProjectPath(v.trim());
+            return result;
+          }
+        });
+        firstPath = firstPath.trim();
+      }
+      const resolved = resolve2(expandTilde(firstPath));
+      const validation = await validateProjectPath(resolved);
+      if (validation !== true) {
+        showError(`Invalid path: ${validation}`);
+        exitWithCode(EXIT_ERROR);
+      }
+      repositories.push({ name: basename(resolved), path: resolved });
+    }
+    const firstRepo = repositories[0];
+    if (firstRepo) {
+      if (!isGitRepo2(firstRepo.path)) {
+        showWarning("Path is not a git repository");
+      }
+      if (!hasAiInstructions(firstRepo.path)) {
+        showTip("Add CLAUDE.md or .github/copilot-instructions.md for better AI assistance");
+      }
+      log.info(`
+Configuring: ${firstRepo.name}`);
+      repositories[0] = await addCheckScriptToRepository(firstRepo);
+    }
+    let addMore = true;
+    while (addMore) {
+      const addAction = await select({
+        message: `${emoji.donut} Add another repository?`,
+        choices: [
+          { name: "No, done adding repositories", value: "done" },
+          { name: "Browse filesystem", value: "browse" },
+          { name: "Type path manually", value: "manual" }
+        ]
+      });
+      if (addAction === "done") {
+        addMore = false;
+      } else if (addAction === "browse") {
+        const browsed = await browseDirectory("Select repository directory:");
+        if (browsed) {
+          const resolved = resolve2(expandTilde(browsed));
+          const validation = await validateProjectPath(resolved);
+          if (validation === true) {
+            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}`);
+          }
+        }
+      } else {
+        const additionalPath = await input({
+          message: "Repository path:"
+        });
+        if (additionalPath.trim() === "") {
+          addMore = false;
+        } else {
+          const resolved = resolve2(expandTilde(additionalPath.trim()));
+          const validation = await validateProjectPath(resolved);
+          if (validation === true) {
+            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}`);
+          }
+        }
+      }
+    }
+    description = await input({
+      message: "Description (optional):",
+      default: options.description?.trim()
+    });
+    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) {
+      showError(`Project "${name}" already exists.`);
+      showNextStep(`ralphctl project remove ${name}`, "remove existing project first");
+      log.newline();
+    } else {
+      throw err;
+    }
+  }
+}
+
+export {
+  addCheckScriptToRepository,
+  projectAddCommand
+};

package/dist/chunk-NTWO2LXB.mjs

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+
+// src/interactive/escapable.ts
+import readline from "readline";
+import { select } from "@inquirer/prompts";
+import { bold, dim } from "colorette";
+function defaultKeysHelpTip(keys) {
+  return keys.map(([key, action]) => `${bold(key)} ${dim(action)}`).join(dim(" \u2022 "));
+}
+function withEscapeHint(config, escLabel = "back") {
+  const originalTip = config.theme?.style?.keysHelpTip;
+  return {
+    ...config,
+    theme: {
+      ...config.theme,
+      style: {
+        ...config.theme?.style,
+        keysHelpTip: (keys) => {
+          const allKeys = [...keys, ["esc", escLabel]];
+          return originalTip ? originalTip(allKeys) : defaultKeysHelpTip(allKeys);
+        }
+      }
+    }
+  };
+}
+async function escapableSelect(config, options) {
+  const controller = new AbortController();
+  readline.emitKeypressEvents(process.stdin);
+  const onKeypress = (_ch, key) => {
+    if (key?.name === "escape") {
+      controller.abort();
+    }
+  };
+  process.stdin.on("keypress", onKeypress);
+  try {
+    const result = await select(withEscapeHint(config, options?.escLabel ?? "back"), {
+      signal: controller.signal
+    });
+    return result;
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortPromptError") {
+      return null;
+    }
+    throw err;
+  } finally {
+    process.stdin.removeListener("keypress", onKeypress);
+  }
+}
+
+export {
+  escapableSelect
+};