readyup 0.0.0 → 0.13.0

package/dist/esm/formatJsonReport.js

@@ -0,0 +1,90 @@
+import { meetsThreshold } from "./runRdy.js";
+function formatJsonReport(entries, options) {
+  const reportOn = options?.reportOn ?? "recommend";
+  let totalPassed = 0;
+  let totalFailed = 0;
+  let totalSkipped = 0;
+  const checklists = entries.map(({ name, report }) => {
+    let passed = 0;
+    let failed = 0;
+    let skipped = 0;
+    const visibleResults = report.results.filter((r) => meetsThreshold(r.severity, reportOn));
+    for (const result of visibleResults) {
+      if (result.status === "passed") passed++;
+      else if (result.status === "failed") failed++;
+      else skipped++;
+    }
+    const { entries: checks } = buildCheckEntries(visibleResults, 0, 0);
+    totalPassed += passed;
+    totalFailed += failed;
+    totalSkipped += skipped;
+    return {
+      name,
+      allPassed: report.passed,
+      durationMs: report.durationMs,
+      passed,
+      failed,
+      skipped,
+      checks
+    };
+  });
+  const totalDurationMs = checklists.reduce((sum, c) => sum + c.durationMs, 0);
+  const output = {
+    allPassed: entries.every(({ report }) => report.passed),
+    passed: totalPassed,
+    failed: totalFailed,
+    skipped: totalSkipped,
+    durationMs: totalDurationMs,
+    checklists
+  };
+  return JSON.stringify(output);
+}
+function buildCheckEntries(results, startIndex, expectedDepth) {
+  const entries = [];
+  let index = startIndex;
+  while (index < results.length) {
+    const result = results[index];
+    if (result === void 0) break;
+    const depth = result.depth;
+    if (depth < expectedDepth) break;
+    index++;
+    const { entries: children, nextIndex } = buildCheckEntries(results, index, depth + 1);
+    index = nextIndex;
+    entries.push(buildCheckEntry(result, children));
+  }
+  return { entries, nextIndex: index };
+}
+function buildCheckEntry(result, children = []) {
+  const errorString = result.error !== null ? result.error.message : null;
+  if (result.status === "skipped") {
+    return {
+      name: result.name,
+      status: result.status,
+      ok: result.ok,
+      severity: result.severity,
+      skipReason: result.skipReason,
+      detail: result.detail,
+      fix: result.fix,
+      error: errorString,
+      progress: result.progress,
+      durationMs: result.durationMs,
+      checks: children
+    };
+  }
+  return {
+    name: result.name,
+    status: result.status,
+    ok: result.ok,
+    severity: result.severity,
+    skipReason: null,
+    detail: result.detail,
+    fix: result.fix,
+    error: errorString,
+    progress: result.progress,
+    durationMs: result.durationMs,
+    checks: children
+  };
+}
+export {
+  formatJsonReport
+};

package/dist/esm/index.d.ts

@@ -0,0 +1,4 @@
+export type { ChecklistSummary, CheckOutcome, CheckReturnValue, FailedResult, FixLocation, FractionProgress, JsonCheckEntry, JsonChecklistEntry, JsonReport, PassedResult, PercentProgress, Progress, RdyCheck, RdyChecklist, RdyConfig, RdyKit, RdyReport, RdyResult, RdyStagedChecklist, ResolvedRdyConfig, Severity, SkippedResult, SkipResult, } from './types.ts';
+export { isFlatChecklist, isPercentProgress } from './types.ts';
+export { defineChecklists, defineRdyChecklist, defineRdyConfig, defineRdyKit, defineRdyStagedChecklist, } from './authoring.ts';
+export { compareVersions, fileContains, fileDoesNotContain, fileExists, hasDevDependency, hasMinDevDependencyVersion, hasPackageJsonField, readFile, readPackageJson, } from './check-utils/index.ts';

package/dist/esm/index.js

@@ -0,0 +1,37 @@
+import { isFlatChecklist, isPercentProgress } from "./types.js";
+import {
+  defineChecklists,
+  defineRdyChecklist,
+  defineRdyConfig,
+  defineRdyKit,
+  defineRdyStagedChecklist
+} from "./authoring.js";
+import {
+  compareVersions,
+  fileContains,
+  fileDoesNotContain,
+  fileExists,
+  hasDevDependency,
+  hasMinDevDependencyVersion,
+  hasPackageJsonField,
+  readFile,
+  readPackageJson
+} from "./check-utils/index.js";
+export {
+  compareVersions,
+  defineChecklists,
+  defineRdyChecklist,
+  defineRdyConfig,
+  defineRdyKit,
+  defineRdyStagedChecklist,
+  fileContains,
+  fileDoesNotContain,
+  fileExists,
+  hasDevDependency,
+  hasMinDevDependencyVersion,
+  hasPackageJsonField,
+  isFlatChecklist,
+  isPercentProgress,
+  readFile,
+  readPackageJson
+};

package/dist/esm/init/initCommand.d.ts

@@ -0,0 +1,6 @@
+interface InitOptions {
+    dryRun: boolean;
+    force: boolean;
+}
+export declare function initCommand({ dryRun, force }: InitOptions): number;
+export {};

package/dist/esm/init/initCommand.js

@@ -0,0 +1,33 @@
+import { printError, printStep, reportWriteResult } from "../terminal.js";
+import { scaffoldConfig } from "./scaffold.js";
+function initCommand({ dryRun, force }) {
+  if (dryRun) {
+    console.info("[dry-run mode]");
+  }
+  printStep("Scaffolding config");
+  let result;
+  try {
+    result = scaffoldConfig({ dryRun, force });
+  } catch (error) {
+    printError(`Failed to scaffold config: ${error instanceof Error ? error.message : String(error)}`);
+    return 1;
+  }
+  reportWriteResult(result.configResult, dryRun);
+  reportWriteResult(result.kitResult, dryRun);
+  if (result.configResult.outcome === "failed" || result.kitResult.outcome === "failed") {
+    return 1;
+  }
+  if (!dryRun) {
+    printStep("Next steps");
+    console.info(`
+  1. Customize .config/rdy.config.ts with your compile settings.
+  2. Add checklists to .rdy/kits/.
+  3. Test by running: npx readyup run
+  4. Commit the generated files.
+`);
+  }
+  return 0;
+}
+export {
+  initCommand
+};

package/dist/esm/init/scaffold.d.ts

@@ -0,0 +1,11 @@
+import type { WriteResult } from '../writeFileWithCheck.ts';
+interface ScaffoldOptions {
+    dryRun: boolean;
+    force: boolean;
+}
+interface ScaffoldResult {
+    configResult: WriteResult;
+    kitResult: WriteResult;
+}
+export declare function scaffoldConfig({ dryRun, force }: ScaffoldOptions): ScaffoldResult;
+export {};

package/dist/esm/init/scaffold.js

@@ -0,0 +1,15 @@
+import { writeFileWithCheck } from "../writeFileWithCheck.js";
+import { rdyConfigTemplate, rdyKitTemplate } from "./templates.js";
+const CONFIG_PATH = ".config/rdy.config.ts";
+const KIT_PATH = ".rdy/kits/default.ts";
+function scaffoldConfig({ dryRun, force }) {
+  const configResult = writeFileWithCheck(CONFIG_PATH, rdyConfigTemplate, { dryRun, overwrite: force });
+  const kitResult = writeFileWithCheck(KIT_PATH, rdyKitTemplate, {
+    dryRun,
+    overwrite: force
+  });
+  return { configResult, kitResult };
+}
+export {
+  scaffoldConfig
+};

package/dist/esm/init/templates.d.ts

@@ -0,0 +1,2 @@
+export declare const rdyConfigTemplate = "import { defineRdyConfig } from 'readyup';\n\n/** Repo-level readyup settings. */\nexport default defineRdyConfig({\n  compile: {\n    srcDir: '.rdy/kits',\n    outDir: '.rdy/kits',\n  },\n});\n";
+export declare const rdyKitTemplate = "import { defineRdyKit } from 'readyup';\n\n/**\n * Default rdy kit.\n *\n * Each checklist contains checks that run before a deployment or other operation.\n * Checks run concurrently within a checklist. Use `fix` to provide remediation hints.\n */\nexport default defineRdyKit({\n  checklists: [\n    {\n      name: 'deploy',\n      checks: [\n        {\n          name: 'environment variables set',\n          check: () => Boolean(process.env['NODE_ENV']),\n          fix: 'Set NODE_ENV before deploying',\n        },\n      ],\n    },\n  ],\n});\n";

package/dist/esm/init/templates.js

@@ -0,0 +1,37 @@
+const rdyConfigTemplate = `import { defineRdyConfig } from 'readyup';
+
+/** Repo-level readyup settings. */
+export default defineRdyConfig({
+  compile: {
+    srcDir: '.rdy/kits',
+    outDir: '.rdy/kits',
+  },
+});
+`;
+const rdyKitTemplate = `import { defineRdyKit } from 'readyup';
+
+/**
+ * Default rdy kit.
+ *
+ * Each checklist contains checks that run before a deployment or other operation.
+ * Checks run concurrently within a checklist. Use \`fix\` to provide remediation hints.
+ */
+export default defineRdyKit({
+  checklists: [
+    {
+      name: 'deploy',
+      checks: [
+        {
+          name: 'environment variables set',
+          check: () => Boolean(process.env['NODE_ENV']),
+          fix: 'Set NODE_ENV before deploying',
+        },
+      ],
+    },
+  ],
+});
+`;
+export {
+  rdyConfigTemplate,
+  rdyKitTemplate
+};

package/dist/esm/isRecord.d.ts

@@ -0,0 +1 @@
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/dist/esm/isRecord.js

@@ -0,0 +1,6 @@
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export {
+  isRecord
+};

package/dist/esm/jitiImport.d.ts

@@ -0,0 +1 @@
+export declare function jitiImport(resolvedPath: string, moduleErrorDetail: string, exportNoun: string): Promise<Record<string, unknown>>;

package/dist/esm/jitiImport.js

@@ -0,0 +1,23 @@
+import { isRecord } from "./isRecord.js";
+async function jitiImport(resolvedPath, moduleErrorDetail, exportNoun) {
+  const { createJiti } = await import("jiti");
+  const jiti = createJiti(resolvedPath);
+  let imported;
+  try {
+    imported = await jiti.import(resolvedPath);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && (error.code === "MODULE_NOT_FOUND" || error.code === "ERR_MODULE_NOT_FOUND")) {
+      const moduleMatch = error.message.match(/Cannot find (?:module|package) '([^']+)'/);
+      const moduleName = moduleMatch?.[1] ?? "unknown module";
+      throw new Error(`Cannot resolve '${moduleName}'. ${moduleErrorDetail}`);
+    }
+    throw error;
+  }
+  if (!isRecord(imported)) {
+    throw new Error(`${exportNoun} must export an object, got ${Array.isArray(imported) ? "array" : typeof imported}`);
+  }
+  return imported;
+}
+export {
+  jitiImport
+};

package/dist/esm/loadConfig.d.ts

@@ -0,0 +1,2 @@
+import type { ResolvedRdyConfig } from './types.ts';
+export declare function loadConfig(overridePath?: string): Promise<ResolvedRdyConfig>;

package/dist/esm/loadConfig.js

@@ -0,0 +1,74 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+import { isRecord } from "./isRecord.js";
+import { jitiImport } from "./jitiImport.js";
+const DEFAULT_CONFIG = {
+  compile: {
+    srcDir: ".rdy/kits",
+    outDir: ".rdy/kits",
+    include: void 0
+  },
+  internal: {
+    dir: ".",
+    extension: ".ts"
+  }
+};
+const LOOKUP_PATHS = [".config/rdy.config.ts"];
+const RdyConfigSchema = z.looseObject({
+  compile: z.looseObject({
+    srcDir: z.string().optional(),
+    outDir: z.string().optional(),
+    include: z.string().optional()
+  }).optional(),
+  internal: z.looseObject({
+    dir: z.string().optional(),
+    extension: z.string().optional()
+  }).optional()
+});
+function assertIsRdyConfig(raw) {
+  RdyConfigSchema.parse(raw);
+}
+async function loadConfig(overridePath) {
+  let resolvedPath;
+  if (overridePath !== void 0) {
+    resolvedPath = path.resolve(process.cwd(), overridePath);
+    if (!existsSync(resolvedPath)) {
+      throw new Error(`Config not found: ${resolvedPath}`);
+    }
+  } else {
+    for (const lookupPath of LOOKUP_PATHS) {
+      const candidate = path.resolve(process.cwd(), lookupPath);
+      if (existsSync(candidate)) {
+        resolvedPath = candidate;
+        break;
+      }
+    }
+  }
+  if (resolvedPath === void 0) {
+    return { ...DEFAULT_CONFIG };
+  }
+  const imported = await jitiImport(
+    resolvedPath,
+    "External packages imported by the config file must be installed in the project.",
+    "Config file"
+  );
+  const raw = imported.default !== void 0 && isRecord(imported.default) ? imported.default : imported;
+  assertIsRdyConfig(raw);
+  const compile = isRecord(raw.compile) ? raw.compile : void 0;
+  const internal = isRecord(raw.internal) ? raw.internal : void 0;
+  return {
+    compile: {
+      srcDir: typeof compile?.srcDir === "string" ? compile.srcDir : DEFAULT_CONFIG.compile.srcDir,
+      outDir: typeof compile?.outDir === "string" ? compile.outDir : DEFAULT_CONFIG.compile.outDir,
+      include: typeof compile?.include === "string" ? compile.include : void 0
+    },
+    internal: {
+      dir: typeof internal?.dir === "string" ? internal.dir : DEFAULT_CONFIG.internal.dir,
+      extension: typeof internal?.extension === "string" ? internal.extension : DEFAULT_CONFIG.internal.extension
+    }
+  };
+}
+export {
+  loadConfig
+};

package/dist/esm/loadRemoteCollection.d.ts

@@ -0,0 +1,6 @@
+import type { PreflightCollection } from './types.ts';
+export interface LoadRemoteCollectionOptions {
+    url: string;
+    token?: string;
+}
+export declare function loadRemoteCollection({ url, token }: LoadRemoteCollectionOptions): Promise<PreflightCollection>;

package/dist/esm/loadRemoteCollection.js

@@ -0,0 +1,40 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { assertIsPreflightCollection } from "./assertIsPreflightCollection.js";
+import { isRecord } from "./isRecord.js";
+import { resolveCollectionExports } from "./resolveCollectionExports.js";
+import { validateCollection } from "./validateCollection.js";
+async function loadRemoteCollection({ url, token }) {
+  const headers = {};
+  if (token !== void 0) {
+    headers.Authorization = `token ${token}`;
+  }
+  const response = await fetch(url, { headers });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch remote collection from ${url}: ${response.status} ${response.statusText}`);
+  }
+  const body = await response.text();
+  const trimmedBody = body.trimStart().toLowerCase();
+  if (trimmedBody.startsWith("<html") || trimmedBody.startsWith("<!doctype")) {
+    throw new Error(`Remote collection URL returned an HTML page instead of JavaScript: ${url}`);
+  }
+  const tempDir = mkdtempSync(join(tmpdir(), "preflight-"));
+  const tempFile = join(tempDir, "collection.js");
+  try {
+    writeFileSync(tempFile, body, "utf8");
+    const fileUrl = `${pathToFileURL(tempFile).href}?t=${Date.now()}`;
+    const imported = await import(fileUrl);
+    const moduleRecord = isRecord(imported) ? imported : {};
+    const resolved = resolveCollectionExports(moduleRecord);
+    assertIsPreflightCollection(resolved);
+    validateCollection(resolved);
+    return resolved;
+  } finally {
+    rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+export {
+  loadRemoteCollection
+};

package/dist/esm/loadRemoteKit.d.ts

@@ -0,0 +1,6 @@
+import type { RdyKit } from './types.ts';
+export interface LoadRemoteKitOptions {
+    url: string;
+    token?: string;
+}
+export declare function loadRemoteKit({ url, token }: LoadRemoteKitOptions): Promise<RdyKit>;

package/dist/esm/loadRemoteKit.js

@@ -0,0 +1,40 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { assertIsRdyKit } from "./assertIsRdyKit.js";
+import { isRecord } from "./isRecord.js";
+import { resolveKitExports } from "./resolveKitExports.js";
+import { validateKit } from "./validateKit.js";
+async function loadRemoteKit({ url, token }) {
+  const headers = {};
+  if (token !== void 0) {
+    headers.Authorization = `token ${token}`;
+  }
+  const response = await fetch(url, { headers });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch remote kit from ${url}: ${response.status} ${response.statusText}`);
+  }
+  const body = await response.text();
+  const trimmedBody = body.trimStart().toLowerCase();
+  if (trimmedBody.startsWith("<html") || trimmedBody.startsWith("<!doctype")) {
+    throw new Error(`Remote kit URL returned an HTML page instead of JavaScript: ${url}`);
+  }
+  const tempDir = mkdtempSync(join(tmpdir(), "rdy-"));
+  const tempFile = join(tempDir, "kit.js");
+  try {
+    writeFileSync(tempFile, body, "utf8");
+    const fileUrl = `${pathToFileURL(tempFile).href}?t=${Date.now()}`;
+    const imported = await import(fileUrl);
+    const moduleRecord = isRecord(imported) ? imported : {};
+    const resolved = resolveKitExports(moduleRecord);
+    assertIsRdyKit(resolved);
+    validateKit(resolved);
+    return resolved;
+  } finally {
+    rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+export {
+  loadRemoteKit
+};

package/dist/esm/parseArgs.d.ts

@@ -0,0 +1,15 @@
+export interface FlagDefinition {
+    long: string;
+    type: 'boolean' | 'string';
+    short?: string;
+}
+export type FlagSchema = Record<string, FlagDefinition>;
+export type ParsedFlags<S extends FlagSchema> = {
+    [K in keyof S]: S[K]['type'] extends 'boolean' ? boolean : string | undefined;
+};
+export interface ParsedArgs<S extends FlagSchema> {
+    flags: ParsedFlags<S>;
+    positionals: string[];
+}
+export declare function parseArgs<S extends FlagSchema>(argv: string[], schema: S): ParsedArgs<S>;
+export declare function translateParseError(error: unknown): string;

package/dist/esm/parseArgs.js

@@ -0,0 +1,93 @@
+function handleEqualsForm(arg, eqIndex, longToKey, definitions) {
+  const longFlag = arg.slice(0, eqIndex);
+  const key = longToKey.get(longFlag);
+  if (key === void 0) {
+    throw new Error(`unknown flag '${longFlag}'`);
+  }
+  const def = definitions.get(key);
+  if (def?.type === "boolean") {
+    throw new Error(`flag '${longFlag}' does not accept a value`);
+  }
+  const value = arg.slice(eqIndex + 1);
+  if (value === "") {
+    throw new Error(`${longFlag} requires a value`);
+  }
+  return { key, value };
+}
+function handleBareFlag(arg, index, argv, longToKey, shortToKey, definitions) {
+  const key = longToKey.get(arg) ?? shortToKey.get(arg);
+  if (key === void 0) {
+    throw new Error(`unknown flag '${arg}'`);
+  }
+  const def = definitions.get(key);
+  if (def?.type === "boolean") {
+    return { key, value: true, advance: 0 };
+  }
+  const next = argv[index + 1];
+  if (next === void 0 || next.startsWith("-") && next !== "-") {
+    throw new Error(`${def?.long} requires a value`);
+  }
+  return { key, value: next, advance: 1 };
+}
+function buildLookupTables(schema) {
+  const longToKey = /* @__PURE__ */ new Map();
+  const shortToKey = /* @__PURE__ */ new Map();
+  const definitions = /* @__PURE__ */ new Map();
+  for (const [key, def] of Object.entries(schema)) {
+    longToKey.set(def.long, key);
+    definitions.set(key, def);
+    if (def.short !== void 0) {
+      shortToKey.set(def.short, key);
+    }
+  }
+  return { longToKey, shortToKey, definitions };
+}
+function parseArgsInternal(argv, schema) {
+  const { longToKey, shortToKey, definitions } = buildLookupTables(schema);
+  const flags = {};
+  for (const [key, def] of Object.entries(schema)) {
+    flags[key] = def.type === "boolean" ? false : void 0;
+  }
+  const positionals = [];
+  let pastDelimiter = false;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i] ?? "";
+    if (pastDelimiter) {
+      positionals.push(arg);
+      continue;
+    }
+    if (arg === "--") {
+      pastDelimiter = true;
+      continue;
+    }
+    const eqIndex = arg.indexOf("=");
+    if (eqIndex !== -1 && arg.startsWith("--")) {
+      const { key, value } = handleEqualsForm(arg, eqIndex, longToKey, definitions);
+      flags[key] = value;
+      continue;
+    }
+    if (arg.startsWith("-") && arg !== "-") {
+      const { key, value, advance } = handleBareFlag(arg, i, argv, longToKey, shortToKey, definitions);
+      flags[key] = value;
+      i += advance;
+      continue;
+    }
+    positionals.push(arg);
+  }
+  return { flags, positionals };
+}
+function parseArgs(argv, schema) {
+  return parseArgsInternal(argv, schema);
+}
+function translateParseError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const flagMatch = message.match(/^unknown flag '(.+)'$/);
+  if (flagMatch?.[1] !== void 0) {
+    return `Unknown option: ${flagMatch[1]}`;
+  }
+  return message;
+}
+export {
+  parseArgs,
+  translateParseError
+};

package/dist/esm/reportPreflight.d.ts

@@ -0,0 +1,7 @@
+import type { FixLocation, PreflightReport, Severity } from './types.ts';
+export interface ReportPreflightOptions {
+    fixLocation?: FixLocation;
+    reportOn?: Severity;
+}
+export declare function formatSummaryCounts(passed: number, failed: number, skipped: number): string;
+export declare function reportPreflight(report: PreflightReport, options?: ReportPreflightOptions): string;