@ball-lang/cli 1.24.0 → 1.26.0

package/src/index.ts

@@ -12,7 +12,6 @@
 import { readFileSync, writeFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
-import { BallEngine } from '@ball-lang/engine';
 import {
   analyzeCapabilities,
   checkPolicy,
@@ -20,6 +19,24 @@ import {
   type Program,
 } from './capability_analyzer.ts';
 
+// `@ball-lang/engine` (compiled_engine.ts) and `./cli_core.ts`
+// (compiled_cli.ts) are BOTH auto-generated by compiling a self-hosted Ball
+// program through `@ball-lang/compiler`, and each installs its own runtime
+// preamble as a side effect of module evaluation — including monkey-patching
+// shared native prototypes (`Map.prototype.get`/`entries`/`keys`/`values`).
+// That patching is idempotent against being installed *once*, but NOT against
+// a second, independently-compiled preamble installing on top of it: the
+// second artifact's "capture the native method before shadowing it" step
+// actually captures the FIRST artifact's already-shadowed version, and a
+// later call against a genuine native Map throws ("Method Map.prototype.entries
+// called on incompatible receiver"). Every `ball` invocation is a fresh,
+// single-command process, so the fix is to never let both load in the same
+// one: import each compiled engine LAZILY, only inside the command handler
+// that actually needs it (`cmdRun` / the info-validate-tree-version handlers
+// below), instead of eagerly at module top level.
+type EngineModule = typeof import('@ball-lang/engine');
+type CliCoreModule = typeof import('./cli_core.ts');
+
 const VERSION = readVersion();
 
 const USAGE = `ball — the Ball language CLI (v${VERSION})
@@ -29,7 +46,11 @@ USAGE
 
 COMMANDS
   run <program.ball.json>        Execute a Ball program and print stdout.
+  info <program.ball.json>       Inspect ball program structure.
+  validate <program.ball.json>   Check ball program validity.
+  tree <program.ball.json>       Print module/import structure.
   audit <program.ball.json>      Static capability analysis (I/O, fs, network, ...).
+  version                        Print version.
 
 OPTIONS
   -h, --help                     Print this help message.
@@ -187,6 +208,7 @@ async function cmdRun(args: ParsedArgs): Promise<number> {
     return 1;
   }
 
+  const { BallEngine }: EngineModule = await import('@ball-lang/engine');
   const program = loadProgram(programPath);
   const engine = new BallEngine(program as any, {
     stdout: (msg: string) => process.stdout.write(msg + '\n'),
@@ -205,6 +227,68 @@ async function cmdRun(args: ParsedArgs): Promise<number> {
   return 0;
 }
 
+// ── info / validate / tree ──────────────────────────────────────────────────
+//
+// All three delegate their report text to `cli_core.ts` (a thin wrapper over
+// `compiled_cli.ts`, compiled from `dart/shared/lib/cli_core.dart` — see
+// CLAUDE.md's "Regenerate compiled TS CLI core" recipe), so the computed
+// output is byte-identical to the native Dart CLI's (proven by
+// `test/cli_core_parity_test.ts`). Only argv parsing / usage-error text stays
+// TS-local, matching `cmdRun`/`cmdAudit`'s existing style.
+
+async function cmdInfo(args: ParsedArgs): Promise<number> {
+  const programPath = args.positional[0];
+  if (!programPath) {
+    process.stderr.write('ball: info requires a program path\n\n');
+    process.stderr.write(USAGE);
+    return 1;
+  }
+
+  const cliCore: CliCoreModule = await import('./cli_core.ts');
+  const program = loadProgram(programPath);
+  process.stdout.write(cliCore.infoReport(program) + '\n');
+  return 0;
+}
+
+async function cmdValidate(args: ParsedArgs): Promise<number> {
+  const programPath = args.positional[0];
+  if (!programPath) {
+    process.stderr.write('ball: validate requires a program path\n\n');
+    process.stderr.write(USAGE);
+    return 1;
+  }
+
+  const cliCore: CliCoreModule = await import('./cli_core.ts');
+  const program = loadProgram(programPath);
+  const report = cliCore.validateReport(program);
+  if (cliCore.validateOk(program)) {
+    process.stdout.write(report + '\n');
+    return 0;
+  }
+  process.stderr.write(report + '\n');
+  return 1;
+}
+
+async function cmdTree(args: ParsedArgs): Promise<number> {
+  const programPath = args.positional[0];
+  if (!programPath) {
+    process.stderr.write('ball: tree requires a program path\n\n');
+    process.stderr.write(USAGE);
+    return 1;
+  }
+
+  const cliCore: CliCoreModule = await import('./cli_core.ts');
+  const program = loadProgram(programPath);
+  process.stdout.write(cliCore.treeReport(program) + '\n');
+  return 0;
+}
+
+async function cmdVersion(): Promise<number> {
+  const cliCore: CliCoreModule = await import('./cli_core.ts');
+  process.stdout.write(`${cliCore.versionLine(VERSION)}\n`);
+  return 0;
+}
+
 function cmdAudit(args: ParsedArgs): number {
   const programPath = args.positional[0];
   if (!programPath) {
@@ -266,15 +350,25 @@ async function main(argv: string[]): Promise<number> {
   }
 
   if (args.flags['version'] === true || args.flags['v'] === true) {
-    process.stdout.write(`${VERSION}\n`);
-    return 0;
+    // Matches the Dart CLI's `version`/`--version`/`-v` cases (all three
+    // dispatch to the same `cli_core.versionLine`) — see the `case 'version'`
+    // branch below for the bare-command spelling.
+    return await cmdVersion();
   }
 
   switch (args.command) {
     case 'run':
       return await cmdRun(args);
+    case 'info':
+      return await cmdInfo(args);
+    case 'validate':
+      return await cmdValidate(args);
+    case 'tree':
+      return await cmdTree(args);
     case 'audit':
       return cmdAudit(args);
+    case 'version':
+      return await cmdVersion();
     case undefined:
       process.stdout.write(USAGE);
       return 0;