cobolx-2 1.2.3

package/runtime/src/time_travel/index.ts

@@ -0,0 +1,54 @@
+import fs from "node:fs";
+
+export interface TimelineEntry {
+  step: number;
+  action: string;
+  state: Record<string, unknown>;
+  at: string;
+}
+
+export class TimeTravelDebugger {
+  private readonly timeline: TimelineEntry[] = [];
+  private state: Record<string, unknown> = {};
+  private step = 0;
+
+  constructor(private readonly traceFile?: string) {}
+
+  set(name: string, value: unknown): void {
+    this.state = { ...this.state, [name]: value };
+    this.record(`set:${name}`);
+  }
+
+  record(action: string): void {
+    this.timeline.push({
+      step: this.step,
+      action,
+      state: structuredClone(this.state),
+      at: new Date().toISOString()
+    });
+    this.step += 1;
+    this.flush();
+  }
+
+  snapshot(): TimelineEntry[] {
+    return [...this.timeline];
+  }
+
+  rewind(step: number): TimelineEntry | undefined {
+    return this.timeline.find((entry) => entry.step === step);
+  }
+
+  latest(): TimelineEntry | undefined {
+    return this.timeline.at(-1);
+  }
+
+  private flush(): void {
+    if (!this.traceFile) return;
+    fs.writeFileSync(this.traceFile, JSON.stringify(this.timeline, null, 2), "utf8");
+  }
+}
+
+export function loadTimeline(traceFile: string): TimelineEntry[] {
+  if (!fs.existsSync(traceFile)) return [];
+  return JSON.parse(fs.readFileSync(traceFile, "utf8")) as TimelineEntry[];
+}

package/runtime/src/workflows/index.ts

@@ -0,0 +1,35 @@
+export interface WorkflowStepContext {
+  attempts: number;
+}
+
+export interface WorkflowStep {
+  name: string;
+  timeoutMs?: number;
+  retries?: number;
+  run: (context: WorkflowStepContext) => Promise<void> | void;
+}
+
+export class WorkflowEngine {
+  constructor(private readonly steps: WorkflowStep[]) {}
+
+  async execute(): Promise<void> {
+    for (const step of this.steps) {
+      let attempts = 0;
+      const retries = step.retries ?? 0;
+      while (true) {
+        attempts += 1;
+        try {
+          await Promise.race([
+            Promise.resolve(step.run({ attempts })),
+            new Promise((_, reject) =>
+              step.timeoutMs ? setTimeout(() => reject(new Error(`Workflow step '${step.name}' timed out`)), step.timeoutMs) : undefined
+            )
+          ]);
+          break;
+        } catch (error) {
+          if (attempts > retries + 1) throw error;
+        }
+      }
+    }
+  }
+}

package/runtime/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist"
+  },
+  "include": ["src/**/*.ts"]
+}

package/sample-payroll/README.md

@@ -0,0 +1,3 @@
+# sample-payroll
+
+Generated with COBOLX.

package/sample-payroll/cobolx.toml

@@ -0,0 +1,3 @@
+name = "sample-payroll"
+version = "0.1.0"
+entry = "src/main.cbx"

package/sample-payroll/src/main.cbx

@@ -0,0 +1,5 @@
+PROGRAM samplepayroll
+
+BEGIN
+DISPLAY "Hello from COBOLX"
+END

package/stdlib/business/index.js

@@ -0,0 +1,15 @@
+import { audit } from "../../runtime/dist/index.js";
+
+export function requireRole(activeRoles, requiredRole) {
+  const allowed = activeRoles.includes(requiredRole);
+  audit("security", "role-check", { requiredRole, allowed });
+  if (!allowed) {
+    throw new Error(`Missing required role: ${requiredRole}`);
+  }
+}
+
+export function evaluateRule(name, predicate) {
+  const outcome = Boolean(predicate());
+  audit("business-rule", name, { outcome });
+  return outcome;
+}

package/stdlib/core/README.md

@@ -0,0 +1,8 @@
+# COBOLX Core Standard Library
+
+Runtime helpers exposed to generated JavaScript:
+
+- `display(value)`
+- `input(promptText?)`
+- `math.abs`, `math.floor`, `math.ceil`, `math.round`, `math.max`, `math.min`, `math.sqrt`, `math.pow`
+- `strings.length`, `strings.upper`, `strings.lower`, `strings.concat`

package/stdlib/core/runtime.js

@@ -0,0 +1,191 @@
+import fs from "node:fs";
+
+export function display(value) {
+  console.log(value);
+}
+
+export function input(promptText = "") {
+  if (promptText) {
+    process.stdout.write(String(promptText));
+  }
+  const buffer = fs.readFileSync(0, "utf8");
+  return buffer.toString().trimEnd();
+}
+
+export const math = {
+  abs: Math.abs,
+  floor: Math.floor,
+  ceil: Math.ceil,
+  round: Math.round,
+  max: Math.max,
+  min: Math.min,
+  sqrt: Math.sqrt,
+  pow: Math.pow
+};
+
+export const strings = {
+  length(value) {
+    return String(value).length;
+  },
+  upper(value) {
+    return String(value).toUpperCase();
+  },
+  lower(value) {
+    return String(value).toLowerCase();
+  },
+  concat(...values) {
+    return values.map((value) => String(value)).join("");
+  }
+};
+
+export const Result = {
+  ok(value) {
+    return { tag: "OK", values: [value] };
+  },
+  err(error) {
+    return { tag: "ERR", values: [error] };
+  }
+};
+
+export const Option = {
+  some(value) {
+    return { tag: "SOME", values: [value] };
+  },
+  none() {
+    return { tag: "NONE", values: [] };
+  }
+};
+
+export function iter(items) {
+  return {
+    items: [...items],
+    map(fn) {
+      return iter(this.items.map(fn));
+    },
+    filter(fn) {
+      return iter(this.items.filter(fn));
+    },
+    reduce(fn, initial) {
+      return this.items.reduce(fn, initial);
+    },
+    collect() {
+      return [...this.items];
+    }
+  };
+}
+
+export function spawn(task) {
+  return Promise.resolve().then(() => task());
+}
+
+export function channel() {
+  const queue = [];
+  return {
+    send(value) {
+      queue.push(value);
+    },
+    receive() {
+      return queue.shift();
+    }
+  };
+}
+
+export function createDebuggerContext(traceFile = process.env.COBOLX_DEBUG_TRACE_FILE) {
+  const timeline = [];
+  const state = {};
+  return {
+    set(name, value) {
+      state[name] = value;
+      this.record(`set:${name}`);
+    },
+    record(action) {
+      timeline.push({
+        step: timeline.length,
+        action,
+        state: structuredClone(state),
+        at: new Date().toISOString()
+      });
+      if (traceFile) {
+        fs.writeFileSync(traceFile, JSON.stringify(timeline, null, 2), "utf8");
+      }
+    },
+    timeline() {
+      return [...timeline];
+    }
+  };
+}
+
+export function createEventBus() {
+  const handlers = new Map();
+  return {
+    on(name, handler) {
+      handlers.set(name, [...(handlers.get(name) ?? []), handler]);
+    },
+    async emit(name, payload) {
+      for (const handler of handlers.get(name) ?? []) {
+        await handler(payload);
+      }
+    }
+  };
+}
+
+export function createWorkflow(steps) {
+  return {
+    async run() {
+      for (const step of steps) {
+        let attempts = 0;
+        const retries = step.retries ?? 0;
+        while (true) {
+          attempts += 1;
+          try {
+            await Promise.resolve(step.run({ attempts }));
+            break;
+          } catch (error) {
+            if (attempts > retries + 1) throw error;
+          }
+        }
+      }
+    }
+  };
+}
+
+export function createVersionedState(initial) {
+  const history = [];
+  let version = 0;
+  const push = (value) => {
+    history.push({ version, value: structuredClone(value), at: new Date().toISOString() });
+    version += 1;
+  };
+  push(initial);
+  return {
+    set(value) {
+      push(value);
+    },
+    current() {
+      return history[history.length - 1];
+    },
+    rollback(targetVersion) {
+      return history.find((item) => item.version === targetVersion);
+    },
+    timeline() {
+      return [...history];
+    }
+  };
+}
+
+export function createSupervisor(maxRetries = 3) {
+  return {
+    async run(name, task) {
+      let attempt = 0;
+      while (attempt <= maxRetries) {
+        try {
+          await Promise.resolve(task());
+          return;
+        } catch (error) {
+          attempt += 1;
+          if (attempt > maxRetries) throw new Error(`Supervisor failed ${name}: ${String(error)}`);
+        }
+      }
+    }
+  };
+}

package/stdlib/crypto/index.js

@@ -0,0 +1,5 @@
+import crypto from "node:crypto";
+
+export function sha256(value) {
+  return crypto.createHash("sha256").update(String(value)).digest("hex");
+}

package/stdlib/datetime/index.js

@@ -0,0 +1,3 @@
+export function nowIso() {
+  return new Date().toISOString();
+}

package/stdlib/fs/index.js

@@ -0,0 +1,9 @@
+import fs from "node:fs";
+
+export function readText(path) {
+  return fs.readFileSync(path, "utf8");
+}
+
+export function writeText(path, contents) {
+  fs.writeFileSync(path, contents, "utf8");
+}

package/stdlib/http/index.js

@@ -0,0 +1,7 @@
+import http from "node:http";
+
+export function createServer(port, handler) {
+  const server = http.createServer((req, res) => handler(req, res));
+  server.listen(port);
+  return server;
+}

package/stdlib/io/index.js

@@ -0,0 +1 @@
+export { display, input } from "../core/runtime.js";

package/stdlib/json/index.js

@@ -0,0 +1,7 @@
+export function encode(value) {
+  return JSON.stringify(value);
+}
+
+export function decode(text) {
+  return JSON.parse(text);
+}

package/stdlib/net/index.js

@@ -0,0 +1,4 @@
+export async function getJson(url) {
+  const response = await fetch(url);
+  return await response.json();
+}

package/tests/macros.cbx

@@ -0,0 +1,10 @@
+PROGRAM Macros
+
+MACRO announce(value)
+BEGIN
+  DISPLAY value
+END-MACRO
+
+BEGIN
+  announce!("macro works")
+END

package/tests/pattern_match.cbx

@@ -0,0 +1,16 @@
+PROGRAM PatternMatch
+
+ENUM Result:
+OK(value)
+ERR(message)
+END
+
+BEGIN
+  LET result = OK(7)
+  MATCH result:
+  OK(value):
+    DISPLAY value
+  ERR(problem):
+    DISPLAY problem
+  END-MATCH
+END

package/tests/smoke.cbx

@@ -0,0 +1,7 @@
+PROGRAM Smoke
+
+BEGIN
+  SET left = 10
+  SET right = 20
+  DISPLAY left + right
+END

package/tests/validate-release.mjs

@@ -0,0 +1,54 @@
+import { mkdtempSync, rmSync, existsSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+const root = process.cwd();
+const cli = path.join(root, "cli", "cobolx-cli", "dist", "index.js");
+const tempRoot = mkdtempSync(path.join(tmpdir(), "cobolx-validate-"));
+
+function run(command, args, cwd = root) {
+  const result = spawnSync(process.execPath, [cli, command, ...args], {
+    cwd,
+    encoding: "utf8",
+    stdio: "pipe"
+  });
+  if ((result.status ?? 1) !== 0) {
+    throw new Error(`Command failed: cobolx ${command} ${args.join(" ")}\n${result.stdout}\n${result.stderr}`);
+  }
+  return `${result.stdout}${result.stderr}`;
+}
+
+try {
+  run("build", []);
+  run("test", []);
+  run("bench", []);
+
+  const projectDir = path.join(tempRoot, "release-app");
+  run("new", [projectDir, "api"]);
+  run("add", ["ledger", "1.2.3"], projectDir);
+  run("install", [], projectDir);
+  run("update", [], projectDir);
+  run("check", [], projectDir);
+  run("build", ["--release"], projectDir);
+  run("run", [], projectDir);
+  run("doc", [], projectDir);
+  run("generate", ["api"], projectDir);
+  run("generate", ["client", "typescript"], projectDir);
+  run("migrate", ["create", "init"], projectDir);
+  run("migrate", ["run"], projectDir);
+  run("visualize", [], projectDir);
+  run("deploy", [], projectDir);
+  run("debug", ["--rewind"], projectDir);
+
+  if (!existsSync(path.join(projectDir, "dist", "main.mjs"))) throw new Error("Missing built main.mjs");
+  if (!existsSync(path.join(projectDir, "dist", "debug-timeline.json"))) throw new Error("Missing debug timeline");
+  if (!existsSync(path.join(projectDir, "docs-output", "index.html"))) throw new Error("Missing generated docs");
+  if (!existsSync(path.join(projectDir, "generated", "deploy.json"))) throw new Error("Missing deploy metadata");
+  const deploy = JSON.parse(readFileSync(path.join(projectDir, "generated", "deploy.json"), "utf8"));
+  if (!deploy.service) throw new Error("Deploy metadata missing service name");
+
+  console.log("Release validation completed successfully");
+} finally {
+  rmSync(tempRoot, { recursive: true, force: true });
+}

package/tsconfig.base.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "strict": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "paths": {
+      "@cobolx/compiler": ["compiler/src/index.ts"],
+      "@cobolx/cargox": ["cargox/src/index.ts"],
+      "@cobolx/runtime": ["runtime/src/index.ts"],
+      "@cobolx/formatter": ["formatter/src/index.ts"],
+      "@cobolx/linter": ["linter/src/index.ts"],
+      "@cobolx/debugger": ["debugger/src/index.ts"],
+      "@cobolx/profiler": ["profiler/src/index.ts"]
+    },
+    "sourceMap": true
+  }
+}

package/vscode-extension/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 COBOL-X
+
+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/vscode-extension/README.md

@@ -0,0 +1,47 @@
+# COBOL-X VS Code Extension
+
+COBOL-X language support for Visual Studio Code.
+
+## Features
+
+- Language registration for `.cbx`, `.cob`, and `.col`
+- Syntax highlighting for COBOL-X keywords, functions, types, strings, comments, and numbers
+- LSP-backed diagnostics, hover information, and keyword completions
+- Snippets for common program, function, enum, and match scaffolds
+- Commands:
+  - `COBOL-X: Run File`
+  - `COBOL-X: Build Project`
+  - `COBOL-X: Open REPL`
+  - `COBOL-X: Debug Current Project`
+
+## Development
+
+```powershell
+npm install
+npm run build
+```
+
+Open the repository in VS Code and launch the extension development host with `F5`.
+
+Command execution uses the local repo CLI when the workspace contains the COBOL-X monorepo. In standalone projects, it falls back to a `cobolx` executable on your `PATH`.
+
+## Packaging
+
+```powershell
+npm install -g vsce
+cd vscode-extension
+npx @vscode/vsce package
+```
+
+Install the generated `.vsix` with:
+
+```powershell
+code --install-extension cobolx-1.0.0.vsix
+```
+
+## Publishing
+
+1. Create a publisher in Azure DevOps.
+2. Generate a Personal Access Token with Marketplace permissions.
+3. Login with `vsce login Magnexis`
+4. Publish with `vsce publish`

package/vscode-extension/icon.svg

@@ -0,0 +1,15 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 256" role="img" aria-labelledby="title desc">
+  <title>COBOL-X VS Code Extension Icon</title>
+  <desc>Rounded square logo with a C and X monogram over a blue-green gradient and a COBOL-X label.</desc>
+  <defs>
+    <linearGradient id="bg" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" stop-color="#0b3558"/>
+      <stop offset="100%" stop-color="#00a78b"/>
+    </linearGradient>
+  </defs>
+  <rect x="12" y="12" width="232" height="232" rx="52" fill="url(#bg)" stroke="rgba(255,255,255,0.45)" stroke-width="6"/>
+  <path d="M151 73c-14-14-38-17-57-7-20 10-33 31-33 54 0 24 13 45 33 55 19 10 43 7 57-7" fill="none" stroke="#fff0ad" stroke-width="18" stroke-linecap="round"/>
+  <path d="M136 73 208 183M208 73l-72 110" fill="none" stroke="#f5c14e" stroke-width="20" stroke-linecap="round"/>
+  <rect x="42" y="186" width="172" height="34" rx="17" fill="#071827" fill-opacity="0.88"/>
+  <text x="128" y="209" text-anchor="middle" font-family="Segoe UI, Arial, sans-serif" font-size="18" font-weight="700" fill="#ffffff">COBOL-X</text>
+</svg>

package/vscode-extension/language-configuration.json

@@ -0,0 +1,17 @@
+{
+  "comments": {
+    "lineComment": "*>"
+  },
+  "brackets": [["(", ")"], ["[", "]"]],
+  "autoClosingPairs": [
+    ["(", ")"],
+    ["[", "]"],
+    ["\"", "\""]
+  ],
+  "surroundingPairs": [
+    ["(", ")"],
+    ["[", "]"],
+    ["\"", "\""]
+  ],
+  "wordPattern": "(-?\\d*\\.\\d\\w*)|([A-Za-z_][A-Za-z0-9_-]*)"
+}