@10stars/config 15.0.13 → 15.1.0

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@10stars/config",
-  "version": "15.0.13",
+  "version": "15.1.0",
   "private": false,
   "bin": {
-    "config": "./src/index.ts"
+    "10config": "./src/index.ts"
   },
   "files": [
     ".oxfmtrc.json",
@@ -19,12 +19,13 @@
   "dependencies": {
     "@10stars/oxlint-plugin-react-hooks": "^1.0.5",
     "@oxc-node/core": "0.0.35",
+    "@types/bun": "^1.0.0",
     "@types/node": "^24.0.0",
     "@types/react": "^19.0.0",
     "husky": "^9.0.0",
-    "oxfmt": "0.21.0",
-    "oxlint": "1.36.0",
-    "oxlint-tsgolint": "0.10.1",
+    "oxfmt": "^0.24.0",
+    "oxlint": "^1.39.0",
+    "oxlint-tsgolint": "^0.11.0",
     "tsx": "^4.21.0",
     "type-fest": "^5.0.0",
     "typescript": "~5.9.3"

package/src/colors.ts

@@ -0,0 +1,26 @@
+const reset = "\x1b[0m"
+
+export const colors = {
+  yellow: (t: string) => "\x1b[33m" + t + reset,
+  cyan: (t: string) => "\x1b[36m" + t + reset,
+  green: (t: string) => "\x1b[32m" + t + reset,
+  blue: (t: string) => "\x1b[34m" + t + reset,
+  magenta: (t: string) => "\x1b[35m" + t + reset,
+  red: (t: string) => "\x1b[31m" + t + reset,
+} as const
+
+export type ColorName = keyof typeof colors
+
+const colorNames = Object.keys(colors) as ColorName[]
+
+let colorIndex = 0
+
+export function getNextColor(): ColorName {
+  const color = colorNames[colorIndex % colorNames.length]!
+  colorIndex++
+  return color
+}
+
+export function resetColorIndex(): void {
+  colorIndex = 0
+}

package/src/index.ts

@@ -1,8 +1,11 @@
+#!/usr/bin/env bun
 import { execSync } from "node:child_process"
 import fs from "node:fs/promises"
 import path from "node:path"
 
+import { resetColorIndex } from "./colors"
 import { checkIsMonorepo, linkPackages } from "./link-packages"
+import { runConcurrently, type CommandConfig } from "./runner"
 import { setupVSCode } from "./vscode-config"
 
 const cwd = process.env.PWD!
@@ -58,6 +61,10 @@ const actions = {
     info: `Typecheck code (no watch)`,
     action: () => exec(`tsc --project ./tsconfig.json --noEmit`),
   },
+  typecheckGo: {
+    info: `Typecheck using tsgo (@typescript/native-preview, experimental)`,
+    action: () => exec(`@typescript/native-preview --project ./tsconfig.json`),
+  },
   lint: {
     info: `Format & Lint code (no watch)`,
     action: async () => exec(`oxfmt && oxlint --fix --type-aware ${await getOxlintCommonCmd()}`),
@@ -97,23 +104,91 @@ const actions = {
       }
     },
   },
+  run: {
+    info: `Run multiple commands concurrently (usage: 10config run -l label1 "cmd1" -l label2 "cmd2")`,
+    action: async () => {
+      const args = process.argv.slice(3) // skip 'node', 'config', 'run'
+
+      const printHelp = () => {
+        console.log(`
+Run multiple commands concurrently with colored prefixes
+
+Usage:
+  10config run --label <name> "<command>" [--label <name> "<command>" ...]
+  10config run -l <name> "<command>" [-l <name> "<command>" ...]
+  10config run "<command1>" "<command2>" ...
+
+Examples:
+  10config run -l server "bun run dev.server" -l client "bun run dev.client"
+  10config run -l hono "bun run dev.hono" -l astro "bun run dev.astro"
+`)
+      }
+
+      if (args.includes("-h") || args.includes("--help")) {
+        printHelp()
+        process.exit(0)
+      }
+
+      const commands: CommandConfig[] = []
+      let i = 0
+
+      while (i < args.length) {
+        const arg = args[i]
+        if (arg === "-l" || arg === "--label") {
+          const label = args[i + 1]
+          const command = args[i + 2]
+          if (!label || !command) {
+            console.error(`Error: --label requires a label and a command`)
+            console.error(`Usage: 10config run --label <name> "<command>"`)
+            process.exit(1)
+          }
+          commands.push({ label, command })
+          i += 3
+        } else {
+          commands.push({ label: `cmd${commands.length + 1}`, command: arg! })
+          i++
+        }
+      }
+
+      if (commands.length === 0) {
+        printHelp()
+        process.exit(0)
+      }
+
+      resetColorIndex()
+      await runConcurrently(commands)
+    },
+  },
 } satisfies Record<string, { info: string; action: () => void | Promise<void> }>
 
 export const run = async () => {
-  const cmd = process.argv[2] as keyof typeof actions
+  const cmd = process.argv[2]
   const availableActions = Object.keys(actions)
+
+  const getAvailableCommands = () =>
+    availableActions
+      .map((action) => `  ${action} - ${actions[action as keyof typeof actions].info}`)
+      .join("\n")
+
+  if (!cmd || cmd === "-h" || cmd === "--help") {
+    console.log(`Usage: 10config <command> [options]\n`)
+    console.log(`Available commands:`)
+    console.log(getAvailableCommands())
+    process.exit(0)
+  }
+
   if (!availableActions.includes(cmd)) {
-    let error = [
-      `Unknown command: ${cmd}\n`,
-      `Example CLI cmd: $ config lint`,
-      `Available commands:`,
-    ].join(`\n`)
-    for (const availableAction of availableActions) {
-      error += `\n  ${availableAction} - ${actions[availableAction].info}`
-    }
-    throw new Error(`${error}\n`)
+    throw new Error(
+      [
+        `Unknown command: ${cmd}\n`,
+        `Example CLI cmd: $ 10config lint`,
+        `Available commands:`,
+        getAvailableCommands(),
+        "",
+      ].join(`\n`),
+    )
   }
-  await actions[cmd].action()
+  await actions[cmd as keyof typeof actions].action()
 }
 
 void run()

package/src/runner.ts

@@ -0,0 +1,83 @@
+import { colors, getNextColor, type ColorName } from "./colors"
+
+export interface CommandConfig {
+  /** Label shown as prefix in output */
+  label: string
+  /** Command to run (string will be split by spaces, array used as-is) */
+  command: string | string[]
+  /** Color for the label (auto-assigned if not provided) */
+  color?: ColorName
+}
+
+interface RunningProcess {
+  label: string
+  proc: ReturnType<typeof Bun.spawn>
+  prefix: string
+}
+
+async function pipeOutput(stream: ReadableStream<Uint8Array>, prefix: string): Promise<void> {
+  const decoder = new TextDecoder()
+  for await (const chunk of stream) {
+    const text = decoder.decode(chunk).trimEnd()
+    if (text) {
+      for (const line of text.split("\n")) {
+        console.log(`${prefix} ${line}`)
+      }
+    }
+  }
+}
+
+function parseCommand(command: string | string[]): string[] {
+  if (Array.isArray(command)) return command
+  // Simple split by spaces - doesn't handle quoted strings
+  return command.split(/\s+/).filter(Boolean)
+}
+
+export async function runConcurrently(commands: CommandConfig[]): Promise<void> {
+  const processes: RunningProcess[] = []
+
+  for (const config of commands) {
+    const colorName = config.color ?? getNextColor()
+    const colorFn = colors[colorName]
+    const prefix = `[${colorFn(config.label)}]`
+    const args = parseCommand(config.command)
+
+    const proc = Bun.spawn(args, {
+      stdout: "pipe",
+      stderr: "pipe",
+    })
+
+    processes.push({ label: config.label, proc, prefix })
+
+    // Start piping output (don't await - run concurrently)
+    pipeOutput(proc.stdout, prefix)
+    pipeOutput(proc.stderr, prefix)
+  }
+
+  // Handle SIGINT to kill all child processes
+  const cleanup = () => {
+    for (const { proc } of processes) {
+      proc.kill()
+    }
+    process.exit(0)
+  }
+  process.on("SIGINT", cleanup)
+  process.on("SIGTERM", cleanup)
+
+  // Wait for all processes to complete
+  const results = await Promise.all(
+    processes.map(async ({ label, proc, prefix }) => {
+      const exitCode = await proc.exited
+      if (exitCode !== 0) {
+        console.log(`${prefix} exited with code ${exitCode}`)
+      }
+      return { label, exitCode }
+    }),
+  )
+
+  // Exit with non-zero if any process failed
+  const failed = results.filter((r) => r.exitCode !== 0)
+  if (failed.length > 0) {
+    process.exit(1)
+  }
+}