@bensandee/tooling 0.13.0 → 0.14.1

package/dist/docker-verify/index.mjs

@@ -0,0 +1,218 @@
+import { t as isExecSyncError } from "../exec-CC49vrkM.mjs";
+import { execSync } from "node:child_process";
+import { z } from "zod";
+//#region src/docker-verify/executor.ts
+/** Create an executor that runs real commands, fetches, and manages process signals. */
+function createRealExecutor() {
+	return {
+		exec(command, options) {
+			try {
+				return {
+					stdout: execSync(command, {
+						cwd: options?.cwd,
+						env: options?.env ? {
+							...process.env,
+							...options.env
+						} : void 0,
+						encoding: "utf-8",
+						stdio: [
+							"pipe",
+							"pipe",
+							"pipe"
+						]
+					}),
+					stderr: "",
+					exitCode: 0
+				};
+			} catch (err) {
+				if (isExecSyncError(err)) return {
+					stdout: err.stdout,
+					stderr: err.stderr,
+					exitCode: err.status
+				};
+				return {
+					stdout: "",
+					stderr: "",
+					exitCode: 1
+				};
+			}
+		},
+		execInherit(command, options) {
+			execSync(command, {
+				cwd: options?.cwd,
+				env: options?.env ? {
+					...process.env,
+					...options.env
+				} : void 0,
+				stdio: "inherit"
+			});
+		},
+		fetch: globalThis.fetch,
+		now: () => Date.now(),
+		sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+		onSignal(signal, handler) {
+			process.on(signal, handler);
+			return () => {
+				process.removeListener(signal, handler);
+			};
+		},
+		log: (msg) => console.log(msg),
+		logError: (msg) => console.error(msg)
+	};
+}
+//#endregion
+//#region src/docker-verify/compose.ts
+/** Zod schema for a single container entry from `docker compose ps --format json`. */
+const ContainerInfoSchema = z.object({
+	Service: z.string(),
+	Health: z.string()
+});
+/** Build the `docker compose` base command string from config. */
+function composeCommand(config) {
+	return `docker compose ${config.composeFiles.map((f) => `-f ${f}`).join(" ")}${config.envFile ? ` --env-file ${config.envFile}` : ""}`;
+}
+/** Run the build command if configured. */
+function buildImages(executor, config) {
+	if (!config.buildCommand) return;
+	executor.execInherit(config.buildCommand, { cwd: config.buildCwd ?? config.compose.cwd });
+}
+/** Start the compose stack in detached mode. */
+function composeUp(executor, config) {
+	executor.execInherit(`${composeCommand(config)} up -d`, { cwd: config.cwd });
+}
+/** Tear down the compose stack, removing volumes and orphans. Swallows errors. */
+function composeDown(executor, config) {
+	try {
+		executor.execInherit(`${composeCommand(config)} down -v --remove-orphans`, { cwd: config.cwd });
+	} catch (_error) {}
+}
+/** Show logs for a specific service (or all services if not specified). Swallows errors. */
+function composeLogs(executor, config, service) {
+	try {
+		const suffix = service ? ` ${service}` : "";
+		executor.execInherit(`${composeCommand(config)} logs${suffix}`, { cwd: config.cwd });
+	} catch (_error) {}
+}
+/**
+* Query container status via `docker compose ps --format json`.
+* Handles both JSON array and newline-delimited JSON (varies by docker compose version).
+*/
+function composePs(executor, config) {
+	const output = executor.exec(`${composeCommand(config)} ps --format json`, { cwd: config.cwd }).stdout.trim();
+	if (!output) return [];
+	const ArraySchema = z.array(ContainerInfoSchema);
+	try {
+		const direct = ArraySchema.safeParse(JSON.parse(output));
+		if (direct.success) return direct.data;
+		const single = ContainerInfoSchema.safeParse(JSON.parse(output));
+		if (single.success) return [single.data];
+	} catch (_error) {}
+	try {
+		const joined = `[${output.split("\n").join(",")}]`;
+		const delimited = ArraySchema.safeParse(JSON.parse(joined));
+		return delimited.success ? delimited.data : [];
+	} catch (_error) {
+		return [];
+	}
+}
+//#endregion
+//#region src/docker-verify/health.ts
+/** Look up the health status of a specific service from container info. */
+function getContainerHealth(containers, serviceName) {
+	return containers.find((c) => c.Service === serviceName)?.Health ?? "unknown";
+}
+/** Run a single HTTP health check, returning true if the validator passes. */
+async function checkHttpHealth(executor, check) {
+	try {
+		const response = await executor.fetch(check.url);
+		return await check.validate(response);
+	} catch (_error) {
+		return false;
+	}
+}
+//#endregion
+//#region src/docker-verify/verify.ts
+const DEFAULT_TIMEOUT_MS = 12e4;
+const DEFAULT_POLL_INTERVAL_MS = 5e3;
+/** Run the full Docker image verification lifecycle. */
+async function runVerification(executor, config) {
+	const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+	const pollIntervalMs = config.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+	const { compose } = config;
+	const cleanup = () => composeDown(executor, compose);
+	const disposeInt = executor.onSignal("SIGINT", () => {
+		cleanup();
+		process.exit(1);
+	});
+	const disposeTerm = executor.onSignal("SIGTERM", () => {
+		cleanup();
+		process.exit(1);
+	});
+	try {
+		if (config.buildCommand) {
+			executor.log("Building images...");
+			buildImages(executor, config);
+		}
+		executor.log("Starting compose stack...");
+		composeUp(executor, compose);
+		executor.log(`Waiting for stack to be healthy (max ${timeoutMs / 1e3}s)...`);
+		const startTime = executor.now();
+		const healthStatus = new Map(config.healthChecks.map((c) => [c.name, false]));
+		while (executor.now() - startTime < timeoutMs) {
+			const containers = composePs(executor, compose);
+			for (const service of compose.services) if (getContainerHealth(containers, service) === "unhealthy") {
+				executor.logError(`Container ${service} is unhealthy`);
+				composeLogs(executor, compose, service);
+				cleanup();
+				return {
+					success: false,
+					reason: "unhealthy-container",
+					message: service,
+					elapsedMs: executor.now() - startTime
+				};
+			}
+			for (const check of config.healthChecks) if (!healthStatus.get(check.name)) {
+				if (await checkHttpHealth(executor, check)) {
+					healthStatus.set(check.name, true);
+					executor.log(`${check.name} is healthy!`);
+				}
+			}
+			if ([...healthStatus.values()].every(Boolean)) {
+				executor.log("Verification successful! All systems operational.");
+				cleanup();
+				return {
+					success: true,
+					elapsedMs: executor.now() - startTime
+				};
+			}
+			const elapsed = Math.floor((executor.now() - startTime) / 1e3);
+			if (elapsed > 0 && elapsed % 5 === 0) {
+				const statuses = [...healthStatus.entries()].map(([name, ok]) => `${name}=${ok ? "OK" : "Pending"}`).join(", ");
+				executor.log(`Waiting... (${elapsed}s elapsed). ${statuses}`);
+			}
+			await executor.sleep(pollIntervalMs);
+		}
+		executor.logError("Timeout waiting for stack to become healthy");
+		for (const service of compose.services) composeLogs(executor, compose, service);
+		cleanup();
+		return {
+			success: false,
+			reason: "timeout",
+			message: "Exceeded timeout",
+			elapsedMs: executor.now() - startTime
+		};
+	} catch (error) {
+		cleanup();
+		return {
+			success: false,
+			reason: "error",
+			message: error instanceof Error ? error.message : String(error),
+			elapsedMs: 0
+		};
+	} finally {
+		disposeInt();
+		disposeTerm();
+	}
+}
+//#endregion
+export { checkHttpHealth, composeCommand, composeDown, composeLogs, composePs, composeUp, createRealExecutor, getContainerHealth, runVerification };

package/dist/exec-CC49vrkM.mjs

@@ -0,0 +1,7 @@
+//#region src/utils/exec.ts
+/** Type guard for `execSync` errors that carry stdout/stderr/status. */
+function isExecSyncError(err) {
+	return err instanceof Error && "stdout" in err && typeof err.stdout === "string" && "stderr" in err && typeof err.stderr === "string" && "status" in err && typeof err.status === "number";
+}
+//#endregion
+export { isExecSyncError as t };

package/dist/index.d.mts

@@ -0,0 +1,104 @@
+import { z } from "zod";
+
+//#region src/utils/json.d.ts
+declare const PackageJsonSchema: z.ZodObject<{
+  name: z.ZodOptional<z.ZodString>;
+  version: z.ZodOptional<z.ZodString>;
+  private: z.ZodOptional<z.ZodBoolean>;
+  type: z.ZodOptional<z.ZodString>;
+  scripts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  devDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  bin: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+  exports: z.ZodOptional<z.ZodUnknown>;
+  main: z.ZodOptional<z.ZodString>;
+  types: z.ZodOptional<z.ZodString>;
+  typings: z.ZodOptional<z.ZodString>;
+  engines: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$loose>;
+type PackageJson = z.infer<typeof PackageJsonSchema>;
+//#endregion
+//#region src/types.d.ts
+type CiPlatform = "github" | "forgejo" | "none";
+type ReleaseStrategy = "release-it" | "simple" | "changesets" | "none";
+/** User's answers from the interactive prompt or CLI flags. */
+interface ProjectConfig {
+  /** Project name (from package.json name or user input) */
+  name: string;
+  /** Whether this is a new project or existing */
+  isNew: boolean;
+  /** Project structure */
+  structure: "single" | "monorepo";
+  /** Include @bensandee/eslint-plugin oxlint plugin */
+  useEslintPlugin: boolean;
+  /** Formatter choice */
+  formatter: "oxfmt" | "prettier";
+  /** Set up vitest with a starter test */
+  setupVitest: boolean;
+  /** CI platform choice */
+  ci: CiPlatform;
+  /** Set up Renovate for automated dependency updates */
+  setupRenovate: boolean;
+  /** Release management strategy */
+  releaseStrategy: ReleaseStrategy;
+  /** Project type determines tsconfig base configuration */
+  projectType: "default" | "node" | "react" | "library";
+  /** Auto-detect and configure tsconfig bases for monorepo packages */
+  detectPackageTypes: boolean;
+  /** Target directory (default: cwd) */
+  targetDir: string;
+}
+/** Result from a single generator: what file was written and how. */
+interface GeneratorResult {
+  filePath: string;
+  action: "created" | "updated" | "skipped" | "archived";
+  /** Human-readable description of what changed */
+  description: string;
+}
+/** Context passed to each generator function. */
+interface GeneratorContext {
+  config: ProjectConfig;
+  /** Absolute path to target directory */
+  targetDir: string;
+  /** Pre-parsed package.json from the target directory, or undefined if missing/invalid */
+  packageJson: PackageJson | undefined;
+  /** Check whether a file exists in the target directory */
+  exists: (relativePath: string) => boolean;
+  /** Read an existing file from the target directory, returns undefined if not found */
+  read: (relativePath: string) => string | undefined;
+  /** Write a file to the target directory (creating directories as needed) */
+  write: (relativePath: string, content: string) => void;
+  /** Remove a file from the target directory (no-op if not found) */
+  remove: (relativePath: string) => void;
+  /** Prompt user for conflict resolution on non-mergeable files */
+  confirmOverwrite: (relativePath: string) => Promise<"overwrite" | "skip">;
+}
+/** Generator function signature. */
+type Generator = (ctx: GeneratorContext) => Promise<GeneratorResult>;
+/** State detected from an existing project directory. */
+interface DetectedProjectState {
+  hasPackageJson: boolean;
+  hasTsconfig: boolean;
+  hasOxlintConfig: boolean;
+  /** Legacy .oxlintrc.json found (should be migrated to oxlint.config.ts) */
+  hasLegacyOxlintJson: boolean;
+  hasGitignore: boolean;
+  hasVitestConfig: boolean;
+  hasTsdownConfig: boolean;
+  hasPnpmWorkspace: boolean;
+  hasKnipConfig: boolean;
+  hasRenovateConfig: boolean;
+  hasReleaseItConfig: boolean;
+  hasSimpleReleaseConfig: boolean;
+  hasChangesetsConfig: boolean;
+  /** Legacy tooling configs found */
+  legacyConfigs: LegacyConfig[];
+}
+declare const LEGACY_TOOLS: readonly ["eslint", "prettier", "jest", "webpack", "rollup"];
+type LegacyTool = (typeof LEGACY_TOOLS)[number];
+interface LegacyConfig {
+  tool: LegacyTool;
+  files: string[];
+}
+//#endregion
+export { type DetectedProjectState, type Generator, type GeneratorContext, type GeneratorResult, type LegacyConfig, type ProjectConfig };

package/package.json

@@ -1,20 +1,28 @@
 {
   "name": "@bensandee/tooling",
-  "version": "0.13.0",
+  "version": "0.14.1",
   "description": "CLI tool to bootstrap and maintain standardized TypeScript project tooling",
   "bin": {
     "tooling": "./dist/bin.mjs"
   },
   "files": [
-    "dist"
+    "dist",
+    "CHANGELOG.md"
   ],
   "type": "module",
   "imports": {
-    "#src/*": "./src/*.ts"
+    "#src/*.ts": "./src/*.ts"
   },
   "exports": {
-    ".": "./dist/index.mjs",
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
     "./bin": "./dist/bin.mjs",
+    "./docker-verify": {
+      "types": "./dist/docker-verify/index.d.mts",
+      "default": "./dist/docker-verify/index.mjs"
+    },
     "./package.json": "./package.json"
   },
   "publishConfig": {
@@ -27,14 +35,18 @@
     "jsonc-parser": "^3.3.1",
     "yaml": "^2.8.2",
     "zod": "^4.3.6",
-    "@bensandee/common": "0.1.0"
+    "@bensandee/common": "0.1.2"
   },
   "devDependencies": {
     "@types/node": "24.12.0",
-    "tsdown": "0.21.0",
+    "tsdown": "0.21.2",
     "typescript": "5.9.3",
     "vitest": "4.0.18",
-    "@bensandee/config": "0.7.1"
+    "@bensandee/config": "0.8.1"
+  },
+  "optionalDependencies": {
+    "@changesets/cli": "^2.29.4",
+    "commit-and-tag-version": "^12.5.0"
   },
   "scripts": {
     "build": "tsdown",