cobolx-2 1.2.3

package/compiler/src/type_system/checker.ts

@@ -0,0 +1,108 @@
+import type { BinaryExpressionNode, ExpressionNode, ProgramNode, StatementNode } from "../ast/types.js";
+import type { Diagnostic } from "../diagnostics.js";
+import type { CobolxType } from "../hir/types.js";
+
+interface Scope {
+  values: Map<string, CobolxType>;
+  parent?: Scope;
+}
+
+function lookup(scope: Scope, name: string): CobolxType | undefined {
+  return scope.values.get(name) ?? scope.parent?.values.get(name) ?? (scope.parent ? lookup(scope.parent, name) : undefined);
+}
+
+function inferExpression(expression: ExpressionNode, scope: Scope, diagnostics: Diagnostic[]): CobolxType {
+  switch (expression.kind) {
+    case "NumberLiteral":
+      return "number";
+    case "StringLiteral":
+      return "string";
+    case "BooleanLiteral":
+      return "boolean";
+    case "Identifier":
+      return lookup(scope, expression.name) ?? "unknown";
+    case "UnaryExpression":
+      return inferExpression(expression.operand, scope, diagnostics);
+    case "TryExpression":
+      return inferExpression(expression.expression, scope, diagnostics);
+    case "MemberExpression":
+      return "unknown";
+    case "CallExpression":
+    case "MacroInvocation":
+      for (const arg of expression.args) inferExpression(arg, scope, diagnostics);
+      return "unknown";
+    case "EnumConstructorExpression":
+      for (const field of expression.fields) inferExpression(field, scope, diagnostics);
+      return "enum";
+    case "ArrayLiteral":
+      for (const item of expression.items) inferExpression(item, scope, diagnostics);
+      return "array";
+    case "BinaryExpression":
+      return inferBinaryExpression(expression, scope, diagnostics);
+  }
+}
+
+function inferBinaryExpression(expression: BinaryExpressionNode, scope: Scope, diagnostics: Diagnostic[]): CobolxType {
+  const left = inferExpression(expression.left, scope, diagnostics);
+  const right = inferExpression(expression.right, scope, diagnostics);
+  if (["+", "-", "*", "/", "%"].includes(expression.operator)) {
+    if (left !== "number" || right !== "number") {
+      diagnostics.push({ message: `Arithmetic operator '${expression.operator}' expects number operands`, severity: "warning", range: expression.range });
+    }
+    return "number";
+  }
+  if (["==", "!=", "<", "<=", ">", ">="].includes(expression.operator)) return "boolean";
+  return "unknown";
+}
+
+export function inferProgramTypes(program: ProgramNode): { symbolTypes: Record<string, CobolxType>; diagnostics: Diagnostic[] } {
+  const diagnostics: Diagnostic[] = [];
+  const scope: Scope = { values: new Map() };
+  for (const constant of program.consts) scope.values.set(constant.name, inferExpression(constant.expression, scope, diagnostics));
+
+  const visitStatements = (statements: StatementNode[], localScope: Scope): void => {
+    for (const statement of statements) {
+      switch (statement.kind) {
+        case "LetStatement":
+          localScope.values.set(statement.binding.name, inferExpression(statement.expression, localScope, diagnostics));
+          break;
+        case "SetStatement":
+          localScope.values.set(statement.name, inferExpression(statement.expression, localScope, diagnostics));
+          break;
+        case "InputStatement":
+          localScope.values.set(statement.name, "string");
+          if (statement.prompt) inferExpression(statement.prompt, localScope, diagnostics);
+          break;
+        case "DisplayStatement":
+        case "ExpressionStatement":
+        case "ReturnStatement":
+        case "AssertStatement":
+        case "SpawnStatement":
+          inferExpression(statement.expression, localScope, diagnostics);
+          break;
+        case "IfStatement":
+          inferExpression(statement.condition, localScope, diagnostics);
+          visitStatements(statement.thenBranch, { values: new Map(localScope.values), parent: localScope.parent });
+          visitStatements(statement.elseBranch, { values: new Map(localScope.values), parent: localScope.parent });
+          break;
+        case "MatchStatement":
+          inferExpression(statement.expression, localScope, diagnostics);
+          for (const arm of statement.arms) visitStatements(arm.body, { values: new Map(localScope.values), parent: localScope.parent });
+          break;
+        case "UnsafeBlock":
+        case "BlockStatement":
+          visitStatements(statement.body, { values: new Map(localScope.values), parent: localScope });
+          break;
+      }
+    }
+  };
+
+  for (const fn of program.functions) {
+    const fnScope: Scope = { values: new Map(), parent: scope };
+    for (const param of fn.signature.params) fnScope.values.set(param.name, param.typeName === "STRING" ? "string" : "unknown");
+    visitStatements(fn.body, fnScope);
+  }
+
+  visitStatements(program.body, scope);
+  return { symbolTypes: Object.fromEntries(scope.values.entries()), diagnostics };
+}

package/compiler/tsconfig.json

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

package/debugger/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@cobolx/debugger",
+  "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/debugger/src/index.d.ts

@@ -0,0 +1 @@
+export declare function debugNodeProgram(programPath: string): number;

package/debugger/src/index.js

@@ -0,0 +1,9 @@
+import { spawnSync } from "node:child_process";
+export function debugNodeProgram(programPath) {
+    console.log(`[debug] starting ${programPath}`);
+    const result = spawnSync(process.execPath, ["--inspect-brk=0", programPath], {
+        stdio: "inherit"
+    });
+    return result.status ?? 1;
+}
+//# sourceMappingURL=index.js.map

package/debugger/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAE/C,MAAM,UAAU,gBAAgB,CAAC,WAAmB;IAClD,OAAO,CAAC,GAAG,CAAC,oBAAoB,WAAW,EAAE,CAAC,CAAC;IAC/C,MAAM,MAAM,GAAG,SAAS,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,iBAAiB,EAAE,WAAW,CAAC,EAAE;QAC3E,KAAK,EAAE,SAAS;KACjB,CAAC,CAAC;IACH,OAAO,MAAM,CAAC,MAAM,IAAI,CAAC,CAAC;AAC5B,CAAC"}

package/debugger/src/index.ts

@@ -0,0 +1,9 @@
+import { spawnSync } from "node:child_process";
+
+export function debugNodeProgram(programPath: string): number {
+  console.log(`[debug] starting ${programPath}`);
+  const result = spawnSync(process.execPath, ["--inspect-brk=0", programPath], {
+    stdio: "inherit"
+  });
+  return result.status ?? 1;
+}

package/debugger/tsconfig.json

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

package/docs/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+## 0.2.0
+
+- Expanded COBOLX into a multi-workspace ecosystem with runtime, package management, formatter, linter, debugger, and profiler packages
+- Added compiler phase separation for HIR, MIR, type checking, borrow analysis, optimizer, and backend generation
+- Added GitHub-ready documentation and repository metadata
+
+## 0.1.0
+
+- Initial TypeScript compiler, CLI, LSP, and VS Code extension

package/docs/CONTRIBUTING.md

@@ -0,0 +1,15 @@
+# Contributing
+
+## Workflow
+
+1. Install dependencies with `npm install`.
+2. Build all workspaces with `npm run build`.
+3. Verify changes with `npm run check`, `npm run test`, and targeted CLI commands.
+4. Keep documentation in sync with behavior.
+
+## Standards
+
+- Prefer small, reviewable changes.
+- Add tests or runnable examples for language features and tools.
+- Keep compiler phases isolated by responsibility.
+- Avoid introducing undocumented syntax.

package/docs/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 COBOLX
+
+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/docs/architecture.md

@@ -0,0 +1,29 @@
+# COBOL-X Architecture
+
+## Compiler
+
+- `lexer`: tokenization and source ranges
+- `parser`: AST construction
+- `semantic`: name and control-flow oriented validation
+- `type_system`: basic type inference for literals and arithmetic expressions
+- `hir`: semantic lowering stage
+- `borrow_checker`: mutating alias checks across calls
+- `mir`: instruction-oriented lowering stage
+- `optimizer`: constant folding
+- `backend`: custom JavaScript backend
+
+## Toolchain
+
+- `cargox`: manifest parsing, lockfile generation, dependency graph resolution, local registry publishing
+- `cli/cobolx-cli`: user-facing command surface
+- `formatter`, `linter`, `debugger`, `profiler`: standalone toolchain packages integrated into the CLI
+
+## Runtime and Stdlib
+
+- `runtime`: ARC-style references, futures, scheduling, and audit hooks
+- `stdlib`: IO, filesystem, network, HTTP, JSON, crypto, datetime, and business modules
+
+## Editor Support
+
+- `lsp/server`: diagnostics, hover, and completion
+- `vscode-extension`: syntax grammar, snippets, and LSP client wiring

package/docs/cli.md

@@ -0,0 +1,58 @@
+# COBOL-X CLI
+
+## Commands
+
+- `cobolx new my-project`
+- `cobolx build`
+- `cobolx run`
+- `cobolx check`
+- `cobolx test`
+- `cobolx bench`
+- `cobolx add dependency 1.0.0`
+- `cobolx install`
+- `cobolx update`
+- `cobolx publish`
+- `cobolx fmt`
+- `cobolx lint`
+- `cobolx debug`
+- `cobolx profile`
+- `cobolx dev`
+- `cobolx doc`
+- `cobolx repl`
+- `cobolx visualize`
+- `cobolx deploy`
+
+## Project Layout
+
+```text
+my-project/
+├── src/
+│   └── main.cbx
+├── cobolx.toml
+└── README.md
+```
+
+## Config
+
+`cobolx.toml` uses a package/dependency layout:
+
+```toml
+[package]
+name = "my-project"
+version = "0.1.0"
+entry = "src/main.cbx"
+
+[dependencies]
+```
+
+Build output is written to `dist/main.mjs`.
+
+## Validation Flow
+
+Typical release validation:
+
+```powershell
+npm run build
+npm run test
+npm run validate
+```

package/docs/language-spec.md

@@ -0,0 +1,49 @@
+# COBOL-X Language Specification
+
+## File Format
+
+COBOL-X source files use the `.cbx` extension.
+
+## Program Structure
+
+Every file starts with a `PROGRAM` declaration followed by a `BEGIN`/`END` block.
+
+```cbx
+PROGRAM Sample
+
+BEGIN
+DISPLAY "Hello"
+END
+```
+
+## Statements
+
+- `SET name = expression`
+- `DISPLAY expression`
+- `INPUT name`
+- `IF expression THEN ... ELSE ... END-IF`
+- `FUNCTION name(param, other) BEGIN ... END-FUNCTION`
+- `RETURN expression`
+
+## Expressions
+
+- Numbers: `42`, `3.14`
+- Strings: `"hello"`
+- Booleans: `TRUE`, `FALSE`
+- Variables: `salary`
+- Arithmetic: `+`, `-`, `*`, `/`
+- Comparison: `=`, `!=`, `<`, `<=`, `>`, `>=`
+- Calls: `compute_tax(salary)`
+
+## Semantics
+
+- Variables must be assigned before they are read.
+- Functions must be declared before they are called.
+- Duplicate function names are rejected.
+- Function argument counts are checked.
+- Arithmetic diagnostics are emitted when non-numeric values are used in numeric operators.
+- Borrow-style alias diagnostics reject passing the same identifier repeatedly to mutating functions.
+
+## Code Generation
+
+The compiler lowers source through HIR and MIR, performs constant folding, and emits JavaScript through the custom backend.

package/docs/packages.md

@@ -0,0 +1,19 @@
+# CargoX Packages
+
+Implemented CargoX features in this repository:
+
+- Manifest parsing from `cobolx.toml`
+- Dependency graph resolution
+- Lockfile writing to `CargoX.lock`
+- Install materialization into `.cargox/packages/`
+- Dependency update flow with manifest rewrite + lockfile refresh
+- Local package publishing to `.cargox-registry/`
+
+The current implementation is intentionally local-first and workspace-friendly.
+
+Core commands:
+
+- `cobolx add ledger 1.2.3`
+- `cobolx install`
+- `cobolx update`
+- `cobolx publish`

package/docs/platform-systems.md

@@ -0,0 +1,31 @@
+# COBOL-X Platform Systems
+
+This repository now includes working foundations for:
+
+1. Effect-oriented compiler evolution groundwork through compiler metadata and plugin hooks
+2. Capability-based runtime security types in `runtime/src/security`
+3. Hot reload via `cobolx dev`
+4. Typed configuration via `runtime/src/config`
+5. Migrations via `cobolx migrate create|run`
+6. Observability via `runtime/src/observability`
+7. Feature flags via `runtime/src/feature_flags`
+8. Version-ready API scaffolding via `cobolx generate api`
+9. Actor model primitives via `runtime/src/actors`
+10. Shared client type generation via `cobolx generate client typescript`
+11. Task pipeline automation via `cobolx task`
+12. Fuzz testing via `cobolx fuzz`
+13. Secret management via `runtime/src/security/secrets`
+14. DSL evolution hooks through macros, plugins, and code generation entry points
+15. Distributed tooling via `runtime/src/distributed`
+16. Build caching and incremental reuse in `cobolx build`
+17. Interactive REPL via `cobolx repl`
+18. Code generation via `cobolx generate`
+19. Legacy COBOL conversion via `cobolx legacy`
+20. Project templates via `cobolx new <name> [api|microservice|cli]`
+21. Time-travel debugging via `runtime/src/time_travel` and `cobolx debug --rewind`
+22. Event bus support via `runtime/src/events`
+23. Workflow execution via `runtime/src/workflows`
+24. Self-healing supervisor and health checks via `runtime/src/healing`
+25. Versioned state tracking via `runtime/src/state/versioned`
+26. Visual flow generation via `cobolx visualize`
+27. Deploy metadata and distributed registration via `cobolx deploy`

package/docs/release-validation.md

@@ -0,0 +1,22 @@
+# Release Validation
+
+The repository includes a scripted validation pass in [tests/validate-release.mjs](/c:/Users/matth/Desktop/temp%20folder/tests/validate-release.mjs:1).
+
+It verifies:
+
+- workspace build
+- compiler-backed tests
+- benchmark execution
+- project scaffolding
+- package add/install/update
+- docs generation
+- migrations
+- visualization
+- deploy metadata
+- debug trace rewind
+
+Run it with:
+
+```powershell
+npm run validate
+```

package/docs/runtime.md

@@ -0,0 +1,10 @@
+# COBOL-X Runtime
+
+The runtime package provides:
+
+- `ArcBox<T>` for deterministic shared ownership semantics
+- `TaskScheduler` for cooperative async execution
+- `futureOf()` for future-style wrappers
+- `audit()` and `getAuditTrail()` for enterprise audit hooks
+
+These modules are intentionally small and composable so services can build deterministic infrastructure behavior on top of them.

package/docs/tooling.md

@@ -0,0 +1,17 @@
+# COBOL-X Tooling
+
+## Formatter
+
+`@cobolx/formatter` parses and prints canonical `.cbx` source.
+
+## Linter
+
+`@cobolx/linter` combines compiler diagnostics with style warnings like lowercase keyword usage.
+
+## Debugger
+
+`@cobolx/debugger` launches Node inspection against compiled output.
+
+## Profiler
+
+`@cobolx/profiler` measures build and run phases used by `cobolx bench` and `cobolx profile`.

package/docs/vscode-extension.md

@@ -0,0 +1,40 @@
+# VS Code Extension
+
+The COBOL-X VS Code extension lives in [vscode-extension](/c:/Users/matth/Desktop/temp%20folder/vscode-extension:1).
+
+## Included Features
+
+- Language registration for `cobolx`
+- File associations for `.cbx`, `.cob`, and `.col`
+- TextMate grammar for syntax highlighting
+- Snippets for programs, functions, enums, and match blocks
+- Language client integration with the local COBOL-X language server
+- Commands for build, run, REPL, and basic debug launch
+
+Command routing:
+
+- In the COBOL-X monorepo, the extension uses the local `cli/cobolx-cli/dist/index.js`
+- In standalone projects, it falls back to `cobolx` on the system `PATH`
+
+## Local Testing
+
+1. Run `npm install`
+2. Run `npm run build`
+3. Open the repo in VS Code
+4. Press `F5` to launch an Extension Development Host
+5. Open a `.cbx` file and confirm syntax coloring, hover text, diagnostics, and command palette entries
+
+## Marketplace Packaging
+
+```powershell
+cd vscode-extension
+npm install -g vsce
+npx @vscode/vsce package
+```
+
+## Publishing
+
+```powershell
+vsce login Magnexis
+vsce publish
+```

package/enterprise-demo/CargoX.lock

@@ -0,0 +1,2 @@
+workspace = "enterprise-demo"
+ledger = "1.2.0"

package/enterprise-demo/README.md

@@ -0,0 +1,3 @@
+# enterprise-demo
+
+Generated with COBOL-X.

package/enterprise-demo/benchmarks/arith.cbx

@@ -0,0 +1,6 @@
+PROGRAM Bench
+
+BEGIN
+SET value = 1000 * 1000
+DISPLAY value
+END

package/enterprise-demo/cobolx.toml

@@ -0,0 +1,7 @@
+[package]
+name = "enterprise-demo"
+version = "0.1.0"
+entry = "src/main.cbx"
+
+[dependencies]
+ledger = "1.2.0"

package/enterprise-demo/src/main.cbx

@@ -0,0 +1,5 @@
+PROGRAM enterprisedemo
+
+BEGIN
+  DISPLAY "Hello from COBOL-X"
+END

package/enterprise-demo/tests/smoke.cbx

@@ -0,0 +1,6 @@
+PROGRAM Smoke
+
+BEGIN
+SET total = 1 + 2
+DISPLAY total
+END

package/examples/README.md

@@ -0,0 +1,20 @@
+# COBOL-X Examples
+
+This directory contains runnable COBOL-X projects that exercise the CLI, compiler, runtime, and platform tooling.
+
+Projects:
+
+- `api-server/`
+- `distributed-system/`
+- `workflow-engine/`
+- `event-system/`
+- `parallel-processing/`
+- `debugging-demo/`
+
+Typical flow:
+
+```powershell
+cd examples/api-server
+node ..\..\cli\cobolx-cli\dist\index.js check
+node ..\..\cli\cobolx-cli\dist\index.js run
+```

package/examples/actors-and-flags.md

@@ -0,0 +1,8 @@
+# Actors And Flags
+
+This example is represented at the platform/runtime layer:
+
+- Use `createActor("payments", handler)` from `@cobolx/runtime`
+- Use `setFeatureFlag("new_checkout", true)` and `featureEnabled("new_checkout")`
+- Use `log()`, `incrementMetric()`, and `trace()` for observability
+- Use `registerService()` and `discoverService()` for distributed service lookup

package/examples/api-server/README.md

@@ -0,0 +1,9 @@
+# API Server Example
+
+Demonstrates the API-oriented project template and documentation/code-generation flow.
+
+Useful commands:
+
+- `cobolx run`
+- `cobolx generate api`
+- `cobolx doc`

package/examples/api-server/cobolx.toml

@@ -0,0 +1,6 @@
+[package]
+name = "api-server"
+version = "1.0.0"
+entry = "src/main.cbx"
+
+[dependencies]

package/examples/api-server/src/main.cbx

@@ -0,0 +1,8 @@
+PROGRAM ApiServer
+
+CONST VERSION = "v1"
+
+BEGIN
+  DISPLAY "API server boot"
+  DISPLAY VERSION
+END

package/examples/debug-replay.md

@@ -0,0 +1,7 @@
+# Debug Replay
+
+1. Run a project with `cobolx run`
+2. COBOL-X writes `dist/debug-timeline.json`
+3. Replay history with `cobolx debug --rewind`
+
+This uses the runtime time-travel debugger and recorded state snapshots.

package/examples/debugging-demo/README.md

@@ -0,0 +1,3 @@
+# Debugging Demo
+
+Run `cobolx run` and then `cobolx debug --rewind` to inspect the recorded execution timeline.

package/examples/debugging-demo/cobolx.toml

@@ -0,0 +1,6 @@
+[package]
+name = "debugging-demo"
+version = "1.0.0"
+entry = "src/main.cbx"
+
+[dependencies]

package/examples/debugging-demo/src/main.cbx

@@ -0,0 +1,7 @@
+PROGRAM DebuggingDemo
+
+BEGIN
+  SET account = 100
+  SET account = account + 50
+  DISPLAY account
+END

package/examples/distributed-service.md

@@ -0,0 +1,12 @@
+# Distributed Service
+
+Use the runtime distributed registry:
+
+```ts
+import { registerService, discoverService } from "@cobolx/runtime";
+
+registerService("payments", "node://payments");
+console.log(discoverService("payments"));
+```
+
+The CLI `cobolx deploy` writes deployment metadata and service discovery output.

package/examples/distributed-system/README.md

@@ -0,0 +1,3 @@
+# Distributed System Example
+
+Demonstrates the distributed deployment flow with `cobolx deploy`.

package/examples/distributed-system/cobolx.toml

@@ -0,0 +1,6 @@
+[package]
+name = "distributed-system"
+version = "1.0.0"
+entry = "src/main.cbx"
+
+[dependencies]