hudson 1.0.0

package/src/core/runner.ts

@@ -0,0 +1,108 @@
+import { execa, ExecaError } from "execa";
+import { HudsonConfig } from "./config.js";
+import { log, formatDuration } from "../utils/display.js";
+import chalk from "chalk";
+
+export interface RunResult {
+  exitCode: number;
+  duration: number;
+  stdout: string;
+  stderr: string;
+}
+
+export async function runCommand(
+  cmd: string,
+  args: string[],
+  options: {
+    cwd?: string;
+    env?: Record<string, string>;
+    verbose?: boolean;
+    label?: string;
+  } = {}
+): Promise<RunResult> {
+  const start = Date.now();
+  const label = options.label ?? `${cmd} ${args.join(" ")}`;
+
+  try {
+    const result = await execa(cmd, args, {
+      cwd: options.cwd ?? process.cwd(),
+      env: { ...process.env, ...options.env },
+      all: true,
+    });
+
+    const duration = Date.now() - start;
+
+    if (options.verbose && result.all) {
+      result.all.split("\n").forEach((line) => {
+        if (line.trim()) console.log(`     ${chalk.dim(line)}`);
+      });
+    }
+
+    return {
+      exitCode: 0,
+      duration,
+      stdout: result.stdout,
+      stderr: result.stderr,
+    };
+  } catch (err) {
+    const duration = Date.now() - start;
+    const execaErr = err as ExecaError;
+
+    if (options.verbose && execaErr.all) {
+      execaErr.all.split("\n").forEach((line) => {
+        if (line.trim()) console.log(`     ${chalk.dim(line)}`);
+      });
+    }
+
+    return {
+      exitCode: execaErr.exitCode ?? 1,
+      duration,
+      stdout: execaErr.stdout ?? "",
+      stderr: execaErr.stderr ?? "",
+    };
+  }
+}
+
+export async function runScript(
+  scriptName: string,
+  config: HudsonConfig,
+  options: { cwd?: string; verbose?: boolean } = {}
+): Promise<RunResult> {
+  const script = config.scripts[scriptName];
+  if (!script) {
+    return { exitCode: 1, duration: 0, stdout: "", stderr: `Script '${scriptName}' not found` };
+  }
+
+  const pm = config.packageManager;
+  const parts = script.split(" ");
+  const cmd = parts[0];
+  const args = parts.slice(1);
+
+  return runCommand(cmd, args, {
+    cwd: options.cwd ?? process.cwd(),
+    verbose: options.verbose ?? config.output.verbose,
+    label: script,
+  });
+}
+
+export async function runHook(
+  hookName: keyof HudsonConfig["hooks"],
+  config: HudsonConfig,
+  cwd = process.cwd()
+): Promise<boolean> {
+  const hook = config.hooks[hookName];
+  if (!hook) return true;
+
+  log.step(`Running hook: ${hookName}`);
+  const parts = hook.split(" ");
+  const result = await runCommand(parts[0], parts.slice(1), {
+    cwd,
+    verbose: config.output.verbose,
+  });
+
+  return result.exitCode === 0;
+}
+
+export function getPackageManager(config: HudsonConfig): string {
+  return config.packageManager;
+}

package/src/core/workspace.ts

@@ -0,0 +1,65 @@
+import fs from "fs";
+import path from "path";
+import glob from "fast-glob";
+import { HudsonConfig } from "./config.js";
+
+export interface Workspace {
+  name: string;
+  path: string;
+  version: string;
+  scripts: Record<string, string>;
+  dependencies: Record<string, string>;
+  devDependencies: Record<string, string>;
+}
+
+export async function discoverWorkspaces(
+  config: HudsonConfig,
+  cwd = process.cwd()
+): Promise<Workspace[]> {
+  if (!config.workspaces.enabled) return [];
+
+  const patterns = config.workspaces.packages.map((p) => path.join(cwd, p, "package.json"));
+  const packageFiles = await glob(patterns, { absolute: true });
+
+  const workspaces: Workspace[] = [];
+
+  for (const pkgFile of packageFiles) {
+    if (!fs.existsSync(pkgFile)) continue;
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgFile, "utf-8"));
+      workspaces.push({
+        name: pkg.name || path.basename(path.dirname(pkgFile)),
+        path: path.dirname(pkgFile),
+        version: pkg.version || "0.0.0",
+        scripts: pkg.scripts || {},
+        dependencies: pkg.dependencies || {},
+        devDependencies: pkg.devDependencies || {},
+      });
+    } catch {
+      // skip invalid package.json
+    }
+  }
+
+  return workspaces;
+}
+
+export function topologicalSort(workspaces: Workspace[]): Workspace[] {
+  const nameToWs = new Map(workspaces.map((w) => [w.name, w]));
+  const visited = new Set<string>();
+  const sorted: Workspace[] = [];
+
+  function visit(ws: Workspace) {
+    if (visited.has(ws.name)) return;
+    visited.add(ws.name);
+
+    const allDeps = { ...ws.dependencies, ...ws.devDependencies };
+    for (const dep of Object.keys(allDeps)) {
+      if (nameToWs.has(dep)) visit(nameToWs.get(dep)!);
+    }
+
+    sorted.push(ws);
+  }
+
+  for (const ws of workspaces) visit(ws);
+  return sorted;
+}

package/src/index.ts

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+import { program } from "commander";
+import chalk from "chalk";
+import { HUDSON_VERSION, BANNER, log, symbols } from "./utils/display.js";
+import { initCommand } from "./commands/init.js";
+import { buildCommand } from "./commands/build.js";
+import { devCommand } from "./commands/dev.js";
+import { runScriptCommand } from "./commands/run.js";
+import { configureCommand } from "./commands/configure.js";
+import { infoCommand } from "./commands/info.js";
+import { workspacesCommand } from "./commands/workspaces.js";
+
+program
+  .name("hudson")
+  .description("Hudson — The blazing-fast TypeScript build system")
+  .version(HUDSON_VERSION, "-v, --version", "Show Hudson version")
+  .addHelpText("beforeAll", BANNER());
+
+program
+  .command("init")
+  .description("Initialize Hudson in the current project")
+  .option("-f, --force", "Reinitialize even if already set up")
+  .action(async (opts) => {
+    await initCommand({ force: opts.force });
+  });
+
+program
+  .command("build")
+  .description("Build the project or workspace(s)")
+  .option("-w, --workspace <name>", "Build a specific workspace")
+  .option("--verbose", "Show detailed output")
+  .option("--no-clean", "Skip cleaning the output directory")
+  .option("--watch", "Watch for changes and rebuild")
+  .action(async (opts) => {
+    await buildCommand({
+      workspace: opts.workspace,
+      verbose: opts.verbose,
+      clean: opts.clean !== false,
+      watch: opts.watch,
+    });
+  });
+
+program
+  .command("dev")
+  .description("Start development mode with file watching")
+  .option("--verbose", "Show detailed output")
+  .action(async (opts) => {
+    await devCommand({ verbose: opts.verbose });
+  });
+
+program
+  .command("run <script>")
+  .description("Run a script defined in .hudson/hudson.yml")
+  .option("-w, --workspace <name>", "Run in a specific workspace")
+  .option("--all", "Run in all workspaces")
+  .option("--verbose", "Show detailed output")
+  .action(async (script, opts) => {
+    await runScriptCommand(script, {
+      workspace: opts.workspace,
+      all: opts.all,
+      verbose: opts.verbose,
+    });
+  });
+
+program
+  .command("configure [key] [value]")
+  .description("Get or set a config value")
+  .option("-l, --list", "List all config values")
+  .option("-g, --get <key>", "Get a specific config value")
+  .option("--reset", "Reset config to defaults")
+  .action(async (key, value, opts) => {
+    await configureCommand(key, value, {
+      list: opts.list,
+      get: opts.get,
+      reset: opts.reset,
+    });
+  });
+
+program
+  .command("info")
+  .description("Show project information and configuration")
+  .action(async () => {
+    await infoCommand();
+  });
+
+program
+  .command("workspaces [subcommand]")
+  .alias("ws")
+  .description("Manage workspaces (subcommands: list)")
+  .action(async (sub) => {
+    await workspacesCommand(sub);
+  });
+
+// Custom help formatting
+program.configureOutput({
+  writeErr: (str) => {
+    console.log(`  ${chalk.red("✘")}  ${str.trim()}`);
+  },
+});
+
+// Handle unknown commands
+program.on("command:*", (ops) => {
+  console.log(BANNER());
+  log.error(`Unknown command: ${chalk.cyan(ops[0])}`);
+  log.blank();
+  log.step("Available commands:");
+  console.log(`  ${chalk.cyan("hudson init")}            Initialize Hudson in a project`);
+  console.log(`  ${chalk.cyan("hudson build")}           Build the project`);
+  console.log(`  ${chalk.cyan("hudson dev")}             Start dev mode with file watching`);
+  console.log(`  ${chalk.cyan("hudson run <script>")}    Run a project script`);
+  console.log(`  ${chalk.cyan("hudson configure")}       Get/set configuration values`);
+  console.log(`  ${chalk.cyan("hudson info")}            Show project information`);
+  console.log(`  ${chalk.cyan("hudson workspaces")}      Manage workspaces`);
+  log.blank();
+  process.exit(1);
+});
+
+program.parse(process.argv);
+
+// Show help if no command given
+if (!process.argv.slice(2).length) {
+  console.log(BANNER());
+  console.log(`  ${chalk.bold("Hudson")} — The blazing-fast TypeScript build system`);
+  log.blank();
+  console.log(`  ${chalk.dim("Usage:")}  ${chalk.cyan("hudson <command> [options]")}`);
+  log.blank();
+  console.log(`  ${chalk.dim("Commands:")}`);
+  console.log(`    ${chalk.cyan("init")}            Initialize Hudson in a project`);
+  console.log(`    ${chalk.cyan("build")}           Build the project`);
+  console.log(`    ${chalk.cyan("dev")}             Start dev mode with file watching`);
+  console.log(`    ${chalk.cyan("run <script>")}    Run a project script`);
+  console.log(`    ${chalk.cyan("configure")}       Get/set configuration values`);
+  console.log(`    ${chalk.cyan("info")}            Show project information`);
+  console.log(`    ${chalk.cyan("ws")}              Manage workspaces`);
+  log.blank();
+  console.log(`  ${chalk.dim("Run")} ${chalk.cyan("hudson <command> --help")} ${chalk.dim("for command details")}`);
+  log.blank();
+}

package/src/types/gradient-string.d.ts

@@ -0,0 +1,4 @@
+declare module 'gradient-string' {
+  function gradient(colors: string[]): (text: string) => string;
+  export default gradient;
+}

package/src/utils/display.ts

@@ -0,0 +1,66 @@
+import chalk from "chalk";
+import gradient from "gradient-string";
+
+export const HUDSON_VERSION = "1.0.0";
+
+// Hudson mascot - fishing on a lake (ASCII art)
+export const MASCOT = `
+  ${chalk.hex("#4FC3F7")("~")}  ${chalk.hex("#FFB74D")("Hudson")}  ${chalk.hex("#4FC3F7")("~")}
+${chalk.hex("#81C784")("  🎣")}
+${chalk.hex("#4FC3F7")("  ≋≋≋≋≋≋≋≋≋")}
+`;
+
+export const MASCOT_FULL = `
+    ${chalk.hex("#FFD54F")("( •_•)")}         ${chalk.dim("Hudson Build System")}
+    ${chalk.hex("#FFD54F")("( >🎣")}           ${chalk.dim("v" + HUDSON_VERSION)}
+    ${chalk.hex("#FFD54F")("/ >")}
+  ${chalk.hex("#4FC3F7")("━━━━━━━━━━━━━━━")}
+  ${chalk.hex("#4FC3F7")("≋ ≋ ≋ ≋ ≋ ≋ ≋ ≋")}
+  ${chalk.hex("#1565C0")("~ ~ ~ ~ ~ ~ ~ ~")}
+`;
+
+export const BANNER = () => {
+  const title = gradient(["#4FC3F7", "#81C784", "#FFD54F"])("  HUDSON");
+  return `
+${title}  ${chalk.dim(`v${HUDSON_VERSION}`)}  ${chalk.hex("#4FC3F7")("⛵")}
+${chalk.hex("#4FC3F7")("  ──────────────────────────────")}
+`;
+};
+
+export const symbols = {
+  success: chalk.green("✔"),
+  error: chalk.red("✘"),
+  warning: chalk.yellow("⚠"),
+  info: chalk.cyan("ℹ"),
+  arrow: chalk.dim("→"),
+  dot: chalk.dim("·"),
+  bullet: chalk.cyan("◆"),
+  fish: "🐟",
+  hook: "🎣",
+};
+
+export const log = {
+  success: (msg: string) => console.log(`  ${symbols.success}  ${chalk.green(msg)}`),
+  error: (msg: string) => console.log(`  ${symbols.error}  ${chalk.red(msg)}`),
+  warn: (msg: string) => console.log(`  ${symbols.warning}  ${chalk.yellow(msg)}`),
+  info: (msg: string) => console.log(`  ${symbols.info}  ${chalk.cyan(msg)}`),
+  step: (msg: string) => console.log(`  ${symbols.arrow}  ${chalk.white(msg)}`),
+  dim: (msg: string) => console.log(`  ${chalk.dim(msg)}`),
+  blank: () => console.log(),
+  section: (title: string) => {
+    console.log();
+    console.log(`  ${chalk.bold.hex("#FFD54F")(title)}`);
+    console.log(`  ${chalk.dim("─".repeat(40))}`);
+  },
+};
+
+export function formatDuration(ms: number): string {
+  if (ms < 1000) return `${ms}ms`;
+  return `${(ms / 1000).toFixed(2)}s`;
+}
+
+export function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(2)}MB`;
+}

package/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"]
+}