@forklaunch/bunrun 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 forklaunch
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,83 @@
+# @forklaunch/bunrun
+
+A Bun-native TypeScript workspace script runner with topological ordering.
+
+## Installation
+
+```bash
+npm install -g @forklaunch/bunrun
+# or
+bun add -g @forklaunch/bunrun
+```
+
+**Requirements:** Bun >= 1.1.0
+
+## Usage
+
+```bash
+# Run build script in topological order
+bunrun build
+
+# Run with specific script
+bunrun test
+
+# Run with concurrency limit
+bunrun build --jobs 4
+
+# Run sequentially (one at a time)
+bunrun build --sequential
+
+# Filter packages
+bunrun build --filter "@myorg/*"
+bunrun build --exclude "**/legacy-*"
+
+# Debug mode
+bunrun build --debug
+
+# Print plan without executing
+bunrun build --print-only
+```
+
+## Features
+
+- **Topological ordering**: Runs scripts in dependency order
+- **Parallel execution**: Runs independent packages concurrently
+- **Workspace discovery**: Automatically finds packages in monorepos
+- **Flexible filtering**: Include/exclude packages by name or path
+- **Dependency-aware**: Considers dependencies, devDependencies, and peerDependencies
+- **Bun-native**: Direct TypeScript execution without compilation
+
+## Options
+
+- `script` - Script to run (default: build)
+- `-j, --jobs <n>` - Concurrency per tier (default: CPU count)
+- `--sequential` - Run strictly one-by-one in topological order
+- `--filter <glob>` - Include packages matching glob pattern (can repeat)
+- `--exclude <glob>` - Exclude packages matching glob pattern (can repeat)
+- `--no-dev` - Ignore devDependencies for ordering
+- `--no-peer` - Ignore peerDependencies for ordering
+- `--print-only` - Print execution plan without running
+- `--debug` - Show diagnostic information
+
+## Examples
+
+```bash
+# Build all packages in dependency order
+bunrun build
+
+# Run tests with limited concurrency
+bunrun test --jobs 2
+
+# Build only frontend packages
+bunrun build --filter "**/frontend-*"
+
+# Build everything except legacy packages
+bunrun build --exclude "**/legacy-*"
+
+# Sequential build for debugging
+bunrun build --sequential --debug
+```
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/cli.js

@@ -0,0 +1,378 @@
+#!/usr/bin/env bun
+
+// src/index.ts
+import { readFileSync, readdirSync, statSync } from "fs";
+import { availableParallelism, cpus } from "os";
+import { join, relative, resolve, sep } from "path";
+var cwd = process.cwd();
+function detectCPUCount() {
+  try {
+    return Math.max(1, availableParallelism());
+  } catch {
+    try {
+      return Math.max(1, cpus()?.length ?? 4);
+    } catch {
+      return 4;
+    }
+  }
+}
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const opts = {
+    script: "build",
+    jobs: detectCPUCount(),
+    includeDev: true,
+    includePeer: true,
+    only: [],
+    exclude: [],
+    printOnly: false,
+    sequential: false,
+    debug: false
+  };
+  let startIndex = 0;
+  if (args.length > 0 && args[0] && !args[0].startsWith("-")) {
+    opts.script = args[0];
+    startIndex = 1;
+  }
+  for (let i = startIndex; i < args.length; i++) {
+    const a = args[i];
+    if (!a) continue;
+    if (a === "-j" || a === "--jobs") {
+      const nextArg = args[++i];
+      if (!nextArg) {
+        console.error(`Missing value for ${a}`);
+        process.exit(1);
+      }
+      const jobs = Number(nextArg);
+      if (isNaN(jobs) || jobs < 1) {
+        console.error(`Invalid jobs value: ${nextArg}`);
+        process.exit(1);
+      }
+      opts.jobs = jobs;
+    } else if (a === "--no-dev") {
+      opts.includeDev = false;
+    } else if (a === "--no-peer") {
+      opts.includePeer = false;
+    } else if (a === "--filter" || a === "--only") {
+      const nextArg = args[++i];
+      if (!nextArg) {
+        console.error(`Missing value for ${a}`);
+        process.exit(1);
+      }
+      opts.only.push(nextArg);
+    } else if (a === "--exclude") {
+      const nextArg = args[++i];
+      if (!nextArg) {
+        console.error(`Missing value for ${a}`);
+        process.exit(1);
+      }
+      opts.exclude.push(nextArg);
+    } else if (a === "--print-only") {
+      opts.printOnly = true;
+    } else if (a === "--sequential") {
+      opts.sequential = true;
+    } else if (a === "--debug") {
+      opts.debug = true;
+    } else {
+      console.error(`Unknown arg: ${a}`);
+      process.exit(1);
+    }
+  }
+  return opts;
+}
+function readJSON(p) {
+  try {
+    const content = readFileSync(p, "utf8");
+    const parsed = JSON.parse(content);
+    if (typeof parsed !== "object" || parsed === null) {
+      throw new Error(`Invalid JSON structure in ${p}`);
+    }
+    const pkg = parsed;
+    if (typeof pkg.name !== "string") {
+      throw new Error(`Missing or invalid name field in ${p}`);
+    }
+    return pkg;
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(`Failed to read package.json at ${p}: ${error.message}`);
+    }
+    throw error;
+  }
+}
+function isDir(p) {
+  try {
+    return statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function safeReadDir(d) {
+  try {
+    return readdirSync(d);
+  } catch {
+    return [];
+  }
+}
+function matchGlob(s, glob) {
+  const esc = glob.replace(/[-/\\^$+?.()|[\]{}]/g, "\\$&").replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*");
+  const re = new RegExp("^" + esc + "$");
+  return re.test(s);
+}
+function expandGlob(root, pattern) {
+  const abs = resolve(root, pattern);
+  const parts = relative(root, abs).split(sep);
+  const out = /* @__PURE__ */ new Set();
+  function walk(dir, i) {
+    if (i === parts.length) {
+      out.add(dir);
+      return;
+    }
+    const seg = parts[i];
+    if (seg === "**") {
+      walk(dir, i + 1);
+      for (const e of safeReadDir(dir)) {
+        const p = join(dir, e);
+        if (isDir(p)) walk(p, i);
+      }
+    } else if (seg === "*") {
+      for (const e of safeReadDir(dir)) {
+        const p = join(dir, e);
+        if (isDir(p)) walk(p, i + 1);
+      }
+    } else {
+      const next = join(dir, seg);
+      if (isDir(next)) walk(next, i + 1);
+    }
+  }
+  walk(root, 0);
+  return [...out];
+}
+function getWorkspaceDirs(rootPkg) {
+  const ws = Array.isArray(rootPkg.workspaces) ? rootPkg.workspaces : rootPkg.workspaces?.packages || [];
+  const dirs = [];
+  for (const patt of ws) {
+    if (typeof patt !== "string") {
+      console.warn(`Skipping invalid workspace pattern: ${patt}`);
+      continue;
+    }
+    for (const d of expandGlob(cwd, patt)) {
+      try {
+        readJSON(join(d, "package.json"));
+        dirs.push(d);
+      } catch {
+      }
+    }
+  }
+  return [...new Set(dirs)];
+}
+function collectDeps(pkgJson, includeDev, includePeer) {
+  return {
+    ...pkgJson.dependencies || {},
+    ...pkgJson.optionalDependencies || {},
+    ...includeDev ? pkgJson.devDependencies || {} : {},
+    ...includePeer ? pkgJson.peerDependencies || {} : {}
+  };
+}
+function topoTiers(nodes, edges) {
+  const indeg = new Map(nodes.map((n) => [n, 0]));
+  for (const [, outs] of edges) {
+    for (const m of outs) {
+      indeg.set(m, (indeg.get(m) || 0) + 1);
+    }
+  }
+  const remain = new Set(nodes);
+  const tiers = [];
+  while (remain.size > 0) {
+    const zero = [];
+    for (const n of remain) {
+      if ((indeg.get(n) || 0) === 0) {
+        zero.push(n);
+      }
+    }
+    if (zero.length === 0) {
+      console.warn(
+        "Dependency cycle detected, placing remaining packages in final tier"
+      );
+      tiers.push([...remain]);
+      break;
+    }
+    tiers.push(zero);
+    for (const z of zero) {
+      remain.delete(z);
+      const outs = edges.get(z);
+      if (!outs) continue;
+      for (const m of outs) {
+        indeg.set(m, Math.max(0, (indeg.get(m) || 0) - 1));
+      }
+    }
+  }
+  return tiers;
+}
+async function runSequential(dirsInOrder, script) {
+  for (const dir of dirsInOrder) {
+    console.log(`\u25B6 ${dir}: bun run ${script}`);
+    const p = Bun.spawn(["bun", "run", script], {
+      cwd: dir,
+      stdout: "inherit",
+      stderr: "inherit"
+    });
+    const code = await p.exited;
+    if (code !== 0) {
+      throw new Error(`Failed in ${dir} with exit code ${code}`);
+    }
+  }
+}
+async function runTierParallel(dirs, script, concurrency) {
+  if (dirs.length === 0) return;
+  let i = 0;
+  const errs = [];
+  async function worker() {
+    while (true) {
+      const idx = i++;
+      if (idx >= dirs.length) break;
+      const dir = dirs[idx];
+      if (!dir) continue;
+      console.log(`\u25B6 ${dir}: bun run ${script}`);
+      const p = Bun.spawn(["bun", "run", script], {
+        cwd: dir,
+        stdout: "inherit",
+        stderr: "inherit"
+      });
+      const code = await p.exited;
+      if (code !== 0) {
+        errs.push(new Error(`Failed in ${dir} with exit code ${code}`));
+      }
+    }
+  }
+  const n = Math.max(1, Math.min(concurrency, dirs.length));
+  await Promise.all(Array.from({ length: n }, () => worker()));
+  if (errs.length > 0) {
+    throw errs[0];
+  }
+}
+async function main() {
+  const opts = parseArgs();
+  const rootPkg = readJSON(join(cwd, "package.json"));
+  const wsDirs = getWorkspaceDirs(rootPkg);
+  if (wsDirs.length === 0) {
+    console.error("No workspaces found in package.json");
+    process.exit(1);
+  }
+  const pkgs = wsDirs.map((dir) => {
+    try {
+      const json = readJSON(join(dir, "package.json"));
+      return {
+        name: json.name,
+        dir,
+        scripts: json.scripts ?? {},
+        json
+      };
+    } catch (error) {
+      console.warn(
+        `Failed to load package.json in ${dir}:`,
+        error instanceof Error ? error.message : error
+      );
+      return null;
+    }
+  }).filter((p) => p !== null && p.name.length > 0);
+  const selected = pkgs.filter((p) => {
+    const matchOnly = opts.only.length > 0 ? opts.only.some((g) => matchGlob(p.name, g) || matchGlob(p.dir, g)) : true;
+    const matchExclude = opts.exclude.length > 0 ? opts.exclude.some((g) => matchGlob(p.name, g) || matchGlob(p.dir, g)) : false;
+    return matchOnly && !matchExclude;
+  });
+  if (selected.length === 0) {
+    console.error("No packages matched selection.");
+    process.exit(1);
+  }
+  const names = new Set(selected.map((p) => p.name));
+  const edges = /* @__PURE__ */ new Map();
+  const ensure = (k) => {
+    const existing = edges.get(k);
+    if (existing) return existing;
+    const newSet = /* @__PURE__ */ new Set();
+    edges.set(k, newSet);
+    return newSet;
+  };
+  for (const p of selected) {
+    const all = collectDeps(p.json, opts.includeDev, opts.includePeer);
+    for (const depName of Object.keys(all)) {
+      if (!names.has(depName)) continue;
+      ensure(depName).add(p.name);
+    }
+  }
+  const nodes = selected.map((p) => p.name);
+  const tiers = topoTiers(nodes, edges);
+  const hasScript = (name) => {
+    const pkg = selected.find((p) => p.name === name);
+    if (!pkg) {
+      console.warn(`Package not found: ${name}`);
+      return false;
+    }
+    return Boolean(pkg.scripts[opts.script]);
+  };
+  if (opts.debug) {
+    console.log(`Script: ${opts.script}`);
+    console.log(
+      `Mode: ${opts.sequential ? "sequential" : `parallel by tier (jobs=${opts.jobs})`}`
+    );
+    console.log(
+      `Edges: deps + optional${opts.includeDev ? " + dev" : ""}${opts.includePeer ? " + peer" : ""}`
+    );
+    console.log("");
+  }
+  const tiersDirs = tiers.map(
+    (tier) => tier.filter(hasScript).map((name) => {
+      const pkg = selected.find((p) => p.name === name);
+      if (!pkg) {
+        throw new Error(`Package not found: ${name}`);
+      }
+      return pkg.dir;
+    })
+  );
+  const seqDirs = tiers.flat().filter(hasScript).map((name) => {
+    const pkg = selected.find((p) => p.name === name);
+    if (!pkg) {
+      throw new Error(`Package not found: ${name}`);
+    }
+    return pkg.dir;
+  });
+  if (opts.debug) {
+    if (opts.sequential) {
+      console.log("Plan (sequential order):");
+      seqDirs.forEach((d, i) => console.log(`  ${i + 1}. ${d}`));
+      console.log("");
+      console.log("Command preview:");
+      console.log(
+        seqDirs.map((d) => `(cd ${JSON.stringify(d)} && bun run ${opts.script})`).join(" && ")
+      );
+    } else {
+      console.log("Plan (tiers):");
+      tiersDirs.forEach((dirs, i) => {
+        if (!dirs.length) return;
+        console.log(`  Tier ${i + 1}:`);
+        dirs.forEach((d) => console.log(`    - ${d}`));
+      });
+      console.log("");
+      console.log("Command preview (conceptual):");
+      console.log(
+        tiersDirs.filter((dirs) => dirs.length).map(
+          (dirs) => dirs.map(
+            (d) => `(cd ${JSON.stringify(d)} && bun run ${opts.script})`
+          ).join(" & ") + " && wait"
+        ).join(" && ")
+      );
+    }
+  }
+  if (opts.printOnly) return;
+  if (opts.sequential) {
+    await runSequential(seqDirs, opts.script);
+  } else {
+    for (const dirs of tiersDirs) {
+      if (dirs.length === 0) continue;
+      await runTierParallel(dirs, opts.script, opts.jobs);
+    }
+  }
+}
+main().catch((err) => {
+  throw err;
+});

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@forklaunch/bunrun",
+  "version": "0.0.1",
+  "description": "Bun-native TypeScript workspace script runner with topological ordering",
+  "homepage": "https://github.com/forklaunch/forklaunch-js#readme",
+  "bugs": {
+    "url": "https://github.com/forklaunch/forklaunch-js/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/forklaunch/forklaunch-js.git"
+  },
+  "license": "MIT",
+  "author": "Rohin Bhargava",
+  "type": "module",
+  "bin": {
+    "bunrun": "dist/index.mjs"
+  },
+  "engines": {
+    "bun": ">=1.1.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "bun",
+    "workspace",
+    "monorepo",
+    "build",
+    "topological",
+    "typescript",
+    "cli"
+  ],
+  "devDependencies": {
+    "@typescript/native-preview": "7.0.0-dev.20250911.1",
+    "tsup": "^8.0.0",
+    "typescript": "^5.6.0"
+  },
+  "scripts": {
+    "build": "tsgo --noEmit && tsup",
+    "check": "depcheck",
+    "clean": "rm -rf dist pnpm.lock.yaml node_modules",
+    "docs": "typedoc --out docs *",
+    "format": "prettier --ignore-path=.prettierignore --config .prettierrc '**/*.{ts,tsx,json}' --write",
+    "lint": "eslint . -c eslint.config.mjs",
+    "lint:fix": "eslint . -c eslint.config.mjs --fix",
+    "publish:package": "./publish-package.bash",
+    "test": "vitest --passWithNoTests"
+  }
+}