@rigkit/cli 0.2.7 → 0.2.9

package/src/ui.ts

@@ -0,0 +1,159 @@
+// Minimal design system for the rig CLI.
+// Mirrors apps/website/src/components/CliShowcase.tsx: bold black for the thing
+// that matters, dim for muted, blue for prompts and active items, green for ok,
+// red for fail. No spinners, no log-update, no boxes. Append-only output that
+// looks the same in a TTY, a CI log, or an LLM transcript.
+
+import chalk from "chalk";
+
+const HEX_ACCENT = "#2d4df5";
+const HEX_OK = "#1f8b4c";
+const HEX_WARN = "#a36b00";
+const HEX_ERR = "#b91c1c";
+
+export const accent = (text: string) => chalk.hex(HEX_ACCENT)(text);
+export const ok = (text: string) => chalk.hex(HEX_OK)(text);
+export const warn = (text: string) => chalk.hex(HEX_WARN)(text);
+export const err = (text: string) => chalk.hex(HEX_ERR)(text);
+export const dim = (text: string) => chalk.dim(text);
+export const bold = (text: string) => chalk.bold(text);
+
+export const sym = {
+  prompt: "$",
+  arrow: "›",
+  active: "▸",
+  ok: "✓",
+  err: "✗",
+  dot: "·",
+  ellipsis: "…",
+} as const;
+
+export function title(text: string): string {
+  return bold(text);
+}
+
+export function heading(text: string): string {
+  return bold(text);
+}
+
+export function muted(text: string): string {
+  return dim(text);
+}
+
+export function prompt(command: string): string {
+  return `${accent(sym.prompt)} ${command}`;
+}
+
+export function hint(text: string): string {
+  return `${dim(sym.arrow)} ${text}`;
+}
+
+export type FileStatus = "created" | "updated" | "kept" | "failed" | "pinned";
+
+const STATUS_WORD_WIDTH = "created".length;
+
+export function fileStatus(kind: FileStatus, label: string): string {
+  switch (kind) {
+    case "created":
+      return `${ok("+")} ${bold(pad("created", STATUS_WORD_WIDTH))}  ${label}`;
+    case "updated":
+      return `${warn("~")} ${bold(pad("updated", STATUS_WORD_WIDTH))}  ${label}`;
+    case "kept":
+      return `${dim(sym.dot)} ${dim(pad("kept", STATUS_WORD_WIDTH))}  ${dim(label)}`;
+    case "pinned":
+      return `${accent("·")} ${bold(pad("pinned", STATUS_WORD_WIDTH))}  ${label}`;
+    case "failed":
+      return `${err(sym.err)} ${err(pad("failed", STATUS_WORD_WIDTH))}  ${label}`;
+  }
+}
+
+export type StepKind = "active" | "ok" | "cached" | "err";
+
+export function stepLine(kind: StepKind, label: string, detail?: string): string {
+  const tail = detail ? `  ${dim(detail)}` : "";
+  switch (kind) {
+    case "active":
+      return `${accent(sym.active)} ${bold(label)}${tail}`;
+    case "ok":
+      return `${ok(sym.ok)} ${label}${tail}`;
+    case "cached":
+      return `${dim(sym.ok)} ${dim(label)}${tail ? `  ${dim("cached")}` : `  ${dim("cached")}`}`;
+    case "err":
+      return `${err(sym.err)} ${bold(label)}${tail}`;
+  }
+}
+
+type Cell = { text: string; style?: (text: string) => string };
+type Row = Array<string | Cell>;
+
+function toCell(value: string | Cell): Cell {
+  return typeof value === "string" ? { text: value } : value;
+}
+
+export type ColumnsOptions = {
+  // Bold + underline the header row. Default true.
+  emphasizeHeader?: boolean;
+  // Two-space indent in front of each row. Default true.
+  indent?: boolean;
+};
+
+// Replacement for the old ASCII table. Aligned columns, bold-underlined header,
+// no dashed separator. Cells may carry their own style.
+export function columns(headers: string[], rows: Row[], options: ColumnsOptions = {}): string {
+  const indent = options.indent === false ? "" : "  ";
+  const emphasizeHeader = options.emphasizeHeader !== false;
+  const widths = headers.map((header, index) =>
+    Math.max(
+      header.length,
+      ...rows.map((row) => toCell(row[index] ?? "").text.length),
+    ),
+  );
+
+  const renderRow = (cells: Cell[], styleFallback?: (text: string) => string): string => {
+    const last = cells.length - 1;
+    return indent + cells
+      .map((cell, index) => {
+        const width = widths[index] ?? cell.text.length;
+        const style = cell.style ?? styleFallback;
+        const styled = style ? style(cell.text) : cell.text;
+        if (index === last) return styled;
+        const padding = " ".repeat(Math.max(0, width - cell.text.length));
+        return `${styled}${padding}  `;
+      })
+      .join("")
+      .replace(/\s+$/u, "");
+  };
+
+  const headerCells = headers.map((text) => ({ text }));
+  const lines: string[] = [];
+  lines.push(renderRow(headerCells, emphasizeHeader ? (s) => chalk.bold.underline(s) : undefined));
+  for (const row of rows) {
+    lines.push(renderRow(row.map(toCell)));
+  }
+  return lines.join("\n");
+}
+
+// "key  value" pairs aligned by the longest key. Keys are bold.
+export function kvList(pairs: Array<[string, string]>, options: { indent?: boolean } = {}): string {
+  const indent = options.indent === false ? "" : "  ";
+  const width = pairs.reduce((max, [key]) => Math.max(max, key.length), 0);
+  return pairs
+    .map(([key, value]) => `${indent}${bold(pad(key, width))}  ${value}`)
+    .join("\n");
+}
+
+export function section(headingText: string, body: string): string {
+  return `${heading(headingText)}\n${body}`;
+}
+
+export function pad(text: string, width: number): string {
+  return text.length >= width ? text : text + " ".repeat(width - text.length);
+}
+
+export function termWidth(stream: NodeJS.WriteStream = process.stderr): number {
+  return stream.columns || 80;
+}
+
+export function clip(value: string, max: number): string {
+  return value.length > max ? `${value.slice(0, Math.max(0, max - 1))}${sym.ellipsis}` : value;
+}

package/src/version.ts

@@ -1 +1 @@
-export const RIGKIT_CLI_VERSION = "0.2.7";
+export const RIGKIT_CLI_VERSION = "0.2.9";

package/src/remote-project.test.ts

@@ -1,55 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-  parseGithubProjectTarget,
-  remoteProjectId,
-  splitGithubProjectTarget,
-} from "./remote-project.ts";
-
-describe("remote GitHub project targets", () => {
-  test("parses github owner repo targets with optional refs", () => {
-    expect(parseGithubProjectTarget("github:freestyle-sh/rigkit")).toEqual({
-      kind: "github",
-      raw: "github:freestyle-sh/rigkit",
-      owner: "freestyle-sh",
-      repo: "rigkit",
-    });
-
-    expect(parseGithubProjectTarget("github:freestyle-sh/rigkit#feature/runtime")).toEqual({
-      kind: "github",
-      raw: "github:freestyle-sh/rigkit#feature/runtime",
-      owner: "freestyle-sh",
-      repo: "rigkit",
-      ref: "feature/runtime",
-    });
-  });
-
-  test("splits a run target from operation arguments", () => {
-    const split = splitGithubProjectTarget(["github:freestyle-sh/rigkit@main", "--workflow", "smoke"]);
-
-    expect(split.target).toEqual({
-      kind: "github",
-      raw: "github:freestyle-sh/rigkit@main",
-      owner: "freestyle-sh",
-      repo: "rigkit",
-      ref: "main",
-    });
-    expect(split.args).toEqual(["--workflow", "smoke"]);
-  });
-
-  test("remote project ids include repo, ref, commit, and config path", () => {
-    const id = remoteProjectId({
-      repoUrl: "https://github.com/freestyle-sh/rigkit.git",
-      ref: "main",
-      commitSha: "0123456789abcdef0123456789abcdef01234567",
-      configPath: "rig.config.ts",
-    });
-
-    expect(id).toMatch(/^github-[a-f0-9]{32}$/);
-    expect(remoteProjectId({
-      repoUrl: "https://github.com/freestyle-sh/rigkit.git",
-      ref: "main",
-      commitSha: "fedcba9876543210fedcba9876543210fedcba98",
-      configPath: "rig.config.ts",
-    })).not.toBe(id);
-  });
-});

package/src/remote-project.ts

@@ -1,225 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { createHash } from "node:crypto";
-import {
-  cpSync,
-  existsSync,
-  mkdtempSync,
-  mkdirSync,
-  readdirSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-import { defaultRigkitHome } from "@rigkit/runtime-client";
-import { DEFAULT_CONFIG_FILE } from "./project.ts";
-
-export type GithubProjectTarget = {
-  kind: "github";
-  raw: string;
-  owner: string;
-  repo: string;
-  ref?: string;
-};
-
-export type MaterializedGithubProject = {
-  target: GithubProjectTarget;
-  projectId: string;
-  projectDir: string;
-  configPath: string;
-  statePath: string;
-  commitSha: string;
-  ref: string;
-  repoUrl: string;
-};
-
-type GithubRepoInfo = {
-  default_branch?: unknown;
-};
-
-type GithubCommitInfo = {
-  sha?: unknown;
-};
-
-export function parseGithubProjectTarget(value: string): GithubProjectTarget | undefined {
-  const match = /^github:([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)(?:(?:#|@)(.+))?$/.exec(value);
-  if (!match) return undefined;
-  const owner = match[1]!;
-  const repo = match[2]!.replace(/\.git$/, "");
-  const ref = match[3]?.trim() || undefined;
-  if (!repo) return undefined;
-  return {
-    kind: "github",
-    raw: value,
-    owner,
-    repo,
-    ...(ref ? { ref } : {}),
-  };
-}
-
-export function splitGithubProjectTarget(args: string[]): {
-  target?: GithubProjectTarget;
-  args: string[];
-} {
-  const first = args[0];
-  const target = first ? parseGithubProjectTarget(first) : undefined;
-  if (!target) return { args };
-  return { target, args: args.slice(1) };
-}
-
-export async function materializeGithubProject(
-  target: GithubProjectTarget,
-  options: { rigkitHome?: string } = {},
-): Promise<MaterializedGithubProject> {
-  const repoUrl = `https://github.com/${target.owner}/${target.repo}.git`;
-  const ref = target.ref ?? await readDefaultBranch(target);
-  const commitSha = await resolveCommitSha(target, ref);
-  const projectId = remoteProjectId({ repoUrl, ref, commitSha, configPath: DEFAULT_CONFIG_FILE });
-  const projectRoot = join(options.rigkitHome ?? defaultRigkitHome(), "projects", projectId);
-  const projectDir = join(projectRoot, "checkout");
-  const configPath = join(projectDir, DEFAULT_CONFIG_FILE);
-  const statePath = join(projectRoot, "state.sqlite");
-
-  if (!existsSync(configPath)) {
-    await downloadGithubTarball(target, commitSha, projectDir);
-  }
-
-  if (!existsSync(configPath)) {
-    throw new Error(`Remote project ${target.raw} does not contain ${DEFAULT_CONFIG_FILE}`);
-  }
-
-  installProjectDependenciesIfNeeded(projectDir);
-
-  return {
-    target,
-    projectId,
-    projectDir,
-    configPath,
-    statePath,
-    commitSha,
-    ref,
-    repoUrl,
-  };
-}
-
-export function remoteProjectId(input: {
-  repoUrl: string;
-  ref: string;
-  commitSha: string;
-  configPath: string;
-}): string {
-  const hash = createHash("sha256").update(JSON.stringify({
-    repoUrl: input.repoUrl,
-    ref: input.ref,
-    commitSha: input.commitSha,
-    configPath: input.configPath,
-  })).digest("hex").slice(0, 32);
-  return `github-${hash}`;
-}
-
-function installProjectDependenciesIfNeeded(projectDir: string): void {
-  if (existsSync(runtimeBinPath(projectDir))) return;
-  if (!existsSync(join(projectDir, "package.json"))) {
-    throw new Error(`Remote project at ${projectDir} does not contain package.json`);
-  }
-
-  const command = installCommandFor(projectDir);
-  const result = spawnSync(command[0], command.slice(1), {
-    cwd: projectDir,
-    stdio: "inherit",
-    env: process.env,
-  });
-
-  if (result.error) {
-    throw new Error(`Failed to run ${command.join(" ")} in ${projectDir}: ${result.error.message}`);
-  }
-  if (result.status !== 0) {
-    throw new Error(`${command.join(" ")} failed in ${projectDir} with exit code ${result.status}`);
-  }
-}
-
-function installCommandFor(projectDir: string): string[] {
-  if (existsSync(join(projectDir, "bun.lock")) || existsSync(join(projectDir, "bun.lockb"))) return ["bun", "install"];
-  if (existsSync(join(projectDir, "pnpm-lock.yaml"))) return ["pnpm", "install"];
-  if (existsSync(join(projectDir, "package-lock.json"))) return ["npm", "install"];
-  return ["npm", "install"];
-}
-
-function runtimeBinPath(projectDir: string): string {
-  return join(projectDir, "node_modules", ".bin", process.platform === "win32" ? "rigkit-project-runtime.cmd" : "rigkit-project-runtime");
-}
-
-async function readDefaultBranch(target: GithubProjectTarget): Promise<string> {
-  const info = await githubJson<GithubRepoInfo>(`/repos/${target.owner}/${target.repo}`);
-  if (typeof info.default_branch !== "string" || !info.default_branch) {
-    throw new Error(`GitHub did not return a default branch for ${target.owner}/${target.repo}`);
-  }
-  return info.default_branch;
-}
-
-async function resolveCommitSha(target: GithubProjectTarget, ref: string): Promise<string> {
-  const commit = await githubJson<GithubCommitInfo>(`/repos/${target.owner}/${target.repo}/commits/${encodeURIComponent(ref)}`);
-  if (typeof commit.sha !== "string" || !/^[a-f0-9]{40}$/i.test(commit.sha)) {
-    throw new Error(`GitHub did not return a commit SHA for ${target.owner}/${target.repo}@${ref}`);
-  }
-  return commit.sha;
-}
-
-async function downloadGithubTarball(
-  target: GithubProjectTarget,
-  commitSha: string,
-  projectDir: string,
-): Promise<void> {
-  const tempDir = mkdtempSync(join(tmpdir(), "rigkit-github-"));
-  const archivePath = join(tempDir, "source.tar.gz");
-  const extractDir = join(tempDir, "extract");
-  mkdirSync(extractDir, { recursive: true });
-
-  try {
-    const response = await fetch(`https://codeload.github.com/${target.owner}/${target.repo}/tar.gz/${commitSha}`, {
-      headers: githubHeaders(),
-    });
-    if (!response.ok) {
-      throw new Error(`GitHub archive download failed for ${target.raw}: ${response.status} ${response.statusText}`);
-    }
-
-    writeFileSync(archivePath, Buffer.from(await response.arrayBuffer()));
-
-    const tar = spawnSync("tar", ["-xzf", archivePath, "-C", extractDir], {
-      stdio: "inherit",
-    });
-    if (tar.error) throw new Error(`Failed to extract GitHub archive: ${tar.error.message}`);
-    if (tar.status !== 0) throw new Error(`Failed to extract GitHub archive: tar exited ${tar.status}`);
-
-    const roots = readdirSync(extractDir, { withFileTypes: true }).filter((entry) => entry.isDirectory());
-    if (roots.length !== 1) {
-      throw new Error(`GitHub archive for ${target.raw} had ${roots.length} root directories`);
-    }
-
-    mkdirSync(dirname(projectDir), { recursive: true });
-    rmSync(projectDir, { recursive: true, force: true });
-    cpSync(join(extractDir, roots[0]!.name), projectDir, { recursive: true });
-  } finally {
-    rmSync(tempDir, { recursive: true, force: true });
-  }
-}
-
-async function githubJson<T>(path: string): Promise<T> {
-  const response = await fetch(`https://api.github.com${path}`, {
-    headers: githubHeaders(),
-  });
-  if (!response.ok) {
-    const text = await response.text().catch(() => "");
-    throw new Error(`GitHub request failed for ${path}: ${response.status} ${response.statusText}${text ? `: ${text.slice(0, 200)}` : ""}`);
-  }
-  return await response.json() as T;
-}
-
-function githubHeaders(): Record<string, string> {
-  const headers: Record<string, string> = {
-    accept: "application/vnd.github+json",
-    "user-agent": "rigkit-cli",
-  };
-  if (process.env.GITHUB_TOKEN) headers.authorization = `Bearer ${process.env.GITHUB_TOKEN}`;
-  return headers;
-}