hudson 1.0.0

package/src/commands/dev.ts

@@ -0,0 +1,114 @@
+import chalk from "chalk";
+import chokidar from "chokidar";
+import { loadConfig } from "../core/config.js";
+import { runCommand } from "../core/runner.js";
+import { log, BANNER, formatDuration } from "../utils/display.js";
+import ora from "ora";
+
+interface DevOptions {
+  verbose?: boolean;
+}
+
+export async function devCommand(options: DevOptions = {}): 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("Dev Mode");
+  log.step(`Watching ${chalk.cyan("src/**/*.ts")} for changes...`);
+  log.dim("Press Ctrl+C to stop");
+  log.blank();
+
+  let building = false;
+  let queued = false;
+
+  async function build() {
+    if (building) {
+      queued = true;
+      return;
+    }
+
+    building = true;
+    const start = Date.now();
+
+    const spinner = ora({
+      text: chalk.dim("Compiling..."),
+      prefixText: "  ",
+    }).start();
+
+    const result = await runCommand("tsc", ["-p", config.build.tsconfig, "--noEmitOnError"], {
+      cwd,
+      verbose,
+    });
+
+    const duration = Date.now() - start;
+
+    if (result.exitCode === 0) {
+      const time = new Date().toLocaleTimeString("en-US", { hour12: false });
+      spinner.succeed(
+        `${chalk.dim(time)} Compiled ${chalk.dim("in")} ${chalk.cyan(formatDuration(duration))}`
+      );
+    } else {
+      const time = new Date().toLocaleTimeString("en-US", { hour12: false });
+      spinner.fail(`${chalk.dim(time)} ${chalk.red("Compile error")}`);
+
+      if (result.stderr) {
+        log.blank();
+        result.stderr
+          .split("\n")
+          .filter(Boolean)
+          .slice(0, 10)
+          .forEach((l) => {
+            console.log(`  ${chalk.red("·")} ${chalk.dim(l)}`);
+          });
+        log.blank();
+      }
+    }
+
+    building = false;
+
+    if (queued) {
+      queued = false;
+      await build();
+    }
+  }
+
+  // Initial build
+  await build();
+
+  // Watch for changes
+  const watcher = chokidar.watch("src/**/*.ts", {
+    cwd,
+    ignoreInitial: true,
+    persistent: true,
+  });
+
+  watcher.on("change", (file) => {
+    log.step(`Changed: ${chalk.cyan(file)}`);
+    build();
+  });
+
+  watcher.on("add", (file) => {
+    log.step(`Added: ${chalk.cyan(file)}`);
+    build();
+  });
+
+  watcher.on("unlink", (file) => {
+    log.step(`Removed: ${chalk.cyan(file)}`);
+    build();
+  });
+
+  process.on("SIGINT", () => {
+    log.blank();
+    log.info("Stopping dev mode...");
+    watcher.close();
+    process.exit(0);
+  });
+
+  // Keep alive
+  await new Promise(() => {});
+}

package/src/commands/info.ts

@@ -0,0 +1,78 @@
+import fs from "fs";
+import path from "path";
+import chalk from "chalk";
+import { loadConfig, getConfigPath, getHudsonDir } from "../core/config.js";
+import { discoverWorkspaces } from "../core/workspace.js";
+import { log, MASCOT_FULL, BANNER } from "../utils/display.js";
+
+export async function infoCommand(): Promise<void> {
+  const cwd = process.cwd();
+  const config = loadConfig(cwd);
+
+  console.log(BANNER());
+  console.log(MASCOT_FULL);
+
+  log.section("Project");
+  console.log(`  ${chalk.dim("Name")}         ${chalk.white(config.project.name)}`);
+  console.log(`  ${chalk.dim("Version")}      ${chalk.cyan(config.project.version)}`);
+  if (config.project.description) {
+    console.log(`  ${chalk.dim("Description")} ${chalk.dim(config.project.description)}`);
+  }
+  console.log(`  ${chalk.dim("Pkg Manager")} ${chalk.cyan(config.packageManager)}`);
+
+  log.section("Build");
+  console.log(`  ${chalk.dim("Output Dir")}  ${chalk.cyan(config.build.outDir)}`);
+  console.log(`  ${chalk.dim("tsconfig")}    ${chalk.cyan(config.build.tsconfig)}`);
+  console.log(`  ${chalk.dim("Target")}      ${chalk.cyan(config.build.target)}`);
+  console.log(`  ${chalk.dim("Sourcemap")}   ${boolDisplay(config.build.sourcemap)}`);
+  console.log(`  ${chalk.dim("Minify")}      ${boolDisplay(config.build.minify)}`);
+  console.log(`  ${chalk.dim("Clean")}       ${boolDisplay(config.build.clean)}`);
+
+  if (config.workspaces.enabled) {
+    log.section("Workspaces");
+    const workspaces = await discoverWorkspaces(config, cwd);
+    console.log(`  ${chalk.dim("Packages")}    ${chalk.cyan(workspaces.length)} found`);
+    console.log(`  ${chalk.dim("Parallel")}    ${boolDisplay(config.workspaces.parallel)}`);
+    console.log(`  ${chalk.dim("Concurrency")} ${chalk.cyan(config.workspaces.maxConcurrency)}`);
+
+    if (workspaces.length > 0) {
+      log.blank();
+      workspaces.forEach((ws) => {
+        const hasTs = fs.existsSync(path.join(ws.path, "tsconfig.json"));
+        console.log(
+          `    ${chalk.dim("·")} ${chalk.cyan(ws.name)} ${chalk.dim("v" + ws.version)} ${hasTs ? chalk.green("[ts]") : ""}`
+        );
+      });
+    }
+  }
+
+  if (Object.keys(config.scripts).length > 0) {
+    log.section("Scripts");
+    for (const [name, script] of Object.entries(config.scripts)) {
+      console.log(`  ${chalk.cyan(name.padEnd(12))} ${chalk.dim(script)}`);
+    }
+  }
+
+  if (Object.values(config.hooks).some(Boolean)) {
+    log.section("Hooks");
+    for (const [name, hook] of Object.entries(config.hooks)) {
+      if (hook) {
+        console.log(`  ${chalk.cyan(name.padEnd(12))} ${chalk.dim(hook)}`);
+      }
+    }
+  }
+
+  log.section("Output Settings");
+  console.log(`  ${chalk.dim("Verbose")}     ${boolDisplay(config.output.verbose)}`);
+  console.log(`  ${chalk.dim("Timestamps")} ${boolDisplay(config.output.timestamps)}`);
+  console.log(`  ${chalk.dim("Color")}       ${boolDisplay(config.output.color)}`);
+  console.log(`  ${chalk.dim("Banner")}      ${boolDisplay(config.output.banner)}`);
+
+  log.blank();
+  log.dim(`Config: ${chalk.cyan(getConfigPath(cwd))}`);
+  log.blank();
+}
+
+function boolDisplay(val: boolean): string {
+  return val ? chalk.green("true") : chalk.red("false");
+}

package/src/commands/init.ts

@@ -0,0 +1,80 @@
+import fs from "fs";
+import path from "path";
+import { saveConfig, DEFAULT_CONFIG, ensureHudsonDirs, getConfigPath } from "../core/config.js";
+import { log, BANNER, MASCOT_FULL, symbols } from "../utils/display.js";
+import chalk from "chalk";
+
+export async function initCommand(options: { force?: boolean } = {}): Promise<void> {
+  const cwd = process.cwd();
+  const configPath = getConfigPath(cwd);
+
+  if (process.stdout.isTTY) {
+    console.log(BANNER());
+    console.log(MASCOT_FULL);
+  }
+
+  if (fs.existsSync(configPath) && !options.force) {
+    log.warn("Hudson is already initialized in this directory.");
+    log.dim(`Config: ${chalk.cyan(configPath)}`);
+    log.dim(`Use ${chalk.cyan("--force")} to reinitialize.`);
+    return;
+  }
+
+  let projectName = path.basename(cwd);
+  let packageManager: "pnpm" | "yarn" | "npm" = "pnpm";
+
+  const pkgJsonPath = path.join(cwd, "package.json");
+  if (fs.existsSync(pkgJsonPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+      if (pkg.name) projectName = pkg.name;
+    } catch {}
+  }
+
+  // Detect package manager
+  if (fs.existsSync(path.join(cwd, "pnpm-lock.yaml"))) packageManager = "pnpm";
+  else if (fs.existsSync(path.join(cwd, "yarn.lock"))) packageManager = "yarn";
+
+  ensureHudsonDirs(cwd);
+
+  const config = {
+    ...DEFAULT_CONFIG,
+    project: {
+      ...DEFAULT_CONFIG.project,
+      name: projectName,
+    },
+    packageManager,
+    workspaces: {
+      ...DEFAULT_CONFIG.workspaces,
+      enabled: fs.existsSync(path.join(cwd, "packages")) || fs.existsSync(path.join(cwd, "apps")),
+    },
+  };
+
+  saveConfig(config, cwd);
+
+  // Create .gitignore entry for .hudson/temp
+  const gitignorePath = path.join(cwd, ".gitignore");
+  const hudsonGitignore = "\n# Hudson Build System\n.hudson/temp/\n";
+  if (fs.existsSync(gitignorePath)) {
+    const content = fs.readFileSync(gitignorePath, "utf-8");
+    if (!content.includes(".hudson/temp")) {
+      fs.appendFileSync(gitignorePath, hudsonGitignore);
+    }
+  }
+
+  log.blank();
+  log.success(chalk.bold("Hudson initialized successfully!"));
+  log.blank();
+
+  console.log(`  ${chalk.dim("Project")}      ${chalk.cyan(projectName)}`);
+  console.log(`  ${chalk.dim("Config")}       ${chalk.cyan(".hudson/hudson.yml")}`);
+  console.log(`  ${chalk.dim("Pkg manager")} ${chalk.cyan(packageManager)}`);
+  console.log(`  ${chalk.dim("Workspaces")}  ${chalk.cyan(config.workspaces.enabled ? "enabled" : "disabled")}`);
+
+  log.blank();
+  log.section("Next steps");
+  log.step(`Edit your config: ${chalk.cyan(".hudson/hudson.yml")}`);
+  log.step(`Or configure via: ${chalk.cyan("hudson configure build.outDir dist")}`);
+  log.step(`Build your project: ${chalk.cyan("hudson build")}`);
+  log.blank();
+}

package/src/commands/run.ts

@@ -0,0 +1,114 @@
+import ora from "ora";
+import chalk from "chalk";
+import { loadConfig } from "../core/config.js";
+import { runScript, runCommand } from "../core/runner.js";
+import { discoverWorkspaces } from "../core/workspace.js";
+import { log, formatDuration, BANNER } from "../utils/display.js";
+
+interface RunOptions {
+  workspace?: string;
+  all?: boolean;
+  verbose?: boolean;
+}
+
+export async function runScriptCommand(scriptName: string, options: RunOptions = {}): 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(`Script: ${scriptName}`);
+
+  const start = Date.now();
+
+  if (options.all && config.workspaces.enabled) {
+    const workspaces = await discoverWorkspaces(config, cwd);
+
+    if (workspaces.length === 0) {
+      log.warn("No workspaces found");
+      return;
+    }
+
+    log.step(`Running ${chalk.cyan(scriptName)} in ${chalk.cyan(workspaces.length)} workspaces`);
+    log.blank();
+
+    const promises = workspaces.map(async (ws) => {
+      if (!ws.scripts[scriptName]) {
+        log.dim(`  ${chalk.dim(ws.name)} — no ${scriptName} script`);
+        return;
+      }
+
+      const spinner = ora({
+        text: chalk.dim(`${ws.name}...`),
+        prefixText: "  ",
+      }).start();
+
+      const parts = ws.scripts[scriptName].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(formatDuration(result.duration))}`);
+      } else {
+        spinner.fail(`${chalk.red(ws.name)} failed`);
+        if (result.stderr && verbose) {
+          result.stderr.split("\n").filter(Boolean).forEach((l) => {
+            console.log(`    ${chalk.dim(l)}`);
+          });
+        }
+      }
+    });
+
+    if (config.workspaces.parallel) {
+      const batchSize = config.workspaces.maxConcurrency;
+      for (let i = 0; i < promises.length; i += batchSize) {
+        await Promise.all(promises.slice(i, i + batchSize));
+      }
+    } else {
+      for (const p of promises) await p;
+    }
+
+  } else {
+    const script = config.scripts[scriptName];
+
+    if (!script) {
+      log.error(`Script '${scriptName}' not found in .hudson/hudson.yml`);
+      log.blank();
+
+      const available = Object.keys(config.scripts);
+      if (available.length > 0) {
+        log.step("Available scripts:");
+        available.forEach((s) => {
+          console.log(`  ${chalk.dim("·")} ${chalk.cyan(s)} ${chalk.dim("→")} ${chalk.dim(config.scripts[s])}`);
+        });
+      }
+      process.exit(1);
+    }
+
+    log.step(`${chalk.dim("Running:")} ${chalk.white(script)}`);
+    log.blank();
+
+    const result = await runScript(scriptName, config, { cwd, verbose });
+
+    if (result.exitCode !== 0) {
+      log.error(`Script '${scriptName}' failed with exit code ${result.exitCode}`);
+      if (result.stderr) {
+        log.blank();
+        result.stderr.split("\n").filter(Boolean).forEach((l) => {
+          console.log(`  ${chalk.dim(l)}`);
+        });
+      }
+      process.exit(1);
+    }
+  }
+
+  const duration = Date.now() - start;
+  log.blank();
+  log.success(`Done ${chalk.dim("in")} ${chalk.cyan(formatDuration(duration))}`);
+  log.blank();
+}

package/src/commands/workspaces.ts

@@ -0,0 +1,49 @@
+import chalk from "chalk";
+import { loadConfig } from "../core/config.js";
+import { discoverWorkspaces } from "../core/workspace.js";
+import { log, BANNER } from "../utils/display.js";
+
+export async function workspacesCommand(subcommand?: string, wsName?: string): Promise<void> {
+  const cwd = process.cwd();
+  const config = loadConfig(cwd);
+
+  if (!config.workspaces.enabled) {
+    log.warn("Workspaces are disabled.");
+    log.dim(`Enable with: ${chalk.cyan("hudson configure workspaces.enabled true")}`);
+    return;
+  }
+
+  const workspaces = await discoverWorkspaces(config, cwd);
+
+  if (config.output.banner) {
+    console.log(BANNER());
+  }
+
+  if (!subcommand || subcommand === "list") {
+    log.section(`Workspaces (${workspaces.length})`);
+
+    if (workspaces.length === 0) {
+      log.warn("No workspaces found.");
+      log.dim(`Check your workspaces.packages patterns in .hudson/hudson.yml`);
+      return;
+    }
+
+    for (const ws of workspaces) {
+      const scripts = Object.keys(ws.scripts);
+      console.log();
+      console.log(`  ${chalk.bold.cyan(ws.name)} ${chalk.dim("v" + ws.version)}`);
+      console.log(`  ${chalk.dim("path:")} ${chalk.dim(ws.path)}`);
+
+      if (scripts.length > 0) {
+        console.log(`  ${chalk.dim("scripts:")} ${scripts.map((s) => chalk.cyan(s)).join(chalk.dim(", "))}`);
+      }
+    }
+
+    log.blank();
+    return;
+  }
+
+  log.error(`Unknown workspaces subcommand: ${subcommand}`);
+  log.dim("Available: list");
+  process.exit(1);
+}

package/src/core/config.ts

@@ -0,0 +1,214 @@
+import fs from "fs";
+import path from "path";
+import yaml from "js-yaml";
+
+export interface WorkspaceConfig {
+  name: string;
+  path: string;
+  scripts?: Record<string, string>;
+}
+
+export interface HudsonConfig {
+  project: {
+    name: string;
+    version: string;
+    description?: string;
+  };
+  build: {
+    outDir: string;
+    tsconfig: string;
+    sourcemap: boolean;
+    minify: boolean;
+    target: string;
+    clean: boolean;
+  };
+  workspaces: {
+    enabled: boolean;
+    packages: string[];
+    parallel: boolean;
+    maxConcurrency: number;
+  };
+  dev: {
+    watch: boolean;
+    port?: number;
+    open: boolean;
+  };
+  scripts: Record<string, string>;
+  hooks: {
+    preBuild?: string;
+    postBuild?: string;
+    preTest?: string;
+    postTest?: string;
+  };
+  packageManager: "pnpm" | "yarn" | "npm";
+  output: {
+    verbose: boolean;
+    timestamps: boolean;
+    color: boolean;
+    banner: boolean;
+  };
+}
+
+export const CONFIG_HEADER = `#####################################################################
+#
+#   ██╗  ██╗██╗   ██╗██████╗ ███████╗ ██████╗ ███╗   ██╗
+#   ██║  ██║██║   ██║██╔══██╗██╔════╝██╔═══██╗████╗  ██║
+#   ███████║██║   ██║██║  ██║███████╗██║   ██║██╔██╗ ██║
+#   ██╔══██║██║   ██║██║  ██║╚════██║██║   ██║██║╚██╗██║
+#   ██║  ██║╚██████╔╝██████╔╝███████║╚██████╔╝██║ ╚████║
+#   ╚═╝  ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝ ╚═════╝ ╚═╝  ╚═══╝
+#
+#   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
+#
+#####################################################################
+
+`;
+
+export const DEFAULT_CONFIG: HudsonConfig = {
+  project: {
+    name: "my-project",
+    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,
+  },
+};
+
+export function getHudsonDir(cwd = process.cwd()): string {
+  return path.join(cwd, ".hudson");
+}
+
+export function getConfigPath(cwd = process.cwd()): string {
+  return path.join(getHudsonDir(cwd), "hudson.yml");
+}
+
+export function getTempDir(cwd = process.cwd()): string {
+  return path.join(getHudsonDir(cwd), "temp");
+}
+
+export function ensureHudsonDirs(cwd = process.cwd()): void {
+  const hudsonDir = getHudsonDir(cwd);
+  const tempDir = getTempDir(cwd);
+  if (!fs.existsSync(hudsonDir)) fs.mkdirSync(hudsonDir, { recursive: true });
+  if (!fs.existsSync(tempDir)) fs.mkdirSync(tempDir, { recursive: true });
+}
+
+export function loadConfig(cwd = process.cwd()): HudsonConfig {
+  const configPath = getConfigPath(cwd);
+  if (!fs.existsSync(configPath)) {
+    return DEFAULT_CONFIG;
+  }
+  const raw = fs.readFileSync(configPath, "utf-8");
+  const parsed = yaml.load(raw) as Partial<HudsonConfig>;
+  return deepMerge(DEFAULT_CONFIG, parsed) as HudsonConfig;
+}
+
+export function saveConfig(config: HudsonConfig, cwd = process.cwd()): void {
+  ensureHudsonDirs(cwd);
+  const configPath = getConfigPath(cwd);
+  const yamlContent = yaml.dump(config, {
+    indent: 2,
+    lineWidth: 80,
+    quotingType: '"',
+  });
+  fs.writeFileSync(configPath, CONFIG_HEADER + yamlContent, "utf-8");
+}
+
+export function setConfigValue(keyPath: string, value: string, cwd = process.cwd()): void {
+  const config = loadConfig(cwd);
+  const keys = keyPath.split(".");
+  let obj: Record<string, unknown> = config as unknown as Record<string, unknown>;
+
+  for (let i = 0; i < keys.length - 1; i++) {
+    const k = keys[i];
+    if (!(k in obj) || typeof obj[k] !== "object") {
+      obj[k] = {};
+    }
+    obj = obj[k] as Record<string, unknown>;
+  }
+
+  const lastKey = keys[keys.length - 1];
+  const parsed = parseValue(value);
+  obj[lastKey] = parsed;
+
+  saveConfig(config, cwd);
+}
+
+export function getConfigValue(keyPath: string, cwd = process.cwd()): unknown {
+  const config = loadConfig(cwd);
+  const keys = keyPath.split(".");
+  let obj: unknown = config;
+
+  for (const k of keys) {
+    if (obj == null || typeof obj !== "object") return undefined;
+    obj = (obj as Record<string, unknown>)[k];
+  }
+
+  return obj;
+}
+
+function parseValue(value: string): unknown {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  const num = Number(value);
+  if (!isNaN(num) && value.trim() !== "") return num;
+  return value;
+}
+
+function deepMerge(target: unknown, source: unknown): unknown {
+  if (typeof source !== "object" || source === null) return source ?? target;
+  if (typeof target !== "object" || target === null) return source;
+
+  const result = { ...(target as Record<string, unknown>) };
+  for (const key of Object.keys(source as Record<string, unknown>)) {
+    const srcVal = (source as Record<string, unknown>)[key];
+    const tgtVal = (target as Record<string, unknown>)[key];
+    result[key] = deepMerge(tgtVal, srcVal);
+  }
+  return result;
+}