readyup 0.0.0 → 0.13.0

package/dist/esm/terminal.js

@@ -0,0 +1,55 @@
+function printStep(message) {
+  console.info(`
+> ${message}`);
+}
+function printSuccess(message) {
+  console.info(`  \u2705 ${message}`);
+}
+function printSkip(message) {
+  console.info(`  \u26A0\uFE0F ${message}`);
+}
+function printError(message) {
+  console.error(`  \u274C ${message}`);
+}
+function reportWriteResult(result, dryRun) {
+  switch (result.outcome) {
+    case "created":
+      if (dryRun) {
+        printSuccess(`[dry-run] Would create ${result.filePath}`);
+      } else {
+        printSuccess(`Created ${result.filePath}`);
+      }
+      break;
+    case "overwritten":
+      if (dryRun) {
+        printSuccess(`[dry-run] Would overwrite ${result.filePath}`);
+      } else {
+        printSuccess(`Overwrote ${result.filePath}`);
+      }
+      break;
+    case "up-to-date":
+      printSuccess(`${result.filePath} (up to date)`);
+      break;
+    case "skipped":
+      if (result.error) {
+        printSkip(`${result.filePath} (could not read for comparison: ${result.error})`);
+      } else {
+        printSkip(`${result.filePath} (already exists)`);
+      }
+      break;
+    case "failed":
+      if (result.error) {
+        printError(`Failed to write ${result.filePath}: ${result.error}`);
+      } else {
+        printError(`Failed to write ${result.filePath}`);
+      }
+      break;
+  }
+}
+export {
+  printError,
+  printSkip,
+  printStep,
+  printSuccess,
+  reportWriteResult
+};

package/dist/esm/types.d.ts

@@ -0,0 +1,139 @@
+export type Severity = 'error' | 'warn' | 'recommend';
+export type SkipResult = false | string;
+export type FixLocation = 'inline' | 'end';
+export interface FractionProgress {
+    type: 'fraction';
+    passedCount: number;
+    count: number;
+}
+export interface PercentProgress {
+    type: 'percent';
+    percent: number;
+}
+export type Progress = FractionProgress | PercentProgress;
+export declare function isPercentProgress(progress: Progress): progress is PercentProgress;
+export interface CheckOutcome {
+    ok: boolean;
+    detail?: string;
+    progress?: Progress;
+}
+export type CheckReturnValue = boolean | CheckOutcome;
+export interface RdyCheck {
+    name: string;
+    check: () => CheckReturnValue | Promise<CheckReturnValue>;
+    severity?: Severity;
+    skip?: () => SkipResult | Promise<SkipResult>;
+    fix?: string;
+    checks?: RdyCheck[];
+}
+interface RdyResultBase {
+    name: string;
+    severity: Severity;
+    detail: string | null;
+    fix: string | null;
+    error: Error | null;
+    progress: Progress | null;
+    durationMs: number;
+    depth: number;
+}
+export interface PassedResult extends RdyResultBase {
+    status: 'passed';
+    ok: true;
+}
+export interface FailedResult extends RdyResultBase {
+    status: 'failed';
+    ok: false;
+}
+export interface SkippedResult extends RdyResultBase {
+    status: 'skipped';
+    ok: null;
+    skipReason: 'n/a' | 'precondition';
+}
+export type RdyResult = PassedResult | FailedResult | SkippedResult;
+export interface RdyReport {
+    results: RdyResult[];
+    passed: boolean;
+    durationMs: number;
+}
+export interface ChecklistSummary {
+    name: string;
+    passed: number;
+    failed: number;
+    skipped: number;
+    allPassed: boolean;
+    durationMs: number;
+}
+export interface RdyChecklist {
+    name: string;
+    preconditions?: RdyCheck[];
+    checks: RdyCheck[];
+    fixLocation?: FixLocation;
+}
+export interface RdyStagedChecklist {
+    name: string;
+    preconditions?: RdyCheck[];
+    groups: RdyCheck[][];
+    fixLocation?: FixLocation;
+}
+export declare function isFlatChecklist(checklist: RdyChecklist | RdyStagedChecklist): checklist is RdyChecklist;
+export interface RdyKit {
+    checklists: Array<RdyChecklist | RdyStagedChecklist>;
+    suites?: Record<string, string[]>;
+    defaultSeverity?: Severity;
+    failOn?: Severity;
+    reportOn?: Severity;
+    fixLocation?: FixLocation;
+}
+export interface RdyConfig {
+    compile?: {
+        srcDir?: string;
+        outDir?: string;
+        include?: string;
+    };
+    internal?: {
+        dir?: string;
+        extension?: string;
+    };
+}
+export interface ResolvedRdyConfig {
+    compile: {
+        srcDir: string;
+        outDir: string;
+        include: string | undefined;
+    };
+    internal: {
+        dir: string;
+        extension: string;
+    };
+}
+export interface JsonCheckEntry {
+    name: string;
+    status: 'passed' | 'failed' | 'skipped';
+    ok: true | false | null;
+    severity: Severity;
+    skipReason: 'n/a' | 'precondition' | null;
+    detail: string | null;
+    fix: string | null;
+    error: string | null;
+    progress: Progress | null;
+    durationMs: number;
+    checks: JsonCheckEntry[];
+}
+export interface JsonChecklistEntry {
+    name: string;
+    passed: number;
+    failed: number;
+    skipped: number;
+    allPassed: boolean;
+    durationMs: number;
+    checks: JsonCheckEntry[];
+}
+export interface JsonReport {
+    allPassed: boolean;
+    passed: number;
+    failed: number;
+    skipped: number;
+    durationMs: number;
+    checklists: JsonChecklistEntry[];
+}
+export {};

package/dist/esm/types.js

@@ -0,0 +1,10 @@
+function isPercentProgress(progress) {
+  return progress.type === "percent";
+}
+function isFlatChecklist(checklist) {
+  return "checks" in checklist;
+}
+export {
+  isFlatChecklist,
+  isPercentProgress
+};

package/dist/esm/validateCollection.d.ts

@@ -0,0 +1,2 @@
+import type { PreflightCollection } from './types.ts';
+export declare function validateCollection(collection: PreflightCollection): void;

package/dist/esm/validateCollection.js

@@ -0,0 +1,27 @@
+function validateCollection(collection) {
+  const { suites } = collection;
+  if (suites === void 0) return;
+  const checklistNames = new Set(collection.checklists.map((c) => c.name));
+  const collisions = Object.keys(suites).filter((name) => checklistNames.has(name));
+  if (collisions.length > 0) {
+    throw new Error(
+      `Suite name(s) collide with checklist name(s): ${collisions.join(", ")}. Suite names and checklist names must be unique across both pools.`
+    );
+  }
+  const missingBySource = [];
+  for (const [suiteName, entries] of Object.entries(suites)) {
+    for (const entry of entries) {
+      if (!checklistNames.has(entry)) {
+        missingBySource.push(`suite "${suiteName}" references unknown checklist "${entry}"`);
+      }
+    }
+  }
+  if (missingBySource.length > 0) {
+    throw new Error(
+      `Invalid suite references: ${missingBySource.join("; ")}. Available checklists: ${[...checklistNames].join(", ")}`
+    );
+  }
+}
+export {
+  validateCollection
+};

package/dist/esm/validateKit.d.ts

@@ -0,0 +1,2 @@
+import type { RdyKit } from './types.ts';
+export declare function validateKit(kit: RdyKit): void;

package/dist/esm/validateKit.js

@@ -0,0 +1,27 @@
+function validateKit(kit) {
+  const { suites } = kit;
+  if (suites === void 0) return;
+  const checklistNames = new Set(kit.checklists.map((c) => c.name));
+  const collisions = Object.keys(suites).filter((name) => checklistNames.has(name));
+  if (collisions.length > 0) {
+    throw new Error(
+      `Suite name(s) collide with checklist name(s): ${collisions.join(", ")}. Suite names and checklist names must be unique across both pools.`
+    );
+  }
+  const missingBySource = [];
+  for (const [suiteName, entries] of Object.entries(suites)) {
+    for (const entry of entries) {
+      if (!checklistNames.has(entry)) {
+        missingBySource.push(`suite "${suiteName}" references unknown checklist "${entry}"`);
+      }
+    }
+  }
+  if (missingBySource.length > 0) {
+    throw new Error(
+      `Invalid suite references: ${missingBySource.join("; ")}. Available checklists: ${[...checklistNames].join(", ")}`
+    );
+  }
+}
+export {
+  validateKit
+};

package/dist/esm/version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION = "0.13.0";

package/dist/esm/version.js

@@ -0,0 +1,4 @@
+const VERSION = "0.13.0";
+export {
+  VERSION
+};

package/dist/esm/writeFileWithCheck.d.ts

@@ -0,0 +1,10 @@
+export type WriteOutcome = 'created' | 'overwritten' | 'up-to-date' | 'skipped' | 'failed';
+export interface WriteResult {
+    filePath: string;
+    outcome: WriteOutcome;
+    error?: string;
+}
+export declare function writeFileWithCheck(filePath: string, content: string, options: {
+    dryRun: boolean;
+    overwrite: boolean;
+}): WriteResult;

package/dist/esm/writeFileWithCheck.js

@@ -0,0 +1,41 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+function normalizeTrailingWhitespace(content) {
+  return content.split("\n").map((line) => line.trimEnd()).join("\n").trimEnd();
+}
+function writeFileWithCheck(filePath, content, options) {
+  const { dryRun, overwrite } = options;
+  const fileExists = existsSync(filePath);
+  if (fileExists && !overwrite) {
+    try {
+      const existing = readFileSync(filePath, "utf8");
+      if (normalizeTrailingWhitespace(existing) === normalizeTrailingWhitespace(content)) {
+        return { filePath, outcome: "up-to-date" };
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return { filePath, outcome: "skipped", error: message };
+    }
+    return { filePath, outcome: "skipped" };
+  }
+  const outcome = fileExists ? "overwritten" : "created";
+  if (dryRun) {
+    return { filePath, outcome };
+  }
+  try {
+    mkdirSync(dirname(filePath), { recursive: true });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { filePath, outcome: "failed", error: message };
+  }
+  try {
+    writeFileSync(filePath, content, "utf8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { filePath, outcome: "failed", error: message };
+  }
+  return { filePath, outcome };
+}
+export {
+  writeFileWithCheck
+};

package/package.json

@@ -1,12 +1,58 @@
 {
   "name": "readyup",
-  "version": "0.0.0",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "description": ""
-}
+  "version": "0.13.0",
+  "private": false,
+  "description": "Run pre-deployment checks to verify environment and configuration",
+  "keywords": [
+    "checks",
+    "deploy",
+    "readyup",
+    "verification"
+  ],
+  "homepage": "https://github.com/williamthorsen/workshop/tree/main/packages/readyup#readme",
+  "bugs": {
+    "url": "https://github.com/williamthorsen/workshop/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/williamthorsen/workshop.git",
+    "directory": "packages/readyup"
+  },
+  "license": "MIT",
+  "author": "William Thorsen <william@thorsen.dev> (https://github.com/williamthorsen)",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "types": "./dist/esm/index.d.ts"
+    }
+  },
+  "bin": {
+    "rdy": "bin/rdy.js",
+    "readyup": "bin/rdy.js"
+  },
+  "files": [
+    "bin",
+    "dist"
+  ],
+  "dependencies": {
+    "jiti": "2.6.1",
+    "picomatch": "4.0.4",
+    "zod": "4.3.6"
+  },
+  "devDependencies": {
+    "@types/picomatch": "4.0.3"
+  },
+  "peerDependencies": {
+    "esbuild": ">=0.17.0"
+  },
+  "peerDependenciesMeta": {
+    "esbuild": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=18.17.0"
+  },
+  "scripts": {}
+}