@maroonedsoftware/johnny5 0.1.0

package/dist/integrations/versions/index.js

@@ -0,0 +1,56 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/integrations/versions/index.ts
+var nodeVersion = /* @__PURE__ */ __name((options) => ({
+  name: `node \u2265 ${options.min}`,
+  run: /* @__PURE__ */ __name(async () => {
+    const raw = process.versions.node;
+    const major = Number(raw.split(".")[0]);
+    if (!Number.isFinite(major) || major < options.min) {
+      return {
+        ok: false,
+        message: `running on Node ${raw}; need \u2265 ${options.min}`,
+        fixHint: `Install Node ${options.min}+ (e.g. \`fnm install ${options.min}\` or \`nvm install ${options.min}\`).`
+      };
+    }
+    return {
+      ok: true,
+      message: `Node ${raw}`
+    };
+  }, "run")
+}), "nodeVersion");
+var pnpmVersion = /* @__PURE__ */ __name((options = {}) => ({
+  name: "pnpm version",
+  run: /* @__PURE__ */ __name(async (ctx) => {
+    let installed;
+    try {
+      const result = await ctx.shell.run("pnpm", [
+        "--version"
+      ]);
+      installed = String(result.stdout).trim();
+    } catch {
+      return {
+        ok: false,
+        message: "pnpm not found on PATH",
+        fixHint: "Install pnpm via corepack: `corepack enable && corepack prepare pnpm@latest --activate`."
+      };
+    }
+    if (options.expected && installed !== options.expected) {
+      return {
+        ok: false,
+        message: `pnpm ${installed}; expected ${options.expected}`,
+        fixHint: `Run \`corepack prepare pnpm@${options.expected} --activate\` to match.`
+      };
+    }
+    return {
+      ok: true,
+      message: `pnpm ${installed}`
+    };
+  }, "run")
+}), "pnpmVersion");
+export {
+  nodeVersion,
+  pnpmVersion
+};
+//# sourceMappingURL=index.js.map

package/dist/integrations/versions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/integrations/versions/index.ts"],"sourcesContent":["import type { Check } from '../../types.js';\n\n/** Options for `nodeVersion`. */\nexport interface NodeVersionOptions {\n    /** Minimum Node major version required. The check fails when `process.versions.node` is below this. */\n    min: number;\n}\n\n/** Check that `process.versions.node` is at least `options.min` (compared by major version). */\nexport const nodeVersion = (options: NodeVersionOptions): Check => ({\n    name: `node ≥ ${options.min}`,\n    run: async () => {\n        const raw = process.versions.node;\n        const major = Number(raw.split('.')[0]);\n        if (!Number.isFinite(major) || major < options.min) {\n            return {\n                ok: false,\n                message: `running on Node ${raw}; need ≥ ${options.min}`,\n                fixHint: `Install Node ${options.min}+ (e.g. \\`fnm install ${options.min}\\` or \\`nvm install ${options.min}\\`).`,\n            };\n        }\n        return { ok: true, message: `Node ${raw}` };\n    },\n});\n\n/** Options for `pnpmVersion`. */\nexport interface PnpmVersionOptions {\n    /**\n     * If supplied, the installed pnpm version must match exactly. Otherwise\n     * only presence on PATH is checked.\n     */\n    expected?: string;\n}\n\n/**\n * Check that pnpm is on PATH and (optionally) matches a specific version. Fails\n * with a corepack-flavoured fixHint when the binary is missing or mismatched.\n */\nexport const pnpmVersion = (options: PnpmVersionOptions = {}): Check => ({\n    name: 'pnpm version',\n    run: async ctx => {\n        let installed: string;\n        try {\n            const result = await ctx.shell.run('pnpm', ['--version']);\n            installed = String(result.stdout).trim();\n        } catch {\n            return {\n                ok: false,\n                message: 'pnpm not found on PATH',\n                fixHint: 'Install pnpm via corepack: `corepack enable && corepack prepare pnpm@latest --activate`.',\n            };\n        }\n        if (options.expected && installed !== options.expected) {\n            return {\n                ok: false,\n                message: `pnpm ${installed}; expected ${options.expected}`,\n                fixHint: `Run \\`corepack prepare pnpm@${options.expected} --activate\\` to match.`,\n            };\n        }\n        return { ok: true, message: `pnpm ${installed}` };\n    },\n});\n"],"mappings":";;;;AASO,IAAMA,cAAc,wBAACC,aAAwC;EAChEC,MAAM,eAAUD,QAAQE,GAAG;EAC3BC,KAAK,mCAAA;AACD,UAAMC,MAAMC,QAAQC,SAASC;AAC7B,UAAMC,QAAQC,OAAOL,IAAIM,MAAM,GAAA,EAAK,CAAA,CAAE;AACtC,QAAI,CAACD,OAAOE,SAASH,KAAAA,KAAUA,QAAQR,QAAQE,KAAK;AAChD,aAAO;QACHU,IAAI;QACJC,SAAS,mBAAmBT,GAAAA,iBAAeJ,QAAQE,GAAG;QACtDY,SAAS,gBAAgBd,QAAQE,GAAG,yBAAyBF,QAAQE,GAAG,uBAAuBF,QAAQE,GAAG;MAC9G;IACJ;AACA,WAAO;MAAEU,IAAI;MAAMC,SAAS,QAAQT,GAAAA;IAAM;EAC9C,GAXK;AAYT,IAd2B;AA6BpB,IAAMW,cAAc,wBAACf,UAA8B,CAAC,OAAc;EACrEC,MAAM;EACNE,KAAK,8BAAMa,QAAAA;AACP,QAAIC;AACJ,QAAI;AACA,YAAMC,SAAS,MAAMF,IAAIG,MAAMhB,IAAI,QAAQ;QAAC;OAAY;AACxDc,kBAAYG,OAAOF,OAAOG,MAAM,EAAEC,KAAI;IAC1C,QAAQ;AACJ,aAAO;QACHV,IAAI;QACJC,SAAS;QACTC,SAAS;MACb;IACJ;AACA,QAAId,QAAQuB,YAAYN,cAAcjB,QAAQuB,UAAU;AACpD,aAAO;QACHX,IAAI;QACJC,SAAS,QAAQI,SAAAA,cAAuBjB,QAAQuB,QAAQ;QACxDT,SAAS,+BAA+Bd,QAAQuB,QAAQ;MAC5D;IACJ;AACA,WAAO;MAAEX,IAAI;MAAMC,SAAS,QAAQI,SAAAA;IAAY;EACpD,GApBK;AAqBT,IAvB2B;","names":["nodeVersion","options","name","min","run","raw","process","versions","node","major","Number","split","isFinite","ok","message","fixHint","pnpmVersion","ctx","installed","result","shell","String","stdout","trim","expected"]}

package/dist/types-CH7ccr3j.d.ts

@@ -0,0 +1,119 @@
+import { AppConfig } from '@maroonedsoftware/appconfig';
+import { Options, ResultPromise } from 'execa';
+
+/** Minimal logger interface that every command and check receives via `CliContext`. */
+interface CliLogger {
+    info: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+    debug: (msg: string) => void;
+    success: (msg: string) => void;
+}
+/** Options accepted by `createDefaultLogger`. */
+interface CreateLoggerOptions {
+    /** When true, `debug` writes to stdout; otherwise it's a no-op. */
+    verbose?: boolean;
+}
+/**
+ * Build the default ANSI-coloured console logger used when a consumer doesn't
+ * supply their own. `debug` output is gated on `verbose`.
+ */
+declare const createDefaultLogger: (options?: CreateLoggerOptions) => CliLogger;
+
+/** Execa options re-typed to require a string `cwd` at the call site. */
+interface ShellOptions extends Options {
+    cwd?: string;
+}
+/** Tiny shell wrapper around execa exposed on `CliContext.shell`. */
+interface Shell {
+    /** Run a command, returning the execa result promise. Use this when the caller needs stdout/stderr. */
+    run: (command: string, args: string[], options?: ShellOptions) => ResultPromise;
+    /** Run a command with inherited stdio, returning the exit code. Failures don't throw — the exit code is returned instead. */
+    runStreaming: (command: string, args: string[], options?: ShellOptions) => Promise<number>;
+}
+/** Build a `Shell` bound to `cwd`, logging streaming invocations through `logger.debug`. */
+declare const createShell: (cwd: string, logger: CliLogger) => Shell;
+
+/** Value-coercion hint for an option declared on a `CommandModule`. */
+type OptionType = 'string' | 'number' | 'boolean';
+/** Declarative description of a single CLI option (flag). */
+interface OptionSpec {
+    /** Commander-style flag string, e.g. `'--name <name>'` or `'-n, --name <name>'`. */
+    flags: string;
+    description: string;
+    type?: OptionType;
+    default?: string | number | boolean;
+    required?: boolean;
+    /** Process env var to read the value from when the flag is not supplied on the CLI. */
+    envVar?: string;
+}
+/** Declarative description of a single positional argument. */
+interface ArgSpec {
+    name: string;
+    description: string;
+    required?: boolean;
+    variadic?: boolean;
+}
+/**
+ * A single CLI command unit. `defineCommand` is the recommended way to create one
+ * so TypeScript can infer `Opts` from the literal.
+ */
+interface CommandModule<Opts = Record<string, unknown>> {
+    name?: string;
+    description: string;
+    options?: OptionSpec[];
+    args?: ArgSpec[];
+    /** Optional hook that runs *after* CLI parsing but *before* `run`, only when stdin/stdout are TTYs. Lets a command fill in missing options interactively. */
+    interactive?: (ctx: CliContext, partial: Partial<Opts>) => Promise<Opts>;
+    /** Returning a non-zero number triggers `process.exit(code)`. `void` / `0` means success. */
+    run: (opts: Opts, ctx: CliContext, args: string[]) => Promise<number | void>;
+    /** When true, unknown options and excess positional args are forwarded to `run` verbatim instead of triggering commander errors. */
+    passthrough?: boolean;
+}
+/** A `CommandModule` plus the path under which it should appear in the CLI tree. */
+interface CommandRegistration {
+    path: string[];
+    module: CommandModule;
+}
+/** A `CommandRegistration` tagged with where it came from — used by the registrar to detect collisions and produce useful error messages. */
+interface DiscoveredCommand extends CommandRegistration {
+    source: 'core' | 'plugin';
+    sourceName?: string;
+}
+/** Shape that a workspace plugin's commands file must default-export to be picked up by `loadWorkspacePlugins`. */
+interface PluginManifest {
+    name: string;
+    commands: CommandRegistration[];
+}
+/** Outcome of a single doctor check. `fixHint` is rendered when `--fix` is not in play. */
+interface CheckResult {
+    ok: boolean;
+    message: string;
+    fixHint?: string;
+}
+/**
+ * A single doctor check. `run` must always resolve — throws are caught by the
+ * runner and rendered as failures. When `autoFix` is supplied and the user passes
+ * `--fix`, the runner invokes it for every failing run.
+ */
+interface Check {
+    name: string;
+    run: (ctx: CliContext) => Promise<CheckResult>;
+    autoFix?: (ctx: CliContext) => Promise<CheckResult>;
+}
+/** Filesystem anchors handed to commands. `repoRoot` is the consumer's workspace, not where johnny5 lives. */
+interface CliPaths {
+    cwd: string;
+    repoRoot: string;
+}
+/** Per-invocation context handed to every command, check, and plugin hook. */
+interface CliContext {
+    paths: CliPaths;
+    logger: CliLogger;
+    shell: Shell;
+    config: AppConfig;
+    isInteractive: () => boolean;
+    env: NodeJS.ProcessEnv;
+}
+
+export { type ArgSpec as A, type CliContext as C, type DiscoveredCommand as D, type OptionSpec as O, type PluginManifest as P, type Shell as S, type CommandRegistration as a, type Check as b, type CliLogger as c, type CommandModule as d, type CheckResult as e, type CliPaths as f, type CreateLoggerOptions as g, type OptionType as h, type ShellOptions as i, createDefaultLogger as j, createShell as k };

package/package.json

@@ -0,0 +1,113 @@
+{
+  "name": "@maroonedsoftware/johnny5",
+  "version": "0.1.0",
+  "description": "CLI framework for ServerKit-based applications — plugin registration, doctor runner, and opt-in Postgres/Redis/Docker integrations",
+  "author": {
+    "name": "Marooned Software",
+    "url": "https://github.com/MaroonedSoftware/serverkit"
+  },
+  "bugs": {
+    "url": "https://github.com/MaroonedSoftware/serverkit/issues"
+  },
+  "homepage": "https://github.com/MaroonedSoftware/serverkit/packages/johnny5#readme",
+  "keywords": [
+    "backend",
+    "cli",
+    "doctor",
+    "framework",
+    "injectkit",
+    "serverkit",
+    "typescript"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MaroonedSoftware/serverkit.git"
+  },
+  "private": false,
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./serverkit": {
+      "types": "./dist/integrations/serverkit/index.d.ts",
+      "import": "./dist/integrations/serverkit/index.js"
+    },
+    "./postgres": {
+      "types": "./dist/integrations/postgres/index.d.ts",
+      "import": "./dist/integrations/postgres/index.js"
+    },
+    "./redis": {
+      "types": "./dist/integrations/redis/index.d.ts",
+      "import": "./dist/integrations/redis/index.js"
+    },
+    "./docker": {
+      "types": "./dist/integrations/docker/index.d.ts",
+      "import": "./dist/integrations/docker/index.js"
+    },
+    "./versions": {
+      "types": "./dist/integrations/versions/index.d.ts",
+      "import": "./dist/integrations/versions/index.js"
+    },
+    "./filesystem": {
+      "types": "./dist/integrations/filesystem/index.d.ts",
+      "import": "./dist/integrations/filesystem/index.js"
+    }
+  },
+  "license": "MIT",
+  "files": [
+    "dist/**"
+  ],
+  "dependencies": {
+    "@clack/prompts": "^0.11.0",
+    "commander": "^14.0.3",
+    "execa": "^9.6.0",
+    "injectkit": "^1.2.0",
+    "@maroonedsoftware/logger": "1.1.0",
+    "@maroonedsoftware/appconfig": "1.4.1"
+  },
+  "peerDependencies": {
+    "ioredis": "^5.10.0",
+    "kysely": "^0.28.0",
+    "pg": "^8.20.0",
+    "@maroonedsoftware/koa": "2.2.1"
+  },
+  "peerDependenciesMeta": {
+    "@maroonedsoftware/koa": {
+      "optional": true
+    },
+    "ioredis": {
+      "optional": true
+    },
+    "kysely": {
+      "optional": true
+    },
+    "pg": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/pg": "^8.20.0",
+    "ioredis": "^5.10.1",
+    "kysely": "^0.28.6",
+    "pg": "^8.20.0",
+    "tsup": "^8.5.1",
+    "vitest": "^4.1.5",
+    "@repo/config-eslint": "0.2.1",
+    "@maroonedsoftware/koa": "2.2.1",
+    "@repo/config-typescript": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "build:ci": "eslint --max-warnings=0 && pnpm run build",
+    "dev": "tsup --watch",
+    "lint": "eslint --fix",
+    "format": "prettier --write .",
+    "test": "vitest run",
+    "test:ci": "vitest run --coverage"
+  }
+}