cobolx-2 1.2.3

package/cli/cobolx-cli/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@cobolx/cli",
+  "version": "0.2.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "bin": {
+    "cobolx": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "powershell -NoProfile -Command \"if (Test-Path dist) { Remove-Item -Recurse -Force dist }; tsc -p tsconfig.json; if (Test-Path 'dist\\\\cli\\\\cobolx-cli\\\\src') { Copy-Item -Recurse -Force 'dist\\\\cli\\\\cobolx-cli\\\\src\\\\*' dist }\"",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "clean": "if (Test-Path dist) { Remove-Item -Recurse -Force dist }"
+  },
+  "dependencies": {
+    "@cobolx/cargox": "0.2.0",
+    "@cobolx/compiler": "0.2.0",
+    "@cobolx/debugger": "0.2.0",
+    "@cobolx/formatter": "0.2.0",
+    "@cobolx/linter": "0.2.0",
+    "@cobolx/profiler": "0.2.0",
+    "@cobolx/runtime": "0.2.0"
+  }
+}

package/cli/cobolx-cli/src/commands/add.ts

@@ -0,0 +1,18 @@
+import { readManifest, resolveDependencyGraph, writeLockfile, writeManifest } from "@cobolx/cargox";
+import { lockfilePath, manifestPath } from "../project.js";
+
+export function runAddCommand(projectDir: string, dependencyName?: string, version = "0.1.0"): number {
+  if (!dependencyName) {
+    console.error("Usage: cobolx add <dependency> [version]");
+    return 1;
+  }
+
+  const manifestFile = manifestPath(projectDir);
+  const manifest = readManifest(manifestFile);
+  manifest.dependencies[dependencyName] = version;
+  writeManifest(manifestFile, manifest);
+  const graph = resolveDependencyGraph(manifest.package.name, manifest.dependencies);
+  writeLockfile(lockfilePath(projectDir), graph.root, graph.dependencies);
+  console.log(`Added dependency ${dependencyName}@${version}`);
+  return 0;
+}

package/cli/cobolx-cli/src/commands/bench.ts

@@ -0,0 +1,47 @@
+import fs from "node:fs";
+import path from "node:path";
+import { profile } from "@cobolx/profiler";
+import { CobolxError, compileFile, compilerStdlibDir, printDiagnostics } from "@cobolx/compiler";
+import { spawnSync } from "node:child_process";
+
+export async function runBenchCommand(projectDir: string): Promise<number> {
+  const benchmarksDir = path.join(projectDir, "benchmarks");
+  if (!fs.existsSync(benchmarksDir)) {
+    console.log("No benchmarks directory found");
+    return 0;
+  }
+  try {
+    const files = fs.readdirSync(benchmarksDir).filter((file) => file.endsWith(".cbx"));
+    const outDir = path.join(projectDir, "dist", "benchmarks");
+    fs.mkdirSync(outDir, { recursive: true });
+    let totalDuration = 0;
+    for (const file of files) {
+      const inputPath = path.join(benchmarksDir, file);
+      const outputPath = path.join(outDir, file.replace(/\.cbx$/i, ".mjs"));
+      const diagnostics = compileFile(inputPath, outputPath, compilerStdlibDir());
+      const hasErrors = diagnostics.some((diagnostic) => diagnostic.severity === "error");
+      if (diagnostics.length > 0) {
+        printDiagnostics(inputPath, diagnostics);
+        if (hasErrors) return 1;
+      }
+      const measurement = await profile(file, () => {
+        const result = spawnSync(process.execPath, [outputPath], {
+          cwd: projectDir,
+          encoding: "utf8",
+          stdio: "inherit"
+        });
+        return result.status ?? 1;
+      });
+      totalDuration += measurement.durationMs;
+      if (measurement.result !== 0) return measurement.result;
+    }
+    console.log(`Benchmarked ${files.length} file(s) in ${totalDuration.toFixed(2)}ms`);
+    return 0;
+  } catch (error) {
+    if (error instanceof CobolxError) {
+      console.error(error.message);
+      return 1;
+    }
+    throw error;
+  }
+}

package/cli/cobolx-cli/src/commands/build.ts

@@ -0,0 +1,74 @@
+import path from "node:path";
+import fs from "node:fs";
+import crypto from "node:crypto";
+import { fileURLToPath } from "node:url";
+import { CobolxError, compileFile, printDiagnostics } from "@cobolx/compiler";
+import { compilerStdlibDir } from "@cobolx/compiler";
+import { readManifest, manifestPath } from "../project.js";
+
+export interface BuildOptions {
+  release?: boolean;
+  target?: string;
+}
+
+const TOOLCHAIN_CACHE_VERSION = "1.0.0";
+
+function buildCachePath(projectDir: string): string {
+  return path.join(projectDir, ".cobolx-cache", "build.json");
+}
+
+function sourceHash(value: string): string {
+  return crypto.createHash("sha256").update(value).digest("hex");
+}
+
+function toolchainFingerprint(): string {
+  const currentFile = fileURLToPath(import.meta.url);
+  const toolchainFiles = [
+    currentFile,
+    path.resolve(path.dirname(currentFile), "../../../compiler/dist/index.js"),
+    path.resolve(path.dirname(currentFile), "../../../stdlib/core/runtime.js")
+  ];
+  return toolchainFiles
+    .filter((file) => fs.existsSync(file))
+    .map((file) => `${path.basename(file)}:${fs.statSync(file).mtimeMs}`)
+    .join("|");
+}
+
+export function runBuildCommand(projectDir: string, options: BuildOptions = {}): number {
+  try {
+    const manifest = readManifest(manifestPath(projectDir));
+    const inputPath = path.join(projectDir, manifest.package.entry);
+    const target = options.target ?? "node";
+    const outputPath = path.join(projectDir, "dist", target === "wasm" ? "main.wasm.mjs" : "main.mjs");
+    const source = fs.readFileSync(inputPath, "utf8");
+    const cachePath = buildCachePath(projectDir);
+    const cacheKey = sourceHash(`${TOOLCHAIN_CACHE_VERSION}:${toolchainFingerprint()}:${source}:${options.release ? "release" : "debug"}:${target}`);
+    if (fs.existsSync(cachePath)) {
+      const previous = JSON.parse(fs.readFileSync(cachePath, "utf8")) as { key?: string; outputPath?: string };
+      if (previous.key === cacheKey && previous.outputPath === outputPath && fs.existsSync(outputPath)) {
+        console.log(`Reused incremental build cache for ${outputPath}`);
+        return 0;
+      }
+    }
+    const diagnostics = compileFile(inputPath, outputPath, compilerStdlibDir());
+    const hasErrors = diagnostics.some((diagnostic) => diagnostic.severity === "error");
+
+    if (diagnostics.length > 0) {
+      printDiagnostics(inputPath, diagnostics);
+    }
+    if (hasErrors) {
+      return 1;
+    }
+
+    fs.mkdirSync(path.dirname(cachePath), { recursive: true });
+    fs.writeFileSync(cachePath, JSON.stringify({ key: cacheKey, outputPath, target, mode: options.release ? "release" : "debug" }, null, 2), "utf8");
+    console.log(`Built ${outputPath}${options.release ? " [release]" : " [debug]"}${target !== "node" ? ` target=${target}` : ""}`);
+    return 0;
+  } catch (error) {
+    if (error instanceof CobolxError) {
+      console.error(error.message);
+      return 1;
+    }
+    throw error;
+  }
+}

package/cli/cobolx-cli/src/commands/check.ts

@@ -0,0 +1,24 @@
+import path from "node:path";
+import { CobolxError, checkFile, printDiagnostics } from "@cobolx/compiler";
+import { readManifest, manifestPath } from "../project.js";
+
+export function runCheckCommand(projectDir: string): number {
+  try {
+    const manifest = readManifest(manifestPath(projectDir));
+    const inputPath = path.join(projectDir, manifest.package.entry);
+    const diagnostics = checkFile(inputPath);
+    const hasErrors = diagnostics.some((diagnostic) => diagnostic.severity === "error");
+    if (diagnostics.length > 0) {
+      printDiagnostics(inputPath, diagnostics);
+      if (hasErrors) return 1;
+    }
+    console.log("Check completed successfully");
+    return 0;
+  } catch (error) {
+    if (error instanceof CobolxError) {
+      console.error(error.message);
+      return 1;
+    }
+    throw error;
+  }
+}

package/cli/cobolx-cli/src/commands/debug.ts

@@ -0,0 +1,15 @@
+import path from "node:path";
+import { debugNodeProgram } from "@cobolx/debugger";
+import { runBuildCommand } from "./build.js";
+import { runDebugRewindCommand } from "./debug_rewind.js";
+
+export function runDebugCommand(projectDir: string, rewind = false): number {
+  if (rewind) {
+    return runDebugRewindCommand(projectDir);
+  }
+  const buildExit = runBuildCommand(projectDir);
+  if (buildExit !== 0) {
+    return buildExit;
+  }
+  return debugNodeProgram(path.join(projectDir, "dist", "main.mjs"));
+}

package/cli/cobolx-cli/src/commands/debug_rewind.ts

@@ -0,0 +1,16 @@
+import fs from "node:fs";
+import path from "node:path";
+import { loadTimeline } from "@cobolx/runtime";
+
+export function runDebugRewindCommand(projectDir: string): number {
+  const tracePath = path.join(projectDir, "dist", "debug-timeline.json");
+  if (!fs.existsSync(tracePath)) {
+    console.error(`No debug trace found at ${tracePath}. Run the program with tracing first.`);
+    return 1;
+  }
+  const timeline = loadTimeline(tracePath);
+  for (const entry of timeline.slice().reverse()) {
+    console.log(`[rewind step ${entry.step}] ${entry.action} ${JSON.stringify(entry.state)}`);
+  }
+  return 0;
+}

package/cli/cobolx-cli/src/commands/deploy.ts

@@ -0,0 +1,18 @@
+import fs from "node:fs";
+import path from "node:path";
+import { discoverService, healthCheck, registerService } from "@cobolx/runtime";
+import { runBuildCommand } from "./build.js";
+
+export function runDeployCommand(projectDir: string): number {
+  const built = runBuildCommand(projectDir, { release: true });
+  if (built !== 0) return built;
+  const serviceName = path.basename(projectDir);
+  const address = `node://${serviceName}`;
+  registerService(serviceName, address);
+  const status = healthCheck(serviceName, true, { address });
+  const out = path.join(projectDir, "generated", "deploy.json");
+  fs.mkdirSync(path.dirname(out), { recursive: true });
+  fs.writeFileSync(out, JSON.stringify({ service: serviceName, address, status, discovered: discoverService(serviceName) }, null, 2), "utf8");
+  console.log(`Deployed ${serviceName} to ${address}`);
+  return 0;
+}

package/cli/cobolx-cli/src/commands/dev.ts

@@ -0,0 +1,24 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { readManifest, manifestPath } from "../project.js";
+import { runBuildCommand } from "./build.js";
+
+export function runDevCommand(projectDir: string): number {
+  const manifest = readManifest(manifestPath(projectDir));
+  const sourcePath = path.join(projectDir, manifest.package.entry);
+  let child: ReturnType<typeof spawn> | undefined;
+
+  const restart = (): void => {
+    child?.kill();
+    const built = runBuildCommand(projectDir);
+    if (built !== 0) return;
+    const output = path.join(projectDir, "dist", "main.mjs");
+    child = spawn(process.execPath, [output], { cwd: projectDir, stdio: "inherit" });
+  };
+
+  restart();
+  fs.watch(sourcePath, { persistent: true }, () => restart());
+  console.log(`Watching ${sourcePath} for hot reload changes. Press Ctrl+C to stop.`);
+  return 0;
+}

package/cli/cobolx-cli/src/commands/doc.ts

@@ -0,0 +1,19 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parseSource } from "@cobolx/compiler";
+import { readManifest, manifestPath } from "../project.js";
+
+export function runDocCommand(projectDir: string): number {
+  const manifest = readManifest(manifestPath(projectDir));
+  const sourcePath = path.join(projectDir, manifest.package.entry);
+  const source = fs.readFileSync(sourcePath, "utf8");
+  const program = parseSource(source);
+  const outputDir = path.join(projectDir, "docs-output");
+  fs.mkdirSync(outputDir, { recursive: true });
+  const html = `<!doctype html><html><body><h1>${program.name}</h1><h2>Functions</h2><ul>${program.functions
+    .map((fn) => `<li><strong>${fn.signature.name}</strong><p>${(fn.docs ?? []).join(" ")}</p></li>`)
+    .join("")}</ul><h2>Traits</h2><ul>${program.traits.map((trait) => `<li>${trait.name}</li>`).join("")}</ul></body></html>`;
+  fs.writeFileSync(path.join(outputDir, "index.html"), html, "utf8");
+  console.log(`Generated docs at ${path.join(outputDir, "index.html")}`);
+  return 0;
+}

package/cli/cobolx-cli/src/commands/fmt.ts

@@ -0,0 +1,14 @@
+import fs from "node:fs";
+import path from "node:path";
+import { formatSource } from "@cobolx/formatter";
+import { readManifest } from "@cobolx/cargox";
+import { manifestPath } from "../project.js";
+
+export function runFmtCommand(projectDir: string): number {
+  const manifest = readManifest(manifestPath(projectDir));
+  const inputPath = path.join(projectDir, manifest.package.entry);
+  const source = fs.readFileSync(inputPath, "utf8");
+  fs.writeFileSync(inputPath, formatSource(source), "utf8");
+  console.log(`Formatted ${inputPath}`);
+  return 0;
+}

package/cli/cobolx-cli/src/commands/fuzz.ts

@@ -0,0 +1,24 @@
+import fs from "node:fs";
+import path from "node:path";
+import { CobolxError, analyzeSource } from "@cobolx/compiler";
+import { readManifest, manifestPath } from "../project.js";
+
+export function runFuzzCommand(projectDir: string, target = "parser"): number {
+  const manifest = readManifest(manifestPath(projectDir));
+  const sourcePath = path.join(projectDir, manifest.package.entry);
+  const source = fs.readFileSync(sourcePath, "utf8");
+  const seeds = [source, source.replace(/DISPLAY/g, "DISPLAY"), source.slice(0, Math.max(1, source.length - 1)), `${source}\nDISPLAY "fuzz"`];
+  for (const seed of seeds) {
+    try {
+      analyzeSource(seed);
+    } catch (error) {
+      if (error instanceof CobolxError) {
+        continue;
+      }
+      console.error(`Fuzz case crashed ${target}: ${String(error)}`);
+      return 1;
+    }
+  }
+  console.log(`Fuzzed ${target} with ${seeds.length} mutated inputs`);
+  return 0;
+}

package/cli/cobolx-cli/src/commands/generate.ts

@@ -0,0 +1,38 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parseSource } from "@cobolx/compiler";
+import { readManifest, manifestPath } from "../project.js";
+
+export function runGenerateCommand(projectDir: string, target?: string, arg?: string): number {
+  const generatedDir = path.join(projectDir, "generated");
+  fs.mkdirSync(generatedDir, { recursive: true });
+
+  if (target === "api") {
+    const file = path.join(generatedDir, "api.cbx");
+    fs.writeFileSync(file, 'PROGRAM Api\n\nBEGIN\nDISPLAY "Generated API"\nEND\n', "utf8");
+    console.log(`Generated ${file}`);
+    return 0;
+  }
+
+  if (target === "model" && arg) {
+    const file = path.join(generatedDir, `${arg}.cbx`);
+    fs.writeFileSync(file, `PROGRAM ${arg}\n\nBEGIN\nDISPLAY "${arg}"\nEND\n`, "utf8");
+    console.log(`Generated ${file}`);
+    return 0;
+  }
+
+  if (target === "client" && arg === "typescript") {
+    const manifest = readManifest(manifestPath(projectDir));
+    const source = fs.readFileSync(path.join(projectDir, manifest.package.entry), "utf8");
+    const program = parseSource(source);
+    const file = path.join(generatedDir, "client-types.ts");
+    const enums = program.enums.map((item) => `export type ${item.name} = ${item.variants.map((variant) => `'${variant.name}'`).join(" | ")};`).join("\n");
+    const functions = program.functions.map((fn) => `export function ${fn.signature.name}(...args: unknown[]): Promise<unknown>;`).join("\n");
+    fs.writeFileSync(file, `${enums}\n${functions}\n`, "utf8");
+    console.log(`Generated ${file}`);
+    return 0;
+  }
+
+  console.error("Usage: cobolx generate <api|model <Name>|client typescript>");
+  return 1;
+}

package/cli/cobolx-cli/src/commands/install.ts

@@ -0,0 +1,25 @@
+import fs from "node:fs";
+import path from "node:path";
+import { readManifest, resolveDependencyGraph, writeLockfile } from "@cobolx/cargox";
+import { lockfilePath, manifestPath } from "../project.js";
+
+export function runInstallCommand(projectDir: string): number {
+  const manifest = readManifest(manifestPath(projectDir));
+  const graph = resolveDependencyGraph(manifest.package.name, manifest.dependencies);
+  const packagesDir = path.join(projectDir, ".cargox", "packages");
+  fs.mkdirSync(packagesDir, { recursive: true });
+
+  for (const [name, version] of Object.entries(graph.dependencies)) {
+    const packageDir = path.join(packagesDir, `${name}-${version}`);
+    fs.mkdirSync(packageDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(packageDir, "manifest.json"),
+      JSON.stringify({ name, version, installedAt: new Date().toISOString() }, null, 2),
+      "utf8"
+    );
+  }
+
+  writeLockfile(lockfilePath(projectDir), graph.root, graph.dependencies);
+  console.log(`Installed ${Object.keys(graph.dependencies).length} package(s)`);
+  return 0;
+}

package/cli/cobolx-cli/src/commands/legacy.ts

@@ -0,0 +1,17 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export function runLegacyConvertCommand(projectDir: string, legacyPath?: string): number {
+  if (!legacyPath) {
+    console.error("Usage: cobolx legacy <path-to-.cob/.col>");
+    return 1;
+  }
+  const source = fs.readFileSync(path.resolve(projectDir, legacyPath), "utf8");
+  const programName = /PROGRAM-ID\.\s+([A-Za-z0-9_-]+)/i.exec(source)?.[1] ?? "Legacy";
+  const converted = `PROGRAM ${programName}\n\nBEGIN\nDISPLAY "Converted legacy COBOL program ${programName}"\nEND\n`;
+  const output = path.join(projectDir, "generated", `${programName}.cbx`);
+  fs.mkdirSync(path.dirname(output), { recursive: true });
+  fs.writeFileSync(output, converted, "utf8");
+  console.log(`Converted legacy COBOL to ${output}`);
+  return 0;
+}

package/cli/cobolx-cli/src/commands/lint.ts

@@ -0,0 +1,17 @@
+import fs from "node:fs";
+import path from "node:path";
+import { formatDiagnostic } from "@cobolx/compiler";
+import type { Diagnostic } from "@cobolx/compiler";
+import { lintSource } from "@cobolx/linter";
+import { readManifest } from "@cobolx/cargox";
+import { manifestPath } from "../project.js";
+
+export function runLintCommand(projectDir: string): number {
+  const manifest = readManifest(manifestPath(projectDir));
+  const inputPath = path.join(projectDir, manifest.package.entry);
+  const diagnostics = lintSource(fs.readFileSync(inputPath, "utf8"));
+  for (const diagnostic of diagnostics as Diagnostic[]) {
+    console.log(formatDiagnostic(inputPath, diagnostic));
+  }
+  return diagnostics.some((diagnostic) => diagnostic.severity === "error") ? 1 : 0;
+}

package/cli/cobolx-cli/src/commands/migrate.ts

@@ -0,0 +1,27 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export function runMigrateCreateCommand(projectDir: string, name = "migration"): number {
+  const migrationsDir = path.join(projectDir, "migrations");
+  fs.mkdirSync(migrationsDir, { recursive: true });
+  const timestamp = new Date().toISOString().replace(/[-:.TZ]/g, "").slice(0, 14);
+  const file = path.join(migrationsDir, `${timestamp}_${name}.sql`);
+  fs.writeFileSync(file, "-- Write migration SQL here\n", "utf8");
+  console.log(`Created migration ${file}`);
+  return 0;
+}
+
+export function runMigrateRunCommand(projectDir: string): number {
+  const migrationsDir = path.join(projectDir, "migrations");
+  const stateFile = path.join(projectDir, ".cobolx-cache", "migrations.json");
+  fs.mkdirSync(path.dirname(stateFile), { recursive: true });
+  const applied = fs.existsSync(stateFile) ? new Set<string>(JSON.parse(fs.readFileSync(stateFile, "utf8"))) : new Set<string>();
+  const files = fs.existsSync(migrationsDir) ? fs.readdirSync(migrationsDir).filter((file) => file.endsWith(".sql")).sort() : [];
+  for (const file of files) {
+    if (applied.has(file)) continue;
+    console.log(`Applying migration ${file}`);
+    applied.add(file);
+  }
+  fs.writeFileSync(stateFile, JSON.stringify([...applied], null, 2), "utf8");
+  return 0;
+}

package/cli/cobolx-cli/src/commands/new.ts

@@ -0,0 +1,20 @@
+import fs from "node:fs";
+import path from "node:path";
+import { scaffoldProject } from "../project.js";
+
+export function runNewCommand(projectName?: string, template = "default"): number {
+  if (!projectName) {
+    console.error("Usage: cobolx new <project-name> [default|api|microservice|cli]");
+    return 1;
+  }
+
+  const targetDir = path.resolve(projectName);
+  if (fs.existsSync(targetDir)) {
+    console.error(`Directory already exists: ${targetDir}`);
+    return 1;
+  }
+
+  scaffoldProject(targetDir, projectName, template);
+  console.log(`Created COBOLX project at ${targetDir}`);
+  return 0;
+}

package/cli/cobolx-cli/src/commands/profile.ts

@@ -0,0 +1,8 @@
+import { profile } from "@cobolx/profiler";
+import { runRunCommand } from "./run.js";
+
+export async function runProfileCommand(projectDir: string): Promise<number> {
+  const measurement = await profile("run", () => runRunCommand(projectDir));
+  console.log(`Profile: ${measurement.label} completed in ${measurement.durationMs.toFixed(2)}ms`);
+  return measurement.result;
+}

package/cli/cobolx-cli/src/commands/publish.ts

@@ -0,0 +1,16 @@
+import fs from "node:fs";
+import path from "node:path";
+import { publishToLocalRegistry, readManifest } from "@cobolx/cargox";
+import { manifestPath } from "../project.js";
+
+export function runPublishCommand(projectDir: string): number {
+  const manifest = readManifest(manifestPath(projectDir));
+  const entryPath = path.join(projectDir, manifest.package.entry);
+  const registryDir = path.join(projectDir, ".cargox-registry");
+  const publishedDir = publishToLocalRegistry(registryDir, manifest.package.name, manifest.package.version, [
+    { path: "cobolx.toml", content: fs.readFileSync(manifestPath(projectDir), "utf8") },
+    { path: manifest.package.entry, content: fs.readFileSync(entryPath, "utf8") }
+  ]);
+  console.log(`Published ${manifest.package.name}@${manifest.package.version} to ${publishedDir}`);
+  return 0;
+}

package/cli/cobolx-cli/src/commands/repl.ts

@@ -0,0 +1,30 @@
+import readline from "node:readline";
+import { analyzeSource, compileSource, compilerStdlibDir } from "@cobolx/compiler";
+
+export async function runReplCommand(): Promise<number> {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout, prompt: "cobolx> " });
+  console.log("COBOL-X REPL. Enter DISPLAY expressions or PROGRAM blocks. Type .exit to quit.");
+  rl.prompt();
+
+  return await new Promise<number>((resolve) => {
+    rl.on("line", (line) => {
+      if (line.trim() === ".exit") {
+        rl.close();
+        return;
+      }
+      const source = line.trim().startsWith("PROGRAM") ? line : `PROGRAM Repl\n\nBEGIN\n${line}\nEND\n`;
+      try {
+        const result = compileSource(source, "repl.mjs", compilerStdlibDir());
+        if (result.diagnostics.length > 0) {
+          console.log(result.diagnostics.map((d) => d.message).join("\n"));
+        } else {
+          console.log("ok");
+        }
+      } catch (error) {
+        console.error(String(error));
+      }
+      rl.prompt();
+    });
+    rl.on("close", () => resolve(0));
+  });
+}

package/cli/cobolx-cli/src/commands/run.ts

@@ -0,0 +1,22 @@
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { type BuildOptions, runBuildCommand } from "./build.js";
+
+export function runRunCommand(projectDir: string, options: BuildOptions = {}): number {
+  const buildExitCode = runBuildCommand(projectDir, options);
+  if (buildExitCode !== 0) {
+    return buildExitCode;
+  }
+
+  const builtFile = path.join(projectDir, "dist", options.target === "wasm" ? "main.wasm.mjs" : "main.mjs");
+  const traceFile = path.join(projectDir, "dist", "debug-timeline.json");
+  const result = spawnSync(process.execPath, [builtFile], {
+    cwd: projectDir,
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      COBOLX_DEBUG_TRACE_FILE: traceFile
+    }
+  });
+  return result.status ?? 1;
+}

package/cli/cobolx-cli/src/commands/task.ts

@@ -0,0 +1,27 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+export function runTaskCommand(projectDir: string, taskName = "build"): number {
+  const tasksFile = path.join(projectDir, "cobolx.tasks.json");
+  if (!fs.existsSync(tasksFile)) {
+    console.error("No cobolx.tasks.json found");
+    return 1;
+  }
+  const tasks = JSON.parse(fs.readFileSync(tasksFile, "utf8")) as Record<string, string[]>;
+  const steps = tasks[taskName];
+  if (!steps) {
+    console.error(`Task '${taskName}' not found`);
+    return 1;
+  }
+  for (const step of steps) {
+    const cliEntry = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../index.js");
+    const result = spawnSync(process.execPath, [cliEntry, ...step.split(" ")], {
+      cwd: projectDir,
+      stdio: "inherit"
+    });
+    if ((result.status ?? 1) !== 0) return result.status ?? 1;
+  }
+  return 0;
+}

package/cli/cobolx-cli/src/commands/test.ts

@@ -0,0 +1,44 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { CobolxError, compileFile, compilerStdlibDir, printDiagnostics } from "@cobolx/compiler";
+
+export function runTestCommand(projectDir: string): number {
+  const testsDir = path.join(projectDir, "tests");
+  if (!fs.existsSync(testsDir)) {
+    console.log("No tests directory found");
+    return 0;
+  }
+  try {
+    const files = fs.readdirSync(testsDir).filter((file) => file.endsWith(".cbx"));
+    const outDir = path.join(projectDir, "dist", "tests");
+    fs.mkdirSync(outDir, { recursive: true });
+      for (const file of files) {
+        const inputPath = path.join(testsDir, file);
+        const outputPath = path.join(outDir, file.replace(/\.cbx$/i, ".mjs"));
+        const diagnostics = compileFile(inputPath, outputPath, compilerStdlibDir());
+        const hasErrors = diagnostics.some((diagnostic) => diagnostic.severity === "error");
+        if (diagnostics.length > 0) {
+          printDiagnostics(inputPath, diagnostics);
+          if (hasErrors) return 1;
+        }
+        const result = spawnSync(process.execPath, [outputPath], {
+          cwd: projectDir,
+        encoding: "utf8",
+        stdio: "inherit"
+      });
+        if ((result.status ?? 1) !== 0) {
+        console.error(`Test failed: ${file}`);
+        return result.status ?? 1;
+      }
+    }
+    console.log(`Executed ${files.length} test file(s)`);
+    return 0;
+  } catch (error) {
+    if (error instanceof CobolxError) {
+      console.error(error.message);
+      return 1;
+    }
+    throw error;
+  }
+}