hudson 1.0.0

package/.hudson/hudson.yml

@@ -0,0 +1,60 @@
+#####################################################################
+#
+#   ██╗  ██╗██╗   ██╗██████╗ ███████╗ ██████╗ ███╗   ██╗
+#   ██║  ██║██║   ██║██╔══██╗██╔════╝██╔═══██╗████╗  ██║
+#   ███████║██║   ██║██║  ██║███████╗██║   ██║██╔██╗ ██║
+#   ██╔══██║██║   ██║██║  ██║╚════██║██║   ██║██║╚██╗██║
+#   ██║  ██║╚██████╔╝██████╔╝███████║╚██████╔╝██║ ╚████║
+#   ╚═╝  ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝ ╚═════╝ ╚═╝  ╚═══╝
+#
+#   Hudson Build System — v1.0.0
+#   The blazing-fast TypeScript build system
+#
+#   ─────────────────────────────────────────────────────
+#   Configure via CLI (without editing this file):
+#
+#     hudson configure <key> <value>
+#
+#   Examples:
+#     hudson configure build.outDir dist
+#     hudson configure output.verbose true
+#     hudson configure packageManager pnpm
+#
+#   ─────────────────────────────────────────────────────
+#   Docs: https://github.com/hudson-build/hudson
+#
+#####################################################################
+
+project:
+  name: hudson
+  version: 1.0.0
+  description: A Hudson-managed project
+build:
+  outDir: dist
+  tsconfig: tsconfig.json
+  sourcemap: true
+  minify: false
+  target: ES2022
+  clean: true
+workspaces:
+  enabled: false
+  packages:
+    - packages/*
+  parallel: true
+  maxConcurrency: 4
+dev:
+  watch: true
+  open: false
+scripts:
+  build: tsc
+  dev: tsc --watch
+  test: node --test
+  lint: eslint .
+  clean: rm -rf dist
+hooks: {}
+packageManager: pnpm
+output:
+  verbose: false
+  timestamps: true
+  color: true
+  banner: true

package/README.md

@@ -0,0 +1,163 @@
+# 🎣 Hudson
+
+**Hudson** is a blazing-fast, beginner-friendly TypeScript build system with first-class workspace support.
+
+```
+  ██╗  ██╗██╗   ██╗██████╗ ███████╗ ██████╗ ███╗   ██╗
+  ██║  ██║██║   ██║██╔══██╗██╔════╝██╔═══██╗████╗  ██║
+  ███████║██║   ██║██║  ██║███████╗██║   ██║██╔██╗ ██║
+  ██╔══██║██║   ██║██║  ██║╚════██║██║   ██║██║╚██╗██║
+  ██║  ██║╚██████╔╝██████╔╝███████║╚██████╔╝██║ ╚████║
+  ╚═╝  ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝ ╚═════╝ ╚═╝  ╚═══╝
+```
+
+## Features
+
+- ⚡ **Blazing fast** — parallel workspace builds, smart caching
+- 🏗️ **Workspace support** — monorepo-ready with topological sort
+- ⚙️ **Fully configurable** — YAML config with CLI configuration
+- 👀 **Dev mode** — file watching with instant rebuilds
+- 🎨 **Beautiful output** — modern, colorful, informative terminal output
+- 📦 **PNPM/Yarn first** — built for modern package managers
+
+## Installation
+
+```bash
+pnpm add -g hudson
+# or
+yarn global add hudson
+```
+
+## Quick Start
+
+```bash
+# Initialize Hudson in your project
+hudson init
+
+# Build your project
+hudson build
+
+# Start dev mode
+hudson dev
+
+# Run a script
+hudson run test
+
+# Configure a setting
+hudson configure build.outDir dist
+```
+
+## Configuration
+
+Hudson uses `.hudson/hudson.yml` for configuration. You can edit it directly or use the CLI:
+
+```bash
+# List all config values
+hudson configure --list
+
+# Set a value
+hudson configure build.outDir lib
+hudson configure output.verbose true
+hudson configure workspaces.enabled true
+hudson configure packageManager pnpm
+
+# Get a value
+hudson configure --get build.outDir
+```
+
+## Config File
+
+Located at `.hudson/hudson.yml`:
+
+```yaml
+project:
+  name: my-project
+  version: 1.0.0
+
+build:
+  outDir: dist
+  tsconfig: tsconfig.json
+  sourcemap: true
+  clean: true
+
+workspaces:
+  enabled: false
+  packages:
+    - packages/*
+  parallel: true
+  maxConcurrency: 4
+
+scripts:
+  build: tsc
+  dev: tsc --watch
+  test: node --test
+  lint: eslint .
+  clean: rm -rf dist
+
+hooks:
+  preBuild: ""
+  postBuild: ""
+
+packageManager: pnpm
+
+output:
+  verbose: false
+  timestamps: true
+  color: true
+  banner: true
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `hudson init` | Initialize Hudson in the current directory |
+| `hudson build` | Build the project |
+| `hudson build --watch` | Build and watch for changes |
+| `hudson build -w <name>` | Build a specific workspace |
+| `hudson dev` | Start dev mode with file watching |
+| `hudson run <script>` | Run a script from config |
+| `hudson run <script> --all` | Run script in all workspaces |
+| `hudson configure <key> <value>` | Set a config value |
+| `hudson configure --list` | List all config values |
+| `hudson info` | Show project info |
+| `hudson ws list` | List all workspaces |
+
+## Workspaces
+
+Hudson supports monorepo workspaces with automatic dependency detection and topological sorting.
+
+```yaml
+workspaces:
+  enabled: true
+  packages:
+    - packages/*
+    - apps/*
+  parallel: true
+  maxConcurrency: 4
+```
+
+```bash
+# Build all workspaces in dependency order
+hudson build
+
+# Build a specific workspace
+hudson build -w my-package
+
+# Run a script in all workspaces
+hudson run test --all
+```
+
+## Hooks
+
+Run custom commands before or after builds:
+
+```yaml
+hooks:
+  preBuild: pnpm lint
+  postBuild: pnpm test
+```
+
+## License
+
+MIT

package/example/.hudson/hudson.yml

@@ -0,0 +1,60 @@
+#####################################################################
+#
+#   ██╗  ██╗██╗   ██╗██████╗ ███████╗ ██████╗ ███╗   ██╗
+#   ██║  ██║██║   ██║██╔══██╗██╔════╝██╔═══██╗████╗  ██║
+#   ███████║██║   ██║██║  ██║███████╗██║   ██║██╔██╗ ██║
+#   ██╔══██║██║   ██║██║  ██║╚════██║██║   ██║██║╚██╗██║
+#   ██║  ██║╚██████╔╝██████╔╝███████║╚██████╔╝██║ ╚████║
+#   ╚═╝  ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝ ╚═════╝ ╚═╝  ╚═══╝
+#
+#   Hudson Build System — v1.0.0
+#   The blazing-fast TypeScript build system
+#
+#   ─────────────────────────────────────────────────────
+#   Configure via CLI (without editing this file):
+#
+#     hudson configure <key> <value>
+#
+#   Examples:
+#     hudson configure build.outDir dist
+#     hudson configure output.verbose true
+#     hudson configure packageManager pnpm
+#
+#   ─────────────────────────────────────────────────────
+#   Docs: https://github.com/hudson-build/hudson
+#
+#####################################################################
+
+project:
+  name: example
+  version: 1.0.0
+  description: A Hudson-managed project
+build:
+  outDir: dist
+  tsconfig: tsconfig.json
+  sourcemap: true
+  minify: false
+  target: ES2022
+  clean: true
+workspaces:
+  enabled: false
+  packages:
+    "0": packages/*
+  parallel: true
+  maxConcurrency: 4
+dev:
+  watch: true
+  open: false
+scripts:
+  build: tsc
+  dev: tsc --watch
+  test: node --test
+  lint: eslint .
+  clean: rm -rf dist
+hooks: {}
+packageManager: pnpm
+output:
+  verbose: false
+  timestamps: true
+  color: true
+  banner: true

package/example/src/index.ts

@@ -0,0 +1 @@
+console.log("hey!")

package/example/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "allowImportingTsExtensions": false,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "hudson",
+  "version": "1.0.0",
+  "description": "A blazing fast TypeScript build system",
+  "type": "module",
+  "bin": {
+    "hudson": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "chokidar": "^3.5.3",
+    "commander": "^11.1.0",
+    "execa": "^8.0.1",
+    "fast-glob": "^3.3.2",
+    "js-yaml": "^4.1.0",
+    "ora": "^7.0.1",
+    "boxen": "^7.1.1",
+    "figures": "^6.0.1",
+    "gradient-string": "^2.0.2",
+    "ansi-escapes": "^6.2.0"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^20.10.0",
+    "typescript": "^5.3.2"
+  }
+}

package/src/commands/build.ts

@@ -0,0 +1,187 @@
+import fs from "fs";
+import path from "path";
+import ora from "ora";
+import chalk from "chalk";
+import { loadConfig, HudsonConfig } from "../core/config.js";
+import { runCommand, runHook } from "../core/runner.js";
+import { discoverWorkspaces, topologicalSort, Workspace } from "../core/workspace.js";
+import { log, formatDuration, symbols, BANNER } from "../utils/display.js";
+
+interface BuildOptions {
+  workspace?: string;
+  verbose?: boolean;
+  clean?: boolean;
+  watch?: boolean;
+}
+
+export async function buildCommand(options: BuildOptions = {}): Promise<void> {
+  const cwd = process.cwd();
+  const config = loadConfig(cwd);
+  const verbose = options.verbose ?? config.output.verbose;
+
+  if (config.output.banner) {
+    console.log(BANNER());
+  }
+
+  log.section("Build");
+
+  const start = Date.now();
+
+  // Pre-build hook
+  if (config.hooks.preBuild) {
+    const ok = await runHook("preBuild", config, cwd);
+    if (!ok) {
+      log.error("Pre-build hook failed");
+      process.exit(1);
+    }
+  }
+
+  // Clean output directory
+  const shouldClean = options.clean ?? config.build.clean;
+  if (shouldClean) {
+    const outDir = path.join(cwd, config.build.outDir);
+    if (fs.existsSync(outDir)) {
+      const spinner = ora({ text: chalk.dim("Cleaning output directory..."), prefixText: "  " }).start();
+      fs.rmSync(outDir, { recursive: true, force: true });
+      spinner.succeed(chalk.dim("Cleaned " + chalk.cyan(config.build.outDir)));
+    }
+  }
+
+  if (config.workspaces.enabled && !options.workspace) {
+    await buildWorkspaces(config, cwd, verbose);
+  } else if (options.workspace) {
+    const workspaces = await discoverWorkspaces(config, cwd);
+    const ws = workspaces.find((w) => w.name === options.workspace);
+    if (!ws) {
+      log.error(`Workspace '${options.workspace}' not found`);
+      process.exit(1);
+    }
+    await buildSingleWorkspace(ws, config, verbose);
+  } else {
+    await buildProject(config, cwd, verbose, options.watch);
+  }
+
+  // Post-build hook
+  if (config.hooks.postBuild) {
+    await runHook("postBuild", config, cwd);
+  }
+
+  const duration = Date.now() - start;
+  log.blank();
+  log.success(
+    `Build complete ${chalk.dim("in")} ${chalk.cyan(formatDuration(duration))}`
+  );
+  log.blank();
+}
+
+async function buildProject(
+  config: HudsonConfig,
+  cwd: string,
+  verbose: boolean,
+  watch = false
+): Promise<void> {
+  const tsconfig = path.join(cwd, config.build.tsconfig);
+
+  if (!fs.existsSync(tsconfig)) {
+    log.error(`tsconfig not found: ${config.build.tsconfig}`);
+    process.exit(1);
+  }
+
+  const args = ["-p", config.build.tsconfig];
+  if (watch) args.push("--watch");
+  if (config.build.sourcemap) args.push("--sourceMap");
+
+  const spinner = ora({
+    text: watch ? chalk.dim("Watching for changes...") : chalk.dim("Compiling TypeScript..."),
+    prefixText: "  ",
+  }).start();
+
+  const result = await runCommand("tsc", args, { cwd, verbose });
+
+  if (result.exitCode === 0) {
+    spinner.succeed(chalk.white("TypeScript compiled") + chalk.dim(`  ${formatDuration(result.duration)}`));
+    if (verbose && result.stdout) {
+      result.stdout.split("\n").filter(Boolean).forEach((l) => log.dim(l));
+    }
+  } else {
+    spinner.fail(chalk.red("TypeScript compilation failed"));
+    if (result.stderr) {
+      log.blank();
+      result.stderr.split("\n").filter(Boolean).forEach((l) => {
+        console.log(`  ${chalk.red(l)}`);
+      });
+    }
+    process.exit(1);
+  }
+}
+
+async function buildWorkspaces(
+  config: HudsonConfig,
+  cwd: string,
+  verbose: boolean
+): Promise<void> {
+  const workspaces = await discoverWorkspaces(config, cwd);
+
+  if (workspaces.length === 0) {
+    log.warn("No workspaces found. Check your workspaces.packages config.");
+    return;
+  }
+
+  const sorted = topologicalSort(workspaces);
+  log.step(`Found ${chalk.cyan(sorted.length)} workspace${sorted.length !== 1 ? "s" : ""}`);
+  log.blank();
+
+  if (config.workspaces.parallel) {
+    const chunks: Workspace[][] = [];
+    const batchSize = config.workspaces.maxConcurrency;
+
+    for (let i = 0; i < sorted.length; i += batchSize) {
+      chunks.push(sorted.slice(i, i + batchSize));
+    }
+
+    for (const chunk of chunks) {
+      await Promise.all(chunk.map((ws) => buildSingleWorkspace(ws, config, verbose)));
+    }
+  } else {
+    for (const ws of sorted) {
+      await buildSingleWorkspace(ws, config, verbose);
+    }
+  }
+}
+
+async function buildSingleWorkspace(
+  ws: Workspace,
+  config: HudsonConfig,
+  verbose: boolean
+): Promise<void> {
+  const buildScript = ws.scripts["build"];
+
+  if (!buildScript) {
+    log.warn(`  ${chalk.cyan(ws.name)} has no build script, skipping`);
+    return;
+  }
+
+  const spinner = ora({
+    text: chalk.dim(`Building ${chalk.cyan(ws.name)}...`),
+    prefixText: "  ",
+  }).start();
+
+  const parts = buildScript.split(" ");
+  const result = await runCommand(parts[0], parts.slice(1), {
+    cwd: ws.path,
+    verbose,
+  });
+
+  if (result.exitCode === 0) {
+    spinner.succeed(
+      `${chalk.cyan(ws.name)} ${chalk.dim("built")} ${chalk.dim(formatDuration(result.duration))}`
+    );
+  } else {
+    spinner.fail(`${chalk.red(ws.name)} ${chalk.red("failed")}`);
+    if (result.stderr) {
+      result.stderr.split("\n").filter(Boolean).forEach((l) => {
+        console.log(`    ${chalk.dim(l)}`);
+      });
+    }
+  }
+}

package/src/commands/configure.ts

@@ -0,0 +1,85 @@
+import chalk from "chalk";
+import { loadConfig, setConfigValue, getConfigValue, saveConfig } from "../core/config.js";
+import { log } from "../utils/display.js";
+
+export async function configureCommand(
+  key?: string,
+  value?: string,
+  options: { list?: boolean; reset?: boolean; get?: string } = {}
+): Promise<void> {
+  const cwd = process.cwd();
+
+  if (options.list) {
+    await listConfig(cwd);
+    return;
+  }
+
+  if (options.reset) {
+    const { DEFAULT_CONFIG } = await import("../core/config.js");
+    saveConfig(DEFAULT_CONFIG, cwd);
+    log.success("Config reset to defaults");
+    return;
+  }
+
+  if (options.get) {
+    const val = getConfigValue(options.get, cwd);
+    if (val === undefined) {
+      log.error(`Config key '${options.get}' not found`);
+      process.exit(1);
+    }
+    console.log(`  ${chalk.cyan(options.get)} ${chalk.dim("=")} ${chalk.white(String(val))}`);
+    return;
+  }
+
+  if (!key || value === undefined) {
+    log.error("Usage: hudson configure <key> <value>");
+    log.dim("Example: hudson configure build.outDir dist");
+    log.dim("         hudson configure output.verbose true");
+    log.dim("         hudson configure packageManager pnpm");
+    log.blank();
+    log.step(`List all keys: ${chalk.cyan("hudson configure --list")}`);
+    process.exit(1);
+  }
+
+  setConfigValue(key, value, cwd);
+  log.success(`Set ${chalk.cyan(key)} ${chalk.dim("→")} ${chalk.white(value)}`);
+}
+
+async function listConfig(cwd: string): Promise<void> {
+  const config = loadConfig(cwd);
+
+  log.section("Configuration");
+  printObject(config, "", 0);
+  log.blank();
+  log.dim(`Config file: ${chalk.cyan(".hudson/hudson.yml")}`);
+}
+
+function printObject(obj: unknown, prefix: string, depth: number): void {
+  if (typeof obj !== "object" || obj === null) return;
+
+  const indent = "  ".repeat(depth + 1);
+
+  for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      console.log(`${indent}${chalk.dim(key + ":")}`);
+      printObject(value, fullKey, depth + 1);
+    } else if (Array.isArray(value)) {
+      console.log(
+        `${indent}${chalk.hex("#4FC3F7")(fullKey)}  ${chalk.dim("=")}  ${chalk.yellow(JSON.stringify(value))}`
+      );
+    } else {
+      const displayValue =
+        typeof value === "boolean"
+          ? value
+            ? chalk.green(String(value))
+            : chalk.red(String(value))
+          : chalk.white(String(value));
+
+      console.log(
+        `${indent}${chalk.hex("#4FC3F7")(fullKey)}  ${chalk.dim("=")}  ${displayValue}`
+      );
+    }
+  }
+}