buncargo 1.0.5

package/lint.ts

@@ -0,0 +1,277 @@
+import { $, Glob } from "bun";
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Types
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Options for running workspace typechecks.
+ */
+export interface WorkspaceTypecheckOptions {
+	/** Root directory to search from (defaults to cwd) */
+	root?: string;
+	/** Glob patterns for workspaces to check (defaults to apps/*, packages/*, modules) */
+	patterns?: string[];
+	/** Maximum concurrent typecheck processes (defaults to 1) */
+	concurrency?: number;
+	/** Print output to console (defaults to true) */
+	verbose?: boolean;
+}
+
+/**
+ * Result of a single workspace typecheck.
+ */
+export interface WorkspaceTypecheckResult {
+	workspace: string;
+	duration: number;
+	success: boolean;
+	fileCount: number;
+	errorOutput?: string;
+}
+
+/**
+ * Overall result of running typechecks across all workspaces.
+ */
+export interface TypecheckResult {
+	success: boolean;
+	totalDuration: number;
+	totalFiles: number;
+	workspaceCount: number;
+	results: WorkspaceTypecheckResult[];
+}
+
+interface Workspace {
+	path: string;
+	fileCount: number;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Constants
+// ═══════════════════════════════════════════════════════════════════════════
+
+const DEFAULT_PATTERNS = ["apps/*", "packages/*", "modules"];
+const DEFAULT_CONCURRENCY = 1;
+
+// Patterns that indicate a corrupted tsgo cache (deadlock/panic)
+const CORRUPTED_CACHE_PATTERNS = [
+	"all goroutines are asleep - deadlock",
+	"fatal error:",
+	"panic:",
+	"github.com/microsoft/typescript-go",
+];
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Helper Functions
+// ═══════════════════════════════════════════════════════════════════════════
+
+function isCorruptedCacheError(output: string): boolean {
+	return CORRUPTED_CACHE_PATTERNS.some((pattern) => output.includes(pattern));
+}
+
+async function clearTsBuildInfo(
+	workspace: string,
+	verbose: boolean,
+): Promise<void> {
+	if (verbose) {
+		console.log(`🧹 Clearing corrupted tsbuildinfo cache for ${workspace}...`);
+	}
+	// Clear both old tsbuildinfo and new tsgo cache
+	await $`find ${workspace} -name '*.tsbuildinfo' -type f -delete`
+		.nothrow()
+		.quiet();
+	await $`find ${workspace} -path '*/.cache/tsbuildinfo.json' -type f -delete`
+		.nothrow()
+		.quiet();
+}
+
+async function countTypeScriptFiles(
+	pkgPath: string,
+	root: string,
+): Promise<number> {
+	let count = 0;
+	const tsGlob = new Glob(`${pkgPath}/**/*.{ts,tsx}`);
+	for await (const _ of tsGlob.scan(root)) {
+		count++;
+	}
+	return count;
+}
+
+function formatErrorOutput(output: string): string {
+	return output
+		.split("\n")
+		.map((line) => {
+			return line
+				.replace(/\.\.\/\.\.\/packages\/modules\//g, "")
+				.replace(/\((\d+),(\d+)\):?/g, ":$1:$2 -");
+		})
+		.join("\n")
+		.trim();
+}
+
+async function runSingleTypecheck(
+	workspace: string,
+	fileCount: number,
+	root: string,
+	verbose: boolean,
+	isRetry = false,
+): Promise<WorkspaceTypecheckResult> {
+	const startTime = performance.now();
+	if (verbose) {
+		console.log(
+			`Running typecheck in ${workspace} (${fileCount} files)${isRetry ? " (retry)" : ""}...`,
+		);
+	}
+
+	const workspacePath = `${root}/${workspace}`;
+	const result = await $`cd ${workspacePath} && bun run typecheck`
+		.nothrow()
+		.quiet();
+	const duration = Number(((performance.now() - startTime) / 1000).toFixed(2));
+	const success = result.exitCode === 0;
+
+	let errorOutput: string | undefined;
+	if (!success) {
+		const stdout = result.stdout.toString().trim();
+		const stderr = result.stderr.toString().trim();
+		const parts = [stdout, stderr].filter(Boolean);
+		errorOutput = parts.length > 0 ? parts.join("\n") : undefined;
+
+		// Check for corrupted cache and retry once
+		if (!isRetry && errorOutput && isCorruptedCacheError(errorOutput)) {
+			await clearTsBuildInfo(workspacePath, verbose);
+			return runSingleTypecheck(workspace, fileCount, root, verbose, true);
+		}
+	}
+
+	return { workspace, duration, success, fileCount, errorOutput };
+}
+
+async function discoverWorkspaces(
+	patterns: string[],
+	root: string,
+): Promise<Workspace[]> {
+	const workspaces: Workspace[] = [];
+
+	for (const pattern of patterns) {
+		const glob = new Glob(`${pattern}/package.json`);
+		for await (const match of glob.scan(root)) {
+			const pkgPath = match.replace("/package.json", "");
+			const pkgJson = await Bun.file(`${root}/${match}`).json();
+			if (pkgJson.scripts?.typecheck) {
+				const fileCount = await countTypeScriptFiles(pkgPath, root);
+				workspaces.push({ path: pkgPath, fileCount });
+			}
+		}
+	}
+
+	// Sort by file count (smallest first for faster feedback)
+	workspaces.sort((a, b) => a.fileCount - b.fileCount);
+
+	return workspaces;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Main Export
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Run TypeScript typechecks across all workspaces that have a `typecheck` script.
+ *
+ * @example
+ * ```typescript
+ * const result = await runWorkspaceTypecheck({ verbose: true })
+ * if (!result.success) {
+ *   console.error('Typecheck failed')
+ *   process.exit(1)
+ * }
+ * ```
+ */
+export async function runWorkspaceTypecheck(
+	options: WorkspaceTypecheckOptions = {},
+): Promise<TypecheckResult> {
+	const {
+		root = process.cwd(),
+		patterns = DEFAULT_PATTERNS,
+		concurrency = DEFAULT_CONCURRENCY,
+		verbose = true,
+	} = options;
+
+	// Discover workspaces
+	const workspaces = await discoverWorkspaces(patterns, root);
+
+	if (workspaces.length === 0) {
+		if (verbose) {
+			console.log("No workspaces with typecheck script found.");
+		}
+		return {
+			success: true,
+			totalDuration: 0,
+			totalFiles: 0,
+			workspaceCount: 0,
+			results: [],
+		};
+	}
+
+	const totalStartTime = performance.now();
+	if (verbose) {
+		console.log(
+			`Running typecheck across ${workspaces.length} workspaces with concurrency limit of ${concurrency}...\n`,
+		);
+	}
+
+	const results: WorkspaceTypecheckResult[] = [];
+	const running = new Set<Promise<void>>();
+
+	for (let i = 0; i < workspaces.length; i++) {
+		const { path, fileCount } = workspaces[i];
+		const promise = runSingleTypecheck(path, fileCount, root, verbose).then(
+			(result) => {
+				results[i] = result;
+				running.delete(promise);
+
+				if (verbose) {
+					const icon = result.success ? "✅" : "❌";
+					const log = result.success ? console.log : console.error;
+					log(
+						`${icon} ${result.workspace} (${result.fileCount} files) ${result.success ? "completed" : "failed"} in ${result.duration.toFixed(2)}s`,
+					);
+					if (!result.success && result.errorOutput) {
+						console.error(`\n${formatErrorOutput(result.errorOutput)}`);
+					}
+				}
+			},
+		);
+
+		running.add(promise);
+
+		if (running.size >= concurrency) {
+			await Promise.race(running);
+		}
+	}
+
+	await Promise.all(running);
+
+	const totalDuration = Number(
+		((performance.now() - totalStartTime) / 1000).toFixed(2),
+	);
+	const totalFiles = workspaces.reduce((sum, w) => sum + w.fileCount, 0);
+	const success = results.every((r) => r.success);
+
+	if (verbose) {
+		if (success) {
+			console.log(
+				`\nAll typecheck checks passed! Total time: ${totalDuration}s (${totalFiles} files)`,
+			);
+		} else {
+			console.error(`\nTypecheck failed. Total time: ${totalDuration}s`);
+		}
+	}
+
+	return {
+		success,
+		totalDuration,
+		totalFiles,
+		workspaceCount: workspaces.length,
+		results,
+	};
+}

package/loader.ts

@@ -0,0 +1,100 @@
+import { createDevEnvironment } from "./environment";
+import type { AppConfig, DevEnvironment, ServiceConfig } from "./types";
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Config Loader
+// ═══════════════════════════════════════════════════════════════════════════
+
+const CONFIG_FILES = [
+	"dev.config.ts",
+	"dev.config.js",
+	"dev-tools.config.ts",
+	"dev-tools.config.js",
+];
+
+let cachedEnv: DevEnvironment<
+	Record<string, ServiceConfig>,
+	Record<string, AppConfig>
+> | null = null;
+
+/**
+ * Load the dev environment from the config file.
+ * Caches the result for subsequent calls.
+ *
+ * @example
+ * ```typescript
+ * import { loadDevEnv } from 'buncargo'
+ *
+ * const env = await loadDevEnv()
+ * console.log(env.ports.postgres)  // 5432 (or offset port)
+ * console.log(env.urls.api)        // http://localhost:3000
+ * ```
+ */
+export async function loadDevEnv(options?: {
+	/** Directory to search for config file. Defaults to process.cwd() */
+	cwd?: string;
+	/** Skip cache and reload config */
+	reload?: boolean;
+}): Promise<
+	DevEnvironment<Record<string, ServiceConfig>, Record<string, AppConfig>>
+> {
+	if (cachedEnv && !options?.reload) {
+		return cachedEnv;
+	}
+
+	const cwd = options?.cwd ?? process.cwd();
+
+	for (const file of CONFIG_FILES) {
+		const path = `${cwd}/${file}`;
+		const exists = await Bun.file(path).exists();
+
+		if (exists) {
+			const mod = await import(path);
+			const config = mod.default;
+
+			if (!config?.projectPrefix || !config?.services) {
+				throw new Error(
+					`Invalid config in "${file}". Use defineDevConfig() and export as default.`,
+				);
+			}
+
+			cachedEnv = createDevEnvironment(config);
+			return cachedEnv;
+		}
+	}
+
+	throw new Error(
+		`No config file found. Create dev.config.ts with: export default defineDevConfig({ ... })`,
+	);
+}
+
+/**
+ * Get the cached dev environment synchronously.
+ * Throws if loadDevEnv() hasn't been called yet.
+ *
+ * @example
+ * ```typescript
+ * // First load async
+ * await loadDevEnv()
+ *
+ * // Then use sync getter anywhere
+ * import { getDevEnv } from 'buncargo'
+ * const env = getDevEnv()
+ * ```
+ */
+export function getDevEnv(): DevEnvironment<
+	Record<string, ServiceConfig>,
+	Record<string, AppConfig>
+> {
+	if (!cachedEnv) {
+		throw new Error("Dev environment not loaded. Call loadDevEnv() first.");
+	}
+	return cachedEnv;
+}
+
+/**
+ * Clear the cached environment.
+ */
+export function clearDevEnvCache(): void {
+	cachedEnv = null;
+}

package/package.json

@@ -0,0 +1,124 @@
+{
+  "name": "buncargo",
+  "version": "1.0.5",
+  "description": "A Bun-powered development environment CLI for managing Docker Compose services, dev servers, and environment variables",
+  "type": "module",
+  "module": "index.ts",
+  "main": "index.ts",
+  "types": "dist/index.d.ts",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/HansKristoffer/buncargo.git"
+  },
+  "author": "Kristoffer Hansen",
+  "keywords": [
+    "bun",
+    "dev-tools",
+    "docker",
+    "docker-compose",
+    "development",
+    "cli",
+    "monorepo",
+    "dev-server",
+    "environment"
+  ],
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "files": [
+    "*.ts",
+    "core/*.ts",
+    "dist",
+    "!*.test.ts",
+    "!core/*.test.ts"
+  ],
+  "bin": {
+    "dev-tools": "bin.ts",
+    "buncargo": "bin.ts"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "bun": "./index.ts",
+      "default": "./index.ts"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "bun": "./types.ts",
+      "default": "./types.ts"
+    },
+    "./config": {
+      "types": "./dist/config.d.ts",
+      "bun": "./config.ts",
+      "default": "./config.ts"
+    },
+    "./environment": {
+      "types": "./dist/environment.d.ts",
+      "bun": "./environment.ts",
+      "default": "./environment.ts"
+    },
+    "./core/ports": {
+      "types": "./dist/core/ports.d.ts",
+      "bun": "./core/ports.ts",
+      "default": "./core/ports.ts"
+    },
+    "./core/docker": {
+      "types": "./dist/core/docker.d.ts",
+      "bun": "./core/docker.ts",
+      "default": "./core/docker.ts"
+    },
+    "./core/network": {
+      "types": "./dist/core/network.d.ts",
+      "bun": "./core/network.ts",
+      "default": "./core/network.ts"
+    },
+    "./core/process": {
+      "types": "./dist/core/process.d.ts",
+      "bun": "./core/process.ts",
+      "default": "./core/process.ts"
+    },
+    "./core/watchdog": {
+      "types": "./dist/core/watchdog.d.ts",
+      "bun": "./core/watchdog.ts",
+      "default": "./core/watchdog.ts"
+    },
+    "./core/utils": {
+      "types": "./dist/core/utils.d.ts",
+      "bun": "./core/utils.ts",
+      "default": "./core/utils.ts"
+    },
+    "./cli": {
+      "types": "./dist/cli.d.ts",
+      "bun": "./cli.ts",
+      "default": "./cli.ts"
+    },
+    "./lint": {
+      "types": "./dist/lint.d.ts",
+      "bun": "./lint.ts",
+      "default": "./lint.ts"
+    },
+    "./loader": {
+      "types": "./dist/loader.d.ts",
+      "bun": "./loader.ts",
+      "default": "./loader.ts"
+    }
+  },
+  "scripts": {
+    "build": "bun run build:types",
+    "build:types": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "bun run build",
+    "lint": "bun run typecheck && biome check",
+    "lint:write": "bun run typecheck && biome check --fix && biome format",
+    "typecheck": "tsgo --incremental"
+  },
+  "devDependencies": {
+    "@types/bun": "1.3.2",
+    "@biomejs/biome": "2.3.4",
+    "@typescript/native-preview": "7.0.0-dev.20260127.1",
+    "typescript": "^5.7.0"
+  },
+  "dependencies": {
+    "picocolors": "^1.1.1"
+  }
+}

package/prisma.ts

@@ -0,0 +1,138 @@
+/**
+ * Prisma integration for dev-tools-v2.
+ *
+ * When `prisma` is configured in defineDevConfig, `dev.prisma` becomes available
+ * with methods to run prisma commands against the Docker development database.
+ *
+ * @example
+ * ```typescript
+ * // In dev.config.ts
+ * const config = defineDevConfig({
+ *   projectPrefix: 'myapp',
+ *   services: { postgres: { port: 5432, healthCheck: 'pg_isready' } },
+ *   prisma: { cwd: 'packages/prisma' }  // Enable prisma integration
+ * })
+ *
+ * // Usage
+ * await dev.prisma.run(['migrate', 'dev'])
+ * await dev.prisma.ensureDatabase()
+ * const url = dev.prisma.getDatabaseUrl()
+ * ```
+ *
+ * @internal This module is used internally by createDevEnvironment.
+ */
+
+import { $ } from "bun";
+import {
+	isContainerRunning,
+	startService,
+	waitForServiceByType,
+} from "./core/docker";
+import type {
+	AppConfig,
+	BuiltInHealthCheck,
+	DevEnvironment,
+	PrismaConfig,
+	PrismaRunner,
+	ServiceConfig,
+} from "./types";
+
+/**
+ * Create a Prisma runner from config (used internally by createDevEnvironment).
+ * @internal
+ */
+export function createPrismaRunner<
+	TServices extends Record<string, ServiceConfig>,
+	TApps extends Record<string, AppConfig>,
+>(env: DevEnvironment<TServices, TApps>, config: PrismaConfig): PrismaRunner {
+	const {
+		cwd = "packages/prisma",
+		service = "postgres",
+		urlEnvVar = "DATABASE_URL",
+	} = config;
+
+	// Map service names to health check types
+	const healthCheckTypes: Record<string, BuiltInHealthCheck> = {
+		postgres: "pg_isready",
+		redis: "redis-cli",
+		clickhouse: "http",
+	};
+
+	function getDatabaseUrl(): string {
+		const envVars = env.buildEnvVars();
+		const url = envVars[urlEnvVar];
+		if (!url) {
+			throw new Error(
+				`Environment variable ${urlEnvVar} not found. Make sure your dev config defines it in envVars.`,
+			);
+		}
+		return url;
+	}
+
+	async function ensureDatabase(): Promise<void> {
+		const alreadyRunning = await isContainerRunning(env.projectName, service);
+
+		if (alreadyRunning) {
+			console.log(`✓ ${service} already running`);
+			return;
+		}
+
+		console.log(`🐳 Starting ${service}...`);
+
+		const envVars = env.buildEnvVars();
+		startService(env.root, env.projectName, service, envVars, {
+			verbose: false,
+		});
+
+		const port = (env.ports as Record<string, number>)[service];
+		if (!port) {
+			throw new Error(`Service ${service} not found in dev environment ports`);
+		}
+
+		// Use the appropriate health check for the service
+		const healthCheckType = healthCheckTypes[service] ?? "tcp";
+		console.log(`⏳ Waiting for ${service} to be healthy...`);
+		await waitForServiceByType(service, healthCheckType, port, {
+			verbose: true,
+		});
+	}
+
+	async function run(args: string[]): Promise<number> {
+		if (args.length === 0) {
+			console.log(`
+Usage: bun prisma <command> [args...]
+
+Examples:
+  bun prisma migrate dev     # Create new migration
+  bun prisma migrate deploy  # Apply migrations
+  bun prisma db push         # Push schema changes
+  bun prisma studio          # Open Prisma Studio
+  bun prisma migrate reset   # Reset database
+`);
+			return 0;
+		}
+
+		const port = (env.ports as Record<string, number>)[service];
+
+		console.log(`
+🔧 Prisma CLI
+   Project: ${env.projectName}
+   Database: localhost:${port}
+   ${env.portOffset > 0 ? `(port offset +${env.portOffset})` : ""}
+`);
+
+		await ensureDatabase();
+
+		const envVars = env.buildEnvVars();
+
+		$.env({ ...process.env, ...envVars, [urlEnvVar]: getDatabaseUrl() });
+		$.cwd(`${env.root}/${cwd}`);
+
+		console.log(`🔄 Running: prisma ${args.join(" ")}\n`);
+
+		const result = await $`bunx prisma ${args}`.nothrow();
+		return result.exitCode;
+	}
+
+	return { run, getDatabaseUrl, ensureDatabase };
+}