cobolx-2 1.2.3

package/lsp/server/src/index.ts

@@ -0,0 +1,168 @@
+import {
+  CompletionItemKind,
+  createConnection,
+  DiagnosticSeverity,
+  Hover,
+  InitializeParams,
+  ProposedFeatures,
+  TextDocuments,
+  TextDocumentSyncKind
+} from "vscode-languageserver/node.js";
+import { TextDocument } from "vscode-languageserver-textdocument";
+import { analyzeSource, CobolxError } from "@cobolx/compiler";
+
+const connection = createConnection(ProposedFeatures.all);
+const documents = new TextDocuments(TextDocument);
+
+const KEYWORD_COMPLETIONS = [
+  "PROGRAM",
+  "BEGIN",
+  "END",
+  "SET",
+  "DISPLAY",
+  "INPUT",
+  "IF",
+  "THEN",
+  "ELSE",
+  "END-IF",
+  "FUNCTION",
+  "RETURN",
+  "END-FUNCTION",
+  "TRUE",
+  "FALSE"
+];
+
+connection.onInitialize((_params: InitializeParams) => ({
+  capabilities: {
+    textDocumentSync: TextDocumentSyncKind.Incremental,
+    completionProvider: {},
+    hoverProvider: true
+  }
+}));
+
+documents.onDidChangeContent(({ document }) => {
+  validateDocument(document);
+});
+
+documents.onDidOpen(({ document }) => {
+  validateDocument(document);
+});
+
+connection.onCompletion(() =>
+  KEYWORD_COMPLETIONS.map((label) => ({
+    label,
+    kind: CompletionItemKind.Keyword
+  }))
+);
+
+connection.onHover(({ textDocument, position }): Hover | null => {
+  const document = documents.get(textDocument.uri);
+  if (!document) {
+    return null;
+  }
+
+  const word = getWordAt(document, position.line, position.character);
+  if (!word) {
+    return null;
+  }
+
+  const keywordDocs: Record<string, string> = {
+    PROGRAM: "Declares the program name.",
+    BEGIN: "Starts the executable body.",
+    END: "Ends the program body.",
+    SET: "Assigns a variable from an expression.",
+    DISPLAY: "Prints a value to standard output.",
+    INPUT: "Reads a value from standard input.",
+    IF: "Starts a conditional block.",
+    THEN: "Separates an IF condition from its body.",
+    ELSE: "Starts the fallback branch of an IF block.",
+    "END-IF": "Closes an IF block.",
+    FUNCTION: "Declares a reusable function.",
+    RETURN: "Returns a value from a function.",
+    "END-FUNCTION": "Closes a function block."
+  };
+
+  const uppercase = word.toUpperCase();
+  if (keywordDocs[uppercase]) {
+    return {
+      contents: {
+        kind: "markdown",
+        value: `**${uppercase}**\n\n${keywordDocs[uppercase]}`
+      }
+    };
+  }
+
+  return {
+    contents: {
+      kind: "markdown",
+      value: `Identifier \`${word}\``
+    }
+  };
+});
+
+async function validateDocument(document: TextDocument): Promise<void> {
+  try {
+    const result = analyzeSource(document.getText());
+    connection.sendDiagnostics({
+      uri: document.uri,
+      diagnostics: result.diagnostics.map((diagnostic) => ({
+        severity: diagnostic.severity === "warning" ? DiagnosticSeverity.Warning : DiagnosticSeverity.Error,
+        range: {
+          start: {
+            line: diagnostic.range.start.line - 1,
+            character: diagnostic.range.start.column - 1
+          },
+          end: {
+            line: diagnostic.range.end.line - 1,
+            character: diagnostic.range.end.column - 1
+          }
+        },
+        message: diagnostic.message,
+        source: "cobolx"
+      }))
+    });
+  } catch (error) {
+    if (error instanceof CobolxError) {
+      connection.sendDiagnostics({
+        uri: document.uri,
+        diagnostics: [
+          {
+            severity: DiagnosticSeverity.Error,
+            range: {
+              start: {
+                line: error.diagnostic.range.start.line - 1,
+                character: error.diagnostic.range.start.column - 1
+              },
+              end: {
+                line: error.diagnostic.range.end.line - 1,
+                character: error.diagnostic.range.end.column - 1
+              }
+            },
+            message: error.diagnostic.message,
+            source: "cobolx"
+          }
+        ]
+      });
+    } else {
+      connection.console.error(String(error));
+    }
+  }
+}
+
+function getWordAt(document: TextDocument, line: number, character: number): string | null {
+  const text = document.getText();
+  const lines = text.split(/\r?\n/);
+  const current = lines[line] ?? "";
+  const matches = current.matchAll(/[A-Za-z_-][A-Za-z0-9_-]*/g);
+  for (const match of matches) {
+    const start = match.index ?? 0;
+    const end = start + match[0].length;
+    if (character >= start && character <= end) {
+      return match[0];
+    }
+  }
+  return null;
+}
+
+documents.listen(connection);
+connection.listen();

package/lsp/server/tsconfig.json

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

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "cobolx-2",
+  "version": "1.2.3",
+  "private": false,
+  "type": "module",
+  "workspaces": [
+    "compiler",
+    "runtime",
+    "cargox",
+    "cli/cobolx-cli",
+    "lsp/server",
+    "vscode-extension",
+    "formatter",
+    "linter",
+    "debugger",
+    "profiler"
+  ],
+  "scripts": {
+    "build": "npm run build --workspaces",
+    "check": "npm run check --workspaces",
+    "clean": "npm run clean --workspaces --if-present",
+    "test": "node cli/cobolx-cli/dist/index.js test",
+    "bench": "node cli/cobolx-cli/dist/index.js bench",
+    "validate": "node tests/validate-release.mjs"
+  },
+  "devDependencies": {
+    "@types/node": "^24.6.0",
+    "typescript": "^5.9.3"
+  }
+}

package/profiler/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@cobolx/profiler",
+  "version": "0.2.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "clean": "if (Test-Path dist) { Remove-Item -Recurse -Force dist }"
+  }
+}

package/profiler/src/index.d.ts

@@ -0,0 +1,5 @@
+export declare function profile<T>(label: string, action: () => Promise<T> | T): Promise<{
+    label: string;
+    durationMs: number;
+    result: T;
+}>;

package/profiler/src/index.js

@@ -0,0 +1,11 @@
+import { performance } from "node:perf_hooks";
+export async function profile(label, action) {
+    const start = performance.now();
+    const result = await Promise.resolve(action());
+    return {
+        label,
+        durationMs: performance.now() - start,
+        result
+    };
+}
+//# sourceMappingURL=index.js.map

package/profiler/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAE9C,MAAM,CAAC,KAAK,UAAU,OAAO,CAAI,KAAa,EAAE,MAA4B;IAC1E,MAAM,KAAK,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;IAChC,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAC/C,OAAO;QACL,KAAK;QACL,UAAU,EAAE,WAAW,CAAC,GAAG,EAAE,GAAG,KAAK;QACrC,MAAM;KACP,CAAC;AACJ,CAAC"}

package/profiler/src/index.ts

@@ -0,0 +1,11 @@
+import { performance } from "node:perf_hooks";
+
+export async function profile<T>(label: string, action: () => Promise<T> | T): Promise<{ label: string; durationMs: number; result: T }> {
+  const start = performance.now();
+  const result = await Promise.resolve(action());
+  return {
+    label,
+    durationMs: performance.now() - start,
+    result
+  };
+}

package/profiler/tsconfig.json

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

package/release.json

@@ -0,0 +1,10 @@
+{
+  "name": "cobolx",
+  "version": "0.3.0-dev",
+  "artifacts": [
+    "compiler/dist",
+    "cli/cobolx-cli/dist",
+    "lsp/server/dist",
+    "vscode-extension/dist"
+  ]
+}

package/runtime/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@cobolx/runtime",
+  "version": "0.2.0",
+  "type": "module",
+  "main": "./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\\\\runtime\\\\src') { Copy-Item -Recurse -Force 'dist\\\\runtime\\\\src\\\\*' dist }\"",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "clean": "if (Test-Path dist) { Remove-Item -Recurse -Force dist }"
+  },
+  "dependencies": {
+    "@cobolx/compiler": "0.2.0"
+  }
+}

package/runtime/src/actors/index.ts

@@ -0,0 +1,27 @@
+type Handler = (message: unknown) => void | Promise<void>;
+
+export class Actor {
+  private readonly mailbox: unknown[] = [];
+  private busy = false;
+
+  constructor(public readonly name: string, private readonly handler: Handler) {}
+
+  send(message: unknown): void {
+    this.mailbox.push(message);
+    void this.drain();
+  }
+
+  private async drain(): Promise<void> {
+    if (this.busy) return;
+    this.busy = true;
+    while (this.mailbox.length > 0) {
+      const message = this.mailbox.shift();
+      await this.handler(message);
+    }
+    this.busy = false;
+  }
+}
+
+export function createActor(name: string, handler: Handler): Actor {
+  return new Actor(name, handler);
+}

package/runtime/src/async/futures.ts

@@ -0,0 +1,11 @@
+export interface CobolxFuture<T> {
+  await(): Promise<T>;
+}
+
+export function futureOf<T>(factory: () => Promise<T> | T): CobolxFuture<T> {
+  return {
+    async await() {
+      return await Promise.resolve(factory());
+    }
+  };
+}

package/runtime/src/code_as_data/index.ts

@@ -0,0 +1,5 @@
+import { parseSource } from "@cobolx/compiler";
+
+export function inspectProgram(source: string) {
+  return parseSource(source);
+}

package/runtime/src/config/index.ts

@@ -0,0 +1,17 @@
+export interface ConfigDefinition<T> {
+  key: string;
+  defaultValue?: T;
+  env?: string;
+  parser?: (value: string) => T;
+}
+
+export function readConfig<T>(definition: ConfigDefinition<T>): T {
+  const envValue = definition.env ? process.env[definition.env] : undefined;
+  if (envValue !== undefined) {
+    return definition.parser ? definition.parser(envValue) : (envValue as T);
+  }
+  if (definition.defaultValue !== undefined) {
+    return definition.defaultValue;
+  }
+  throw new Error(`Missing configuration value for ${definition.key}`);
+}

package/runtime/src/distributed/index.ts

@@ -0,0 +1,13 @@
+const registry = new Map<string, string>();
+
+export function registerService(name: string, address: string): void {
+  registry.set(name, address);
+}
+
+export function discoverService(name: string): string | undefined {
+  return registry.get(name);
+}
+
+export function listServices(): Record<string, string> {
+  return Object.fromEntries(registry.entries());
+}

package/runtime/src/events/index.ts

@@ -0,0 +1,21 @@
+type EventHandler<T = unknown> = (payload: T) => Promise<void> | void;
+
+export class EventBus {
+  private readonly handlers = new Map<string, EventHandler[]>();
+
+  on<T>(eventName: string, handler: EventHandler<T>): void {
+    const existing = this.handlers.get(eventName) ?? [];
+    existing.push(handler as EventHandler);
+    this.handlers.set(eventName, existing);
+  }
+
+  async emit<T>(eventName: string, payload: T): Promise<void> {
+    for (const handler of this.handlers.get(eventName) ?? []) {
+      await handler(payload);
+    }
+  }
+}
+
+export function createEventBus(): EventBus {
+  return new EventBus();
+}

package/runtime/src/feature_flags/index.ts

@@ -0,0 +1,9 @@
+const flags = new Map<string, boolean>();
+
+export function setFeatureFlag(name: string, enabled: boolean): void {
+  flags.set(name, enabled);
+}
+
+export function featureEnabled(name: string): boolean {
+  return flags.get(name) ?? false;
+}

package/runtime/src/gc_or_arc/index.ts

@@ -0,0 +1 @@
+export { ArcBox } from "../memory/arc.js";

package/runtime/src/healing/index.ts

@@ -0,0 +1,26 @@
+export class Supervisor {
+  constructor(private readonly maxRetries = 3) {}
+
+  async run(name: string, task: () => Promise<void> | void): Promise<void> {
+    let attempt = 0;
+    while (attempt <= this.maxRetries) {
+      try {
+        await Promise.resolve(task());
+        return;
+      } catch (error) {
+        attempt += 1;
+        if (attempt > this.maxRetries) throw new Error(`Supervisor failed '${name}': ${String(error)}`);
+      }
+    }
+  }
+}
+
+export interface HealthStatus {
+  name: string;
+  healthy: boolean;
+  details?: Record<string, unknown>;
+}
+
+export function healthCheck(name: string, healthy: boolean, details?: Record<string, unknown>): HealthStatus {
+  return { name, healthy, details };
+}

package/runtime/src/index.ts

@@ -0,0 +1,20 @@
+export { ArcBox } from "./memory/arc.js";
+export { TaskScheduler } from "./scheduler/taskScheduler.js";
+export { futureOf } from "./async/futures.js";
+export { audit, getAuditTrail } from "./std_hooks/audit.js";
+export { readConfig } from "./config/index.js";
+export { log, incrementMetric, getMetrics, trace, getTraces } from "./observability/index.js";
+export { setFeatureFlag, featureEnabled } from "./feature_flags/index.js";
+export { getSecret, setSecret } from "./security/secrets.js";
+export type { DatabaseCapability, FileCapability, NetworkCapability, SecretCapability } from "./security/capabilities.js";
+export { Actor, createActor } from "./actors/index.js";
+export { discoverService, listServices, registerService } from "./distributed/index.js";
+export { createReplContext } from "./repl/context.js";
+export { CobolxIterator, iter } from "./iterators/index.js";
+export { TimeTravelDebugger, loadTimeline } from "./time_travel/index.js";
+export { EventBus, createEventBus } from "./events/index.js";
+export { WorkflowEngine } from "./workflows/index.js";
+export { Supervisor, healthCheck } from "./healing/index.js";
+export { VersionedState } from "./state/versioned.js";
+export { normalizeIntent } from "./intents/index.js";
+export { inspectProgram } from "./code_as_data/index.js";

package/runtime/src/intents/index.ts

@@ -0,0 +1,9 @@
+export interface ExecutionIntent {
+  optimizeFor?: "speed" | "memory" | "throughput";
+}
+
+export function normalizeIntent(intent?: ExecutionIntent): Required<ExecutionIntent> {
+  return {
+    optimizeFor: intent?.optimizeFor ?? "speed"
+  };
+}

package/runtime/src/iterators/index.ts

@@ -0,0 +1,23 @@
+export class CobolxIterator<T> {
+  constructor(private readonly items: T[]) {}
+
+  map<U>(fn: (value: T) => U): CobolxIterator<U> {
+    return new CobolxIterator(this.items.map(fn));
+  }
+
+  filter(fn: (value: T) => boolean): CobolxIterator<T> {
+    return new CobolxIterator(this.items.filter(fn));
+  }
+
+  reduce<U>(fn: (acc: U, value: T) => U, initial: U): U {
+    return this.items.reduce(fn, initial);
+  }
+
+  collect(): T[] {
+    return [...this.items];
+  }
+}
+
+export function iter<T>(items: T[]): CobolxIterator<T> {
+  return new CobolxIterator(items);
+}

package/runtime/src/memory/arc.ts

@@ -0,0 +1,22 @@
+export class ArcBox<T> {
+  private refs = 1;
+
+  constructor(private value: T) {}
+
+  clone(): ArcBox<T> {
+    this.refs += 1;
+    return this;
+  }
+
+  strongCount(): number {
+    return this.refs;
+  }
+
+  release(): void {
+    this.refs = Math.max(0, this.refs - 1);
+  }
+
+  get(): T {
+    return this.value;
+  }
+}

package/runtime/src/observability/index.ts

@@ -0,0 +1,23 @@
+const metrics = new Map<string, number>();
+const traces: Array<{ name: string; at: string; details?: Record<string, unknown> }> = [];
+
+export function log(level: "INFO" | "WARN" | "ERROR", message: string, details?: Record<string, unknown>): void {
+  const payload = { level, message, details, at: new Date().toISOString() };
+  console.log(JSON.stringify(payload));
+}
+
+export function incrementMetric(name: string, value = 1): void {
+  metrics.set(name, (metrics.get(name) ?? 0) + value);
+}
+
+export function getMetrics(): Record<string, number> {
+  return Object.fromEntries(metrics.entries());
+}
+
+export function trace(name: string, details?: Record<string, unknown>): void {
+  traces.push({ name, details, at: new Date().toISOString() });
+}
+
+export function getTraces(): Array<{ name: string; at: string; details?: Record<string, unknown> }> {
+  return [...traces];
+}

package/runtime/src/repl/context.ts

@@ -0,0 +1,7 @@
+export interface ReplContext {
+  values: Record<string, unknown>;
+}
+
+export function createReplContext(): ReplContext {
+  return { values: {} };
+}

package/runtime/src/scheduler/taskScheduler.ts

@@ -0,0 +1,11 @@
+export type Task<T = unknown> = () => Promise<T> | T;
+
+export class TaskScheduler {
+  async run<T>(task: Task<T>): Promise<T> {
+    return await Promise.resolve(task());
+  }
+
+  async all<T>(tasks: Array<Task<T>>): Promise<T[]> {
+    return await Promise.all(tasks.map((task) => this.run(task)));
+  }
+}

package/runtime/src/security/capabilities.ts

@@ -0,0 +1,15 @@
+export interface FileCapability {
+  root: string;
+}
+
+export interface DatabaseCapability {
+  url: string;
+}
+
+export interface NetworkCapability {
+  host: string;
+}
+
+export interface SecretCapability {
+  namespace: string;
+}

package/runtime/src/security/secrets.ts

@@ -0,0 +1,13 @@
+const secrets = new Map<string, string>();
+
+export function setSecret(name: string, value: string): void {
+  secrets.set(name, value);
+}
+
+export function getSecret(name: string): string {
+  const value = secrets.get(name) ?? process.env[name];
+  if (!value) {
+    throw new Error(`Secret '${name}' not found`);
+  }
+  return value;
+}

package/runtime/src/state/versioned.ts

@@ -0,0 +1,31 @@
+export interface VersionedSnapshot<T> {
+  version: number;
+  value: T;
+  at: string;
+}
+
+export class VersionedState<T> {
+  private version = 0;
+  private history: VersionedSnapshot<T>[] = [];
+
+  constructor(initial: T) {
+    this.set(initial);
+  }
+
+  set(value: T): void {
+    this.history.push({ version: this.version, value: structuredClone(value), at: new Date().toISOString() });
+    this.version += 1;
+  }
+
+  current(): VersionedSnapshot<T> {
+    return this.history[this.history.length - 1];
+  }
+
+  rollback(version: number): VersionedSnapshot<T> | undefined {
+    return this.history.find((item) => item.version === version);
+  }
+
+  timeline(): VersionedSnapshot<T>[] {
+    return [...this.history];
+  }
+}

package/runtime/src/std_hooks/audit.ts

@@ -0,0 +1,23 @@
+export interface AuditRecord {
+  category: string;
+  action: string;
+  at: string;
+  details?: Record<string, unknown>;
+}
+
+const records: AuditRecord[] = [];
+
+export function audit(category: string, action: string, details?: Record<string, unknown>): AuditRecord {
+  const record: AuditRecord = {
+    category,
+    action,
+    at: new Date().toISOString(),
+    details
+  };
+  records.push(record);
+  return record;
+}
+
+export function getAuditTrail(): AuditRecord[] {
+  return [...records];
+}