@buildepicshit/cli 0.0.2 → 0.0.4

package/src/orchestrator/core/token.ts

@@ -0,0 +1,88 @@
+import { readFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import type { ComputeContext, LazyEnvSource, Token } from "./types.js";
+
+export function compute(fn: (ctx: ComputeContext) => Promise<string>): Token {
+	return fn;
+}
+
+export function fromEnv(key: string, fallback?: string): Token {
+	return async ({ env }: ComputeContext) => {
+		const value = env[key];
+		if (value !== undefined) return value;
+		if (fallback !== undefined) return fallback;
+		throw new Error(
+			`Environment variable "${key}" is not set and no fallback provided`,
+		);
+	};
+}
+
+export function fromPackageJson(path: string, fallback?: string): Token {
+	return async ({ cwd }: ComputeContext) => {
+		const raw = await readFile(join(cwd, "package.json"), "utf8");
+		const pkg = JSON.parse(raw);
+
+		const value = path.split(".").reduce<unknown>((obj, key) => {
+			if (obj != null && typeof obj === "object") {
+				return (obj as Record<string, unknown>)[key];
+			}
+			return undefined;
+		}, pkg);
+
+		if (value !== undefined) return String(value);
+		if (fallback !== undefined) return fallback;
+		throw new Error(
+			`package.json path "${path}" not found in ${cwd}/package.json and no fallback provided`,
+		);
+	};
+}
+
+/**
+ * Parse .env file(s) relative to the command's cwd.
+ * Multiple files can be passed — later files override earlier ones.
+ */
+export function fromFile(...paths: string[]): LazyEnvSource {
+	return {
+		__type: "env-source",
+		resolve: async (ctx: ComputeContext) => {
+			const env: Record<string, string> = {};
+
+			for (const filePath of paths) {
+				const fullPath = resolve(ctx.cwd, filePath);
+				let content: string;
+				try {
+					content = await readFile(fullPath, "utf8");
+				} catch {
+					continue; // skip missing files silently
+				}
+
+				for (const line of content.split("\n")) {
+					const trimmed = line.trim();
+					if (!trimmed || trimmed.startsWith("#")) continue;
+					const eqIdx = trimmed.indexOf("=");
+					if (eqIdx === -1) continue;
+					const key = trimmed.slice(0, eqIdx).trim();
+					let value = trimmed.slice(eqIdx + 1).trim();
+					// Strip surrounding quotes
+					if (
+						(value.startsWith('"') && value.endsWith('"')) ||
+						(value.startsWith("'") && value.endsWith("'"))
+					) {
+						value = value.slice(1, -1);
+					}
+					env[key] = value;
+				}
+			}
+
+			return env;
+		},
+	};
+}
+
+export async function resolveToken(
+	token: Token,
+	ctx: ComputeContext,
+): Promise<string> {
+	if (typeof token === "string") return token;
+	return token(ctx);
+}

package/src/orchestrator/core/types.ts

@@ -0,0 +1,102 @@
+import type { Identity } from "../utils/dna.js";
+
+// ─── Token ───────────────────────────────────────────────────────────────────
+
+export type ComputeContext = {
+	cwd: string;
+	env: Record<string, string>;
+	root: string;
+};
+
+export type Token = string | ((ctx: ComputeContext) => Promise<string>);
+
+// ─── Env Source ──────────────────────────────────────────────────────────────
+
+export interface LazyEnvSource {
+	__type: "env-source";
+	resolve: (ctx: ComputeContext) => Promise<Record<string, string>>;
+}
+
+export type EnvCallback = (
+	self: ICommand,
+) => Record<string, Token> | LazyEnvSource;
+
+export type EnvSource = Record<string, Token> | LazyEnvSource | EnvCallback;
+
+export function isLazyEnvSource(
+	source: Record<string, Token> | LazyEnvSource,
+): source is LazyEnvSource {
+	return (
+		typeof source === "object" &&
+		"__type" in source &&
+		source.__type === "env-source"
+	);
+}
+
+export function isEnvCallback(source: EnvSource): source is EnvCallback {
+	return typeof source === "function";
+}
+
+// ─── Command ─────────────────────────────────────────────────────────────────
+
+export interface BuiltCommand {
+	args: string[];
+	command: string;
+	cwd: string;
+	env: Record<string, string>;
+}
+
+export interface IdentityAccessor extends Identity {
+	(suffix: string): ICommand;
+}
+
+export interface ICommand {
+	readonly __type: "command";
+	arg(value: Token): ICommand;
+	as(name: string): ICommand;
+	build(ctx: ComputeContext): Promise<BuiltCommand>;
+	collectNames(): string[];
+	dependsOn(...deps: Runnable[]): ICommand;
+	dir(path: string): ICommand;
+	env(source: EnvSource): ICommand;
+	flag(name: string, value?: Token): ICommand;
+	readonly identity: IdentityAccessor;
+	run(): Promise<void>;
+	waitFor(check: HealthCheck | HealthCheckCallback): ICommand;
+}
+
+// ─── Compound ────────────────────────────────────────────────────────────────
+
+export interface ICompound {
+	readonly __type: "compound";
+	collectNames(): string[];
+	dir(path: string): ICompound;
+	env(source: EnvSource): ICompound;
+	readonly mode: "par" | "seq";
+	run(): Promise<void>;
+}
+
+// ─── Runnable ────────────────────────────────────────────────────────────────
+
+export type Runnable = ICommand | ICompound;
+
+// ─── Health Check ────────────────────────────────────────────────────────────
+
+export type HealthCheckCallback = (self: ICommand) => HealthCheck;
+
+export type HealthCheck =
+	| { type: "tcp"; host: Token; port: Token }
+	| { type: "http"; url: Token; status?: number }
+	| { type: "stdout"; pattern: RegExp }
+	| { type: "exec"; command: ICommand }
+	| { type: "custom"; check: () => Promise<boolean> };
+
+// ─── Process ─────────────────────────────────────────────────────────────────
+
+export type ProcessStatus =
+	| "completed"
+	| "failed"
+	| "healthy"
+	| "pending"
+	| "running"
+	| "starting";

package/src/orchestrator/index.ts

@@ -0,0 +1,67 @@
+// Core API
+export {
+	cmd,
+	compute,
+	customHealthCheck,
+	execHealthCheck,
+	fromEnv,
+	fromFile,
+	fromPackageJson,
+	health,
+	httpHealthCheck,
+	par,
+	postgresHealthCheck,
+	seq,
+	stdoutHealthCheck,
+	tcpHealthCheck,
+} from "./core/index.js";
+// Types
+export type {
+	BuiltCommand,
+	ComputeContext,
+	EnvCallback,
+	EnvSource,
+	HealthCheck,
+	HealthCheckCallback,
+	ICommand,
+	ICompound,
+	IdentityAccessor,
+	ProcessStatus,
+	Runnable,
+	Token,
+} from "./core/types.js";
+// Logger
+export type { Logger } from "./logger/logger.js";
+export { createLazyLogger, createLogger } from "./logger/logger.js";
+// Presets
+export type { IDockerCompose, IDrizzle, INextjs, NextPreset } from "./presets/index.js";
+export {
+	docker,
+	dockerCompose,
+	drizzle,
+	esbuild,
+	esbuildWatch,
+	hono,
+	next,
+	nextjs,
+	nodemon,
+	tsx,
+} from "./presets/index.js";
+// Runner
+export type {
+	DevEvent,
+	IEventBus,
+	LogEntry,
+	OrchestratorProcess,
+	ProcessMeta,
+	RuntimeContext,
+} from "./runner/index.js";
+export {
+	clearRuntimeContext,
+	createEventBus,
+	getRuntimeContext,
+	setRuntimeContext,
+} from "./runner/index.js";
+export type { Identity } from "./utils/dna.js";
+// Utils
+export { createIdentity, identity } from "./utils/dna.js";

package/src/orchestrator/logger/logger.ts

@@ -0,0 +1,123 @@
+import chalk, { type ChalkInstance } from "chalk";
+
+const COLORS: ChalkInstance[] = [
+	chalk.cyan,
+	chalk.magenta,
+	chalk.yellow,
+	chalk.green,
+	chalk.blue,
+	chalk.red,
+	chalk.white,
+];
+
+export interface Logger {
+	completed(serviceName: string): void;
+	error(serviceName: string, message: string): void;
+	healthy(serviceName: string): void;
+	output(serviceName: string, line: string, stream: "stderr" | "stdout"): void;
+	ready(serviceName: string): void;
+	starting(serviceName: string, nodeId: string): void;
+	system(message: string): void;
+}
+
+export function createLogger(serviceNames: string[]): Logger {
+	// Compute max prefix width for alignment
+	const maxLen = Math.max(...serviceNames.map((n) => n.length), 6);
+	const colorMap = new Map<string, ChalkInstance>();
+
+	for (let i = 0; i < serviceNames.length; i++) {
+		colorMap.set(serviceNames[i], COLORS[i % COLORS.length]);
+	}
+
+	function prefix(name: string): string {
+		const color = colorMap.get(name) ?? chalk.white;
+		return color(`[${name.padEnd(maxLen)}]`);
+	}
+
+	return {
+		completed(serviceName) {
+			console.log(`${prefix(serviceName)} ${chalk.green("completed")} ✓`);
+		},
+
+		error(serviceName, message) {
+			console.error(
+				`${prefix(serviceName)} ${chalk.red("error")} ✗ ${message}`,
+			);
+		},
+
+		healthy(serviceName) {
+			console.log(`${prefix(serviceName)} ${chalk.green("healthy")} ✓`);
+		},
+
+		output(serviceName, line, _stream) {
+			console.log(`${prefix(serviceName)} ${line}`);
+		},
+
+		ready(serviceName) {
+			console.log(`${prefix(serviceName)} ${chalk.green("ready")} ✓`);
+		},
+		starting(serviceName, nodeId) {
+			console.log(`${prefix(serviceName)} Starting ${nodeId}...`);
+		},
+
+		system(message) {
+			console.log(chalk.gray(message));
+		},
+	};
+}
+
+/**
+ * Lazy logger that auto-registers service names on first use.
+ * Adjusts column padding dynamically as new names appear.
+ */
+export function createLazyLogger(): Logger {
+	const colorMap = new Map<string, ChalkInstance>();
+	let maxLen = 6;
+	let nextColorIdx = 0;
+
+	function ensureName(name: string) {
+		if (!colorMap.has(name)) {
+			colorMap.set(name, COLORS[nextColorIdx % COLORS.length]);
+			nextColorIdx++;
+			maxLen = Math.max(maxLen, name.length);
+		}
+	}
+
+	function prefix(name: string): string {
+		ensureName(name);
+		const color = colorMap.get(name) as ChalkInstance;
+		return color(`[${name.padEnd(maxLen)}]`);
+	}
+
+	return {
+		completed(serviceName) {
+			console.log(`${prefix(serviceName)} ${chalk.green("completed")} ✓`);
+		},
+
+		error(serviceName, message) {
+			console.error(
+				`${prefix(serviceName)} ${chalk.red("error")} ✗ ${message}`,
+			);
+		},
+
+		healthy(serviceName) {
+			console.log(`${prefix(serviceName)} ${chalk.green("healthy")} ✓`);
+		},
+
+		output(serviceName, line, _stream) {
+			console.log(`${prefix(serviceName)} ${line}`);
+		},
+
+		ready(serviceName) {
+			console.log(`${prefix(serviceName)} ${chalk.green("ready")} ✓`);
+		},
+
+		starting(serviceName, _nodeId) {
+			console.log(`${prefix(serviceName)} Starting...`);
+		},
+
+		system(message) {
+			console.log(chalk.gray(message));
+		},
+	};
+}

package/src/orchestrator/presets/docker.ts

@@ -0,0 +1,164 @@
+import { cmd } from "../core/command.js";
+import type {
+	BuiltCommand,
+	ComputeContext,
+	EnvSource,
+	HealthCheck,
+	HealthCheckCallback,
+	ICommand,
+	IdentityAccessor,
+	Runnable,
+	Token,
+} from "../core/types.js";
+
+export interface IDockerCompose extends ICommand {
+	file(path: string): IDockerCompose;
+	up(options?: { detach?: boolean }): IDockerCompose;
+}
+
+interface DockerComposeState {
+	readonly detach: boolean;
+	readonly filePath: string | null;
+}
+
+class DockerCompose implements IDockerCompose {
+	readonly __type = "command" as const;
+	private readonly inner: ICommand;
+	private readonly dcState: DockerComposeState;
+
+	constructor(inner: ICommand, dcState: DockerComposeState) {
+		this.inner = inner;
+		this.dcState = dcState;
+	}
+
+	// ─── Docker-compose-specific methods ─────────────────────────────────
+
+	up(options?: { detach?: boolean }): IDockerCompose {
+		return new DockerCompose(this.inner, {
+			...this.dcState,
+			detach: options?.detach ?? true,
+		});
+	}
+
+	file(path: string): IDockerCompose {
+		return new DockerCompose(this.inner, {
+			...this.dcState,
+			filePath: path,
+		});
+	}
+
+	// ─── ICommand delegation (returns IDockerCompose for chaining) ───────
+
+	get identity(): IdentityAccessor {
+		const innerAccessor = this.inner.identity;
+		const self = this;
+		const setter = (suffix: string): IDockerCompose => {
+			return new DockerCompose(
+				self.inner.identity(suffix),
+				self.dcState,
+			);
+		};
+		Object.defineProperty(setter, "name", {
+			configurable: true,
+			value: innerAccessor.name,
+		});
+		return Object.assign(setter, {
+			localhostUrl: innerAccessor.localhostUrl,
+			port: innerAccessor.port,
+			url: innerAccessor.url,
+		}) as IdentityAccessor;
+	}
+
+	flag(name: string, value?: Token): IDockerCompose {
+		return new DockerCompose(this.inner.flag(name, value), this.dcState);
+	}
+
+	arg(value: Token): IDockerCompose {
+		return new DockerCompose(this.inner.arg(value), this.dcState);
+	}
+
+	env(source: EnvSource): IDockerCompose {
+		return new DockerCompose(this.inner.env(source), this.dcState);
+	}
+
+	dir(path: string): IDockerCompose {
+		return new DockerCompose(this.inner.dir(path), this.dcState);
+	}
+
+	waitFor(check: HealthCheck | HealthCheckCallback): IDockerCompose {
+		return new DockerCompose(this.inner.waitFor(check), this.dcState);
+	}
+
+	as(name: string): IDockerCompose {
+		return new DockerCompose(this.inner.as(name), this.dcState);
+	}
+
+	dependsOn(...deps: Runnable[]): IDockerCompose {
+		return new DockerCompose(
+			this.inner.dependsOn(...deps),
+			this.dcState,
+		);
+	}
+
+	collectNames(): string[] {
+		return this.inner.collectNames();
+	}
+
+	async build(ctx: ComputeContext): Promise<BuiltCommand> {
+		// Build the final docker compose command from state
+		let command = this.inner;
+		if (this.dcState.filePath) {
+			command = command.flag("file", this.dcState.filePath);
+		}
+		command = command.arg("up");
+		if (this.dcState.detach) {
+			command = command.flag("detach");
+		}
+		return command.build(ctx);
+	}
+
+	async run(): Promise<void> {
+		// Build a resolved inner command with docker-compose args applied
+		let command = this.inner;
+		if (this.dcState.filePath) {
+			command = command.flag("file", this.dcState.filePath);
+		}
+		command = command.arg("up");
+		if (this.dcState.detach) {
+			command = command.flag("detach");
+		}
+		return command.run();
+	}
+}
+
+export function dockerCompose(): IDockerCompose {
+	return new DockerCompose(cmd("docker compose"), {
+		detach: false,
+		filePath: null,
+	});
+}
+
+/** @deprecated Use `dockerCompose()` instead */
+export function docker(options?: {
+	detach?: boolean;
+	file?: Token;
+	service?: string;
+}): ICommand {
+	let command = cmd("docker compose");
+
+	if (options?.file) {
+		command = command.flag("file", options.file);
+	}
+
+	command = command.arg("up");
+
+	if (options?.detach) {
+		command = command.flag("detach");
+	}
+
+	if (options?.service) {
+		command = command.arg(options.service);
+	}
+
+	return command;
+}

package/src/orchestrator/presets/drizzle.ts

@@ -0,0 +1,93 @@
+import { cmd } from "../core/command.js";
+import type {
+	EnvSource,
+	ICommand,
+	LazyEnvSource,
+	Runnable,
+	Token,
+} from "../core/types.js";
+
+export interface IDrizzle {
+	database(port: Token): IDrizzle;
+	dependsOn(...deps: Runnable[]): IDrizzle;
+	dir(path: string): IDrizzle;
+	envFile(source: LazyEnvSource): IDrizzle;
+	readonly migrate: ICommand;
+	readonly studio: ICommand;
+}
+
+interface DrizzleState {
+	readonly databasePort: Token | null;
+	readonly dependencies: readonly Runnable[];
+	readonly dirPath: string | null;
+	readonly envSources: readonly EnvSource[];
+}
+
+class Drizzle implements IDrizzle {
+	private readonly state: DrizzleState;
+
+	constructor(state: DrizzleState) {
+		this.state = state;
+	}
+
+	database(port: Token): IDrizzle {
+		return new Drizzle({ ...this.state, databasePort: port });
+	}
+
+	dependsOn(...deps: Runnable[]): IDrizzle {
+		return new Drizzle({
+			...this.state,
+			dependencies: [...this.state.dependencies, ...deps],
+		});
+	}
+
+	dir(path: string): IDrizzle {
+		return new Drizzle({ ...this.state, dirPath: path });
+	}
+
+	envFile(source: LazyEnvSource): IDrizzle {
+		return new Drizzle({
+			...this.state,
+			envSources: [...this.state.envSources, source],
+		});
+	}
+
+	get migrate(): ICommand {
+		return this.buildCommand("drizzle-kit migrate");
+	}
+
+	get studio(): ICommand {
+		return this.buildCommand("drizzle-kit studio");
+	}
+
+	private buildCommand(base: string): ICommand {
+		let command: ICommand = cmd(base);
+
+		if (this.state.dirPath) {
+			command = command.dir(this.state.dirPath);
+		}
+
+		for (const source of this.state.envSources) {
+			command = command.env(source);
+		}
+
+		if (this.state.databasePort) {
+			command = command.env({ DATABASE_PORT: this.state.databasePort });
+		}
+
+		if (this.state.dependencies.length > 0) {
+			command = command.dependsOn(...this.state.dependencies);
+		}
+
+		return command;
+	}
+}
+
+export function drizzle(): IDrizzle {
+	return new Drizzle({
+		databasePort: null,
+		dependencies: [],
+		dirPath: null,
+		envSources: [],
+	});
+}

package/src/orchestrator/presets/esbuild.ts

@@ -0,0 +1,12 @@
+import { cmd } from "../core/command.js";
+import type { ICommand } from "../core/types.js";
+
+export function esbuild(configFile?: string): ICommand {
+	return cmd("node").arg(configFile ?? "esbuild.config.js");
+}
+
+export function esbuildWatch(configFile?: string): ICommand {
+	return cmd("node")
+		.arg(configFile ?? "esbuild.config.js")
+		.flag("watch");
+}

package/src/orchestrator/presets/hono.ts

@@ -0,0 +1,7 @@
+import { cmd } from "../core/command.js";
+import type { ICommand } from "../core/types.js";
+import { identity } from "../utils/dna.js";
+
+export function hono(): ICommand {
+	return cmd("tsx").env({ PORT: identity("hono").port() });
+}

package/src/orchestrator/presets/index.ts

@@ -0,0 +1,6 @@
+export { type IDockerCompose, docker, dockerCompose } from "./docker.js";
+export { type IDrizzle, drizzle } from "./drizzle.js";
+export { esbuild, esbuildWatch } from "./esbuild.js";
+export { hono } from "./hono.js";
+export { type INextjs, type NextPreset, next, nextjs } from "./nextjs.js";
+export { nodemon, tsx } from "./node.js";