@rrlab/cli 0.0.1-git-87d22db.0

package/src/services/json-edit.ts

@@ -0,0 +1,147 @@
+import * as cjson from "comment-json";
+import type { JsonEdit } from "#src/plugin/types.ts";
+
+/**
+ * Applies a sequence of `JsonEdit` ops to a JSON / JSONC source string.
+ * Uses `comment-json` so user comments and `extends`-like top-level shape
+ * survive a parse → mutate → stringify round-trip.
+ *
+ * Paths follow JSON Pointer (RFC 6901): `"/extends"`,
+ * `"/compilerOptions/strict"`. Indices are valid path segments for arrays
+ * (`"/extends/0"`).
+ */
+export function applyJsonEdits(source: string, edits: JsonEdit[]): string {
+  // biome-ignore lint/suspicious/noExplicitAny: cjson exposes the parsed tree as a structurally-typed JS object/array
+  let root: any = source.trim() === "" ? {} : cjson.parse(source);
+  if (root == null || typeof root !== "object") {
+    throw new Error(`applyJsonEdits: expected a JSON object/array at the top level, got ${typeof root}.`);
+  }
+  for (const edit of edits) {
+    root = applyOne(root, edit);
+  }
+  return `${cjson.stringify(root, null, 2)}\n`;
+}
+
+// biome-ignore lint/suspicious/noExplicitAny: see above
+function applyOne(root: any, edit: JsonEdit): any {
+  const segments = parsePointer(edit.path);
+  if (edit.op === "set") {
+    const existing = resolve(root, segments);
+    if (edit.mode === "if-missing" && existing !== undefined) return root;
+    return setAt(root, segments, edit.value);
+  }
+  if (edit.op === "unset") {
+    return unsetAt(root, segments);
+  }
+  if (edit.op === "include") {
+    return includeInArray(root, segments, edit.value, edit.position ?? "end");
+  }
+  if (edit.op === "exclude") {
+    return excludeFromArray(root, segments, edit.value);
+  }
+  return root;
+}
+
+/** Parses a JSON Pointer (RFC 6901) into its segments, decoding `~1` and `~0`. */
+function parsePointer(pointer: string): string[] {
+  if (pointer === "" || pointer === "/") return [];
+  if (!pointer.startsWith("/")) {
+    throw new Error(`Invalid JSON Pointer "${pointer}": must start with "/" or be empty.`);
+  }
+  return pointer
+    .slice(1)
+    .split("/")
+    .map((s) => s.replace(/~1/g, "/").replace(/~0/g, "~"));
+}
+
+// biome-ignore lint/suspicious/noExplicitAny: see above
+function resolve(root: any, segments: string[]): unknown {
+  // biome-ignore lint/suspicious/noExplicitAny: see above
+  let cur: any = root;
+  for (const seg of segments) {
+    if (cur == null) return undefined;
+    cur = cur[arrayIndexIfNumeric(cur, seg)];
+  }
+  return cur;
+}
+
+// biome-ignore lint/suspicious/noExplicitAny: see above
+function setAt(root: any, segments: string[], value: unknown): any {
+  if (segments.length === 0) {
+    // Replacing the whole root — uncommon for our use cases but harmless.
+    return value;
+  }
+  // biome-ignore lint/suspicious/noExplicitAny: see above
+  let cur: any = root;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const seg = segments[i] ?? "";
+    const key = arrayIndexIfNumeric(cur, seg);
+    if (cur[key] == null || typeof cur[key] !== "object") {
+      cur[key] = isNumericIndex(segments[i + 1] ?? "") ? [] : {};
+    }
+    cur = cur[key];
+  }
+  const last = segments[segments.length - 1] ?? "";
+  cur[arrayIndexIfNumeric(cur, last)] = value;
+  return root;
+}
+
+// biome-ignore lint/suspicious/noExplicitAny: see above
+function unsetAt(root: any, segments: string[]): any {
+  if (segments.length === 0) return root;
+  // biome-ignore lint/suspicious/noExplicitAny: see above
+  let cur: any = root;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const seg = segments[i] ?? "";
+    if (cur == null) return root;
+    cur = cur[arrayIndexIfNumeric(cur, seg)];
+  }
+  if (cur == null) return root;
+  const last = segments[segments.length - 1] ?? "";
+  if (Array.isArray(cur) && isNumericIndex(last)) {
+    cur.splice(Number(last), 1);
+  } else {
+    delete cur[last];
+  }
+  return root;
+}
+
+// biome-ignore lint/suspicious/noExplicitAny: see above
+function includeInArray(root: any, segments: string[], value: unknown, position: "start" | "end"): any {
+  const existing = resolve(root, segments);
+  if (existing === undefined) {
+    // Create the array with the single value.
+    return setAt(root, segments, [value]);
+  }
+  if (!Array.isArray(existing)) {
+    throw new Error(`include: expected an array at "${segments.join("/")}", got ${typeof existing}.`);
+  }
+  if (existing.some((item) => deepEqual(item, value))) return root;
+  if (position === "start") existing.unshift(value);
+  else existing.push(value);
+  return root;
+}
+
+// biome-ignore lint/suspicious/noExplicitAny: see above
+function excludeFromArray(root: any, segments: string[], value: unknown): any {
+  const existing = resolve(root, segments);
+  if (!Array.isArray(existing)) return root;
+  const idx = existing.findIndex((item) => deepEqual(item, value));
+  if (idx >= 0) existing.splice(idx, 1);
+  return root;
+}
+
+// biome-ignore lint/suspicious/noExplicitAny: see above
+function arrayIndexIfNumeric(target: any, seg: string): string | number {
+  return Array.isArray(target) && isNumericIndex(seg) ? Number(seg) : seg;
+}
+
+function isNumericIndex(seg: string): boolean {
+  return seg !== "" && /^\d+$/.test(seg);
+}
+
+function deepEqual(a: unknown, b: unknown): boolean {
+  if (a === b) return true;
+  if (typeof a !== "object" || typeof b !== "object" || a == null || b == null) return false;
+  return JSON.stringify(a) === JSON.stringify(b);
+}

package/src/services/logger.ts

@@ -0,0 +1,5 @@
+import { createLoggy } from "@vlandoss/loggy";
+
+export const logger = createLoggy({
+  namespace: "run-run",
+});

package/src/services/plugins-registry.ts

@@ -0,0 +1,21 @@
+/**
+ * Map from short aliases the user types (`rr plugins add ts`) to the
+ * full npm package name and the canonical local binding the plugin file
+ * is imported as inside `run-run.config.{ts,mts}`.
+ *
+ * Third-party plugins use their full package name; the binding is derived
+ * by stripping a `@scope/plugin-` (or `@scope/run-run-plugin-`) prefix.
+ */
+export const OFFICIAL_PLUGINS = {
+  ts: { pkg: "@rrlab/plugin-ts", exportName: "ts" },
+  eslint: { pkg: "@rrlab/plugin-eslint", exportName: "eslint" },
+  biome: { pkg: "@rrlab/plugin-biome", exportName: "biome" },
+  oxc: { pkg: "@rrlab/plugin-oxc", exportName: "oxc" },
+  tsdown: { pkg: "@rrlab/plugin-tsdown", exportName: "tsdown" },
+} as const;
+
+export type OfficialAlias = keyof typeof OFFICIAL_PLUGINS;
+
+export function officialAliases(): readonly OfficialAlias[] {
+  return Object.keys(OFFICIAL_PLUGINS) as OfficialAlias[];
+}

package/src/services/prompts.ts

@@ -0,0 +1,26 @@
+import * as clack from "@clack/prompts";
+import type { ClackPrompts } from "#src/plugin/types.ts";
+
+/**
+ * Adapter that exposes the subset of `@clack/prompts` matching the
+ * `ClackPrompts` contract from `@rrlab/cli/plugin`. The contract intentionally
+ * stays narrow (`select`, `confirm`, `isCancel`) so plugin install hooks can
+ * be tested by injecting a stub without pulling in the real terminal IO.
+ *
+ * The casts compensate for two small type-shape mismatches:
+ * - Our contract requires `label: string`; clack types `label?: string`.
+ * - `clack.select` returns `Promise<unknown>` (a non-cancelled value or
+ *   `symbol`); our contract narrows that to `Promise<T | symbol>`.
+ *
+ * Both widenings are safe: every required field is present, and clack's
+ * runtime returns either the picked option's `value` (typed `T`) or
+ * `clack.isCancel(...)`-detectable `symbol`.
+ */
+export function createClackPrompts(): ClackPrompts {
+  return {
+    select: <T extends string>(opts: Parameters<ClackPrompts["select"]>[0]) =>
+      clack.select(opts as Parameters<typeof clack.select>[0]) as Promise<T | symbol>,
+    confirm: (opts) => clack.confirm(opts),
+    isCancel: (value): value is symbol => clack.isCancel(value),
+  };
+}

package/src/services/workspace-target.ts

@@ -0,0 +1,27 @@
+import type { Pkg } from "@vlandoss/clibuddy";
+import type { PackageManager } from "nypm";
+
+export type WorkspaceChoice = { kind: "current" } | { kind: "root"; flag: true | undefined };
+export type WorkspaceTarget = true | undefined;
+
+export function resolveWorkspaceChoice(appPkg: Pkg, pm: PackageManager | undefined): WorkspaceChoice {
+  if (!appPkg.isMonorepo()) return { kind: "current" };
+  return { kind: "root", flag: pmNeedsRootFlag(pm) ? true : undefined };
+}
+
+export function toNypmWorkspace(choice: WorkspaceChoice): WorkspaceTarget {
+  return choice.kind === "current" ? undefined : choice.flag;
+}
+
+export function describeWorkspaceChoice(choice: WorkspaceChoice): string {
+  return choice.kind === "current" ? "the current package" : "the workspace root";
+}
+
+// pnpm and yarn-classic refuse to install at the workspace root without an
+// explicit flag; npm and yarn-berry don't need it.
+function pmNeedsRootFlag(pm: PackageManager | undefined): boolean {
+  if (!pm) return false;
+  if (pm.name === "pnpm") return true;
+  if (pm.name === "yarn" && (!pm.majorVersion || pm.majorVersion === "1")) return true;
+  return false;
+}

package/src/types/config.ts

@@ -0,0 +1,13 @@
+import type { Plugin } from "#src/plugin/types.ts";
+
+export type UserConfig = {
+  plugins?: Plugin[];
+};
+
+export type ExportedConfig = {
+  config: UserConfig;
+  meta: {
+    isDefault: boolean;
+    filepath?: string;
+  };
+};

package/src/types/tool.ts

@@ -0,0 +1,57 @@
+export type FormatOptions = {
+  fix?: boolean;
+};
+
+export type LintOptions = {
+  fix?: boolean;
+};
+
+export type StaticCheckerOptions = {
+  fix?: boolean;
+  fixStaged?: boolean;
+};
+
+export type DoctorOutput = {
+  stdout: string;
+  stderr: string;
+  exitCode: number | undefined;
+};
+
+export type DoctorResult = {
+  ok: boolean;
+  output: DoctorOutput;
+};
+
+export type Doctor = {
+  ui: string;
+  doctor(): Promise<DoctorResult>;
+};
+
+export type Formatter = {
+  bin: string;
+  ui: string;
+  format(options: FormatOptions): Promise<void>;
+};
+
+export type Linter = {
+  bin: string;
+  ui: string;
+  lint(options: LintOptions): Promise<void>;
+};
+
+export type StaticChecker = {
+  bin: string;
+  ui: string;
+  check(options: StaticCheckerOptions): Promise<void>;
+};
+
+export type TypeCheckOptions = {
+  /** Where to run the type checker. Defaults to the kernel's `cwd`. */
+  cwd?: string;
+};
+
+export type TypeChecker = {
+  bin: string;
+  ui: string;
+  check(options?: TypeCheckOptions): Promise<void>;
+};

package/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": ["@rrlab/ts-config/no-dom/lib"]
+}