cobolx-2 1.2.3

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

@@ -0,0 +1,30 @@
+import { readManifest, writeManifest } from "@cobolx/cargox";
+import { manifestPath } from "../project.js";
+import { runInstallCommand } from "./install.js";
+
+function bumpPatch(version: string): string {
+  const match = /^(\d+)\.(\d+)\.(\d+)$/.exec(version.trim());
+  if (!match) return version;
+  const [, major, minor, patch] = match;
+  return `${major}.${minor}.${Number(patch) + 1}`;
+}
+
+export function runUpdateCommand(projectDir: string): number {
+  const manifestFile = manifestPath(projectDir);
+  const manifest = readManifest(manifestFile);
+  const updated: string[] = [];
+
+  for (const [name, version] of Object.entries(manifest.dependencies)) {
+    const nextVersion = bumpPatch(version);
+    manifest.dependencies[name] = nextVersion;
+    if (nextVersion !== version) {
+      updated.push(`${name}: ${version} -> ${nextVersion}`);
+    }
+  }
+
+  writeManifest(manifestFile, manifest);
+  const installExitCode = runInstallCommand(projectDir);
+  if (installExitCode !== 0) return installExitCode;
+  console.log(updated.length > 0 ? `Updated dependencies:\n${updated.join("\n")}` : "Dependencies already up to date");
+  return 0;
+}

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

@@ -0,0 +1,25 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parseSource } from "@cobolx/compiler";
+import { readManifest, manifestPath } from "../project.js";
+
+export function runVisualizeCommand(projectDir: string): number {
+  const manifest = readManifest(manifestPath(projectDir));
+  const sourcePath = path.join(projectDir, manifest.package.entry);
+  const program = parseSource(fs.readFileSync(sourcePath, "utf8"));
+  const output = path.join(projectDir, "generated", "flowchart.mmd");
+  fs.mkdirSync(path.dirname(output), { recursive: true });
+
+  const lines = ["flowchart TD", `  A[Program ${program.name}]`];
+  let previous = "A";
+  program.body.forEach((statement, index) => {
+    const node = `N${index}`;
+    lines.push(`  ${node}[${statement.kind}]`);
+    lines.push(`  ${previous} --> ${node}`);
+    previous = node;
+  });
+
+  fs.writeFileSync(output, `${lines.join("\n")}\n`, "utf8");
+  console.log(`Generated visualization ${output}`);
+  return 0;
+}

package/cli/cobolx-cli/src/index.ts

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+import { runAddCommand } from "./commands/add.js";
+import { runBenchCommand } from "./commands/bench.js";
+import { runBuildCommand } from "./commands/build.js";
+import { runCheckCommand } from "./commands/check.js";
+import { runDevCommand } from "./commands/dev.js";
+import { runDebugCommand } from "./commands/debug.js";
+import { runDocCommand } from "./commands/doc.js";
+import { runDeployCommand } from "./commands/deploy.js";
+import { runFmtCommand } from "./commands/fmt.js";
+import { runFuzzCommand } from "./commands/fuzz.js";
+import { runGenerateCommand } from "./commands/generate.js";
+import { runInstallCommand } from "./commands/install.js";
+import { runLegacyConvertCommand } from "./commands/legacy.js";
+import { runLintCommand } from "./commands/lint.js";
+import { runMigrateCreateCommand, runMigrateRunCommand } from "./commands/migrate.js";
+import { runNewCommand } from "./commands/new.js";
+import { runProfileCommand } from "./commands/profile.js";
+import { runPublishCommand } from "./commands/publish.js";
+import { runReplCommand } from "./commands/repl.js";
+import { runRunCommand } from "./commands/run.js";
+import { runTaskCommand } from "./commands/task.js";
+import { runTestCommand } from "./commands/test.js";
+import { runUpdateCommand } from "./commands/update.js";
+import { runVisualizeCommand } from "./commands/visualize.js";
+
+function usage(): void {
+  console.log("COBOL-X CLI");
+  console.log("Usage: cobolx <new|build|run|check|test|bench|add|install|update|publish|fmt|lint|debug|profile|dev|migrate|generate|fuzz|repl|doc|task|legacy|visualize|deploy> [args]");
+}
+
+async function main(argv: string[]): Promise<number> {
+  const [command, ...rest] = argv;
+  const projectDir = process.cwd();
+  const release = rest.includes("--release");
+  const targetIndex = rest.indexOf("--target");
+  const target = targetIndex >= 0 ? rest[targetIndex + 1] : undefined;
+
+  switch (command) {
+    case "new":
+      return runNewCommand(rest[0], rest[1]);
+    case "build":
+      return runBuildCommand(projectDir, { release, target });
+    case "run":
+      return runRunCommand(projectDir, { release, target });
+    case "check":
+      return runCheckCommand(projectDir);
+    case "test":
+      return runTestCommand(projectDir);
+    case "bench":
+      return await runBenchCommand(projectDir);
+    case "add":
+      return runAddCommand(projectDir, rest[0], rest[1]);
+    case "install":
+      return runInstallCommand(projectDir);
+    case "update":
+      return runUpdateCommand(projectDir);
+    case "publish":
+      return runPublishCommand(projectDir);
+    case "fmt":
+      return runFmtCommand(projectDir);
+    case "lint":
+      return runLintCommand(projectDir);
+    case "debug":
+      return runDebugCommand(projectDir, rest.includes("--rewind"));
+    case "profile":
+      return await runProfileCommand(projectDir);
+    case "dev":
+      return runDevCommand(projectDir);
+    case "migrate":
+      if (rest[0] === "create") return runMigrateCreateCommand(projectDir, rest[1]);
+      if (rest[0] === "run") return runMigrateRunCommand(projectDir);
+      usage();
+      return 1;
+    case "generate":
+      return runGenerateCommand(projectDir, rest[0], rest[1]);
+    case "fuzz":
+      return runFuzzCommand(projectDir, rest[0]);
+    case "repl":
+      return await runReplCommand();
+    case "doc":
+      return runDocCommand(projectDir);
+    case "task":
+      return runTaskCommand(projectDir, rest[0]);
+    case "legacy":
+      return runLegacyConvertCommand(projectDir, rest[0]);
+    case "visualize":
+      return runVisualizeCommand(projectDir);
+    case "deploy":
+      return runDeployCommand(projectDir);
+    case undefined:
+      usage();
+      return 0;
+    default:
+      console.error(`Unknown command: ${command}`);
+      usage();
+      return 1;
+  }
+}
+
+process.exit(await main(process.argv.slice(2)));

package/cli/cobolx-cli/src/project.ts

@@ -0,0 +1,74 @@
+import fs from "node:fs";
+import path from "node:path";
+import { readManifest, writeManifest, writeLockfile } from "@cobolx/cargox";
+
+export { readManifest };
+
+export function manifestPath(projectDir: string): string {
+  return path.join(projectDir, "cobolx.toml");
+}
+
+export function lockfilePath(projectDir: string): string {
+  return path.join(projectDir, "CargoX.lock");
+}
+
+export function scaffoldProject(targetDir: string, projectName: string, template = "default"): void {
+  const srcDir = path.join(targetDir, "src");
+  const testsDir = path.join(targetDir, "tests");
+  const benchmarksDir = path.join(targetDir, "benchmarks");
+  const migrationsDir = path.join(targetDir, "migrations");
+  const generatedDir = path.join(targetDir, "generated");
+  fs.mkdirSync(srcDir, { recursive: true });
+  fs.mkdirSync(testsDir, { recursive: true });
+  fs.mkdirSync(benchmarksDir, { recursive: true });
+  fs.mkdirSync(migrationsDir, { recursive: true });
+  fs.mkdirSync(generatedDir, { recursive: true });
+
+  writeManifest(manifestPath(targetDir), {
+    package: {
+      name: projectName,
+      version: "0.1.0",
+      entry: "src/main.cbx"
+    },
+    dependencies: {}
+  });
+  writeLockfile(lockfilePath(targetDir), projectName, {});
+
+  fs.writeFileSync(path.join(targetDir, "README.md"), `# ${projectName}\n\nGenerated with COBOL-X template \`${template}\`.\n`, "utf8");
+  fs.writeFileSync(path.join(targetDir, ".env.example"), "DATABASE_URL=\nCOBOLX_SECRET_TOKEN=\n", "utf8");
+  fs.writeFileSync(path.join(targetDir, "cobolx.tasks.json"), JSON.stringify({
+    build: ["check", "test"],
+    release: ["build --release", "doc"]
+  }, null, 2), "utf8");
+
+  const mainSource = templateSource(projectName, template);
+  fs.writeFileSync(
+    path.join(srcDir, "main.cbx"),
+    mainSource,
+    "utf8"
+  );
+  fs.writeFileSync(
+    path.join(testsDir, "smoke.cbx"),
+    `PROGRAM Smoke\n\nBEGIN\nSET total = 1 + 2\nDISPLAY total\nEND\n`,
+    "utf8"
+  );
+  fs.writeFileSync(
+    path.join(benchmarksDir, "arith.cbx"),
+    `PROGRAM Bench\n\nBEGIN\nSET value = 1000 * 1000\nDISPLAY value\nEND\n`,
+    "utf8"
+  );
+}
+
+function templateSource(projectName: string, template: string): string {
+  const programName = projectName.replace(/[^A-Za-z0-9_]/g, "") || "Main";
+  switch (template) {
+    case "api":
+      return `PROGRAM ${programName}\n\nCONST API_VERSION = "v1"\n\nBEGIN\nDISPLAY "API template ${projectName}"\nEND\n`;
+    case "microservice":
+      return `PROGRAM ${programName}\n\nBEGIN\nDISPLAY "Microservice booting"\nEND\n`;
+    case "cli":
+      return `PROGRAM ${programName}\n\nBEGIN\nDISPLAY "CLI ready"\nEND\n`;
+    default:
+      return `PROGRAM ${programName}\n\nBEGIN\nDISPLAY "Hello from COBOL-X"\nEND\n`;
+  }
+}

package/cli/cobolx-cli/tsconfig.json

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

package/cobolx.toml

@@ -0,0 +1,7 @@
+[package]
+name = "cobolx"
+version = "0.2.0"
+entry = "examples/hello.cbx"
+
+[dependencies]
+ledger = "1.2.3"

package/compiler/package.json

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

package/compiler/src/ast/types.d.ts

@@ -0,0 +1,87 @@
+export interface SourceLocation {
+    line: number;
+    column: number;
+    offset: number;
+}
+export interface SourceRange {
+    start: SourceLocation;
+    end: SourceLocation;
+}
+export interface BaseNode {
+    kind: string;
+    range: SourceRange;
+}
+export interface ProgramNode extends BaseNode {
+    kind: "Program";
+    name: string;
+    functions: FunctionDeclarationNode[];
+    body: StatementNode[];
+}
+export interface FunctionDeclarationNode extends BaseNode {
+    kind: "FunctionDeclaration";
+    name: string;
+    params: string[];
+    body: StatementNode[];
+}
+export type StatementNode = SetStatementNode | DisplayStatementNode | InputStatementNode | IfStatementNode | ReturnStatementNode | ExpressionStatementNode;
+export interface SetStatementNode extends BaseNode {
+    kind: "SetStatement";
+    name: string;
+    expression: ExpressionNode;
+}
+export interface DisplayStatementNode extends BaseNode {
+    kind: "DisplayStatement";
+    expression: ExpressionNode;
+}
+export interface InputStatementNode extends BaseNode {
+    kind: "InputStatement";
+    name: string;
+    prompt?: ExpressionNode;
+}
+export interface IfStatementNode extends BaseNode {
+    kind: "IfStatement";
+    condition: ExpressionNode;
+    thenBranch: StatementNode[];
+    elseBranch: StatementNode[];
+}
+export interface ReturnStatementNode extends BaseNode {
+    kind: "ReturnStatement";
+    expression: ExpressionNode;
+}
+export interface ExpressionStatementNode extends BaseNode {
+    kind: "ExpressionStatement";
+    expression: ExpressionNode;
+}
+export type ExpressionNode = NumberLiteralNode | StringLiteralNode | BooleanLiteralNode | IdentifierNode | BinaryExpressionNode | UnaryExpressionNode | CallExpressionNode;
+export interface NumberLiteralNode extends BaseNode {
+    kind: "NumberLiteral";
+    value: number;
+}
+export interface StringLiteralNode extends BaseNode {
+    kind: "StringLiteral";
+    value: string;
+}
+export interface BooleanLiteralNode extends BaseNode {
+    kind: "BooleanLiteral";
+    value: boolean;
+}
+export interface IdentifierNode extends BaseNode {
+    kind: "Identifier";
+    name: string;
+}
+export interface BinaryExpressionNode extends BaseNode {
+    kind: "BinaryExpression";
+    operator: string;
+    left: ExpressionNode;
+    right: ExpressionNode;
+}
+export interface UnaryExpressionNode extends BaseNode {
+    kind: "UnaryExpression";
+    operator: string;
+    operand: ExpressionNode;
+}
+export interface CallExpressionNode extends BaseNode {
+    kind: "CallExpression";
+    callee: string;
+    args: ExpressionNode[];
+}

package/compiler/src/ast/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/compiler/src/ast/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["types.ts"],"names":[],"mappings":""}

package/compiler/src/ast/types.ts

@@ -0,0 +1,329 @@
+export interface SourceLocation {
+  line: number;
+  column: number;
+  offset: number;
+}
+
+export interface SourceRange {
+  start: SourceLocation;
+  end: SourceLocation;
+}
+
+export interface BaseNode {
+  kind: string;
+  range: SourceRange;
+  docs?: string[];
+}
+
+export interface ProgramNode extends BaseNode {
+  kind: "Program";
+  name: string;
+  imports: ImportDeclarationNode[];
+  exports: ExportDeclarationNode[];
+  plugins: PluginUseNode[];
+  consts: ConstDeclarationNode[];
+  enums: EnumDeclarationNode[];
+  traits: TraitDeclarationNode[];
+  impls: ImplDeclarationNode[];
+  macros: MacroDeclarationNode[];
+  modules: ModuleDeclarationNode[];
+  functions: FunctionDeclarationNode[];
+  tests: TestDeclarationNode[];
+  body: StatementNode[];
+}
+
+export interface GenericParam {
+  name: string;
+  bound?: string;
+  lifetime?: string;
+}
+
+export interface TypedName {
+  name: string;
+  typeName?: string;
+  lifetime?: string;
+  mutable?: boolean;
+}
+
+export interface ImportDeclarationNode extends BaseNode {
+  kind: "ImportDeclaration";
+  modulePath: string;
+  importedName: string;
+  alias?: string;
+}
+
+export interface ExportDeclarationNode extends BaseNode {
+  kind: "ExportDeclaration";
+  name: string;
+}
+
+export interface PluginUseNode extends BaseNode {
+  kind: "PluginUse";
+  pluginPath: string;
+}
+
+export interface ConstDeclarationNode extends BaseNode {
+  kind: "ConstDeclaration";
+  name: string;
+  expression: ExpressionNode;
+}
+
+export interface EnumVariantNode extends BaseNode {
+  kind: "EnumVariant";
+  name: string;
+  fields: TypedName[];
+}
+
+export interface EnumDeclarationNode extends BaseNode {
+  kind: "EnumDeclaration";
+  name: string;
+  variants: EnumVariantNode[];
+}
+
+export interface FunctionSignatureNode extends BaseNode {
+  kind: "FunctionSignature";
+  name: string;
+  genericParams: GenericParam[];
+  params: TypedName[];
+  returnType?: string;
+  returnLifetime?: string;
+  isAsync?: boolean;
+  isConst?: boolean;
+  traitBound?: string;
+}
+
+export interface FunctionDeclarationNode extends BaseNode {
+  kind: "FunctionDeclaration";
+  signature: FunctionSignatureNode;
+  body: StatementNode[];
+}
+
+export interface TraitDeclarationNode extends BaseNode {
+  kind: "TraitDeclaration";
+  name: string;
+  composedTraits: string[];
+  methods: FunctionDeclarationNode[];
+}
+
+export interface ImplDeclarationNode extends BaseNode {
+  kind: "ImplDeclaration";
+  traitName?: string;
+  targetType: string;
+  methods: FunctionDeclarationNode[];
+}
+
+export interface MacroDeclarationNode extends BaseNode {
+  kind: "MacroDeclaration";
+  name: string;
+  params: string[];
+  body: StatementNode[];
+}
+
+export interface ModuleDeclarationNode extends BaseNode {
+  kind: "ModuleDeclaration";
+  name: string;
+  exports: ExportDeclarationNode[];
+  consts: ConstDeclarationNode[];
+  enums: EnumDeclarationNode[];
+  traits: TraitDeclarationNode[];
+  impls: ImplDeclarationNode[];
+  macros: MacroDeclarationNode[];
+  functions: FunctionDeclarationNode[];
+}
+
+export interface TestDeclarationNode extends BaseNode {
+  kind: "TestDeclaration";
+  name: string;
+  body: StatementNode[];
+}
+
+export type StatementNode =
+  | SetStatementNode
+  | LetStatementNode
+  | DisplayStatementNode
+  | InputStatementNode
+  | IfStatementNode
+  | MatchStatementNode
+  | ReturnStatementNode
+  | ExpressionStatementNode
+  | UnsafeBlockNode
+  | AssertStatementNode
+  | SpawnStatementNode
+  | BlockStatementNode;
+
+export interface LetStatementNode extends BaseNode {
+  kind: "LetStatement";
+  binding: TypedName;
+  expression: ExpressionNode;
+  isMutable: boolean;
+}
+
+export interface SetStatementNode extends BaseNode {
+  kind: "SetStatement";
+  name: string;
+  expression: ExpressionNode;
+}
+
+export interface DisplayStatementNode extends BaseNode {
+  kind: "DisplayStatement";
+  expression: ExpressionNode;
+}
+
+export interface InputStatementNode extends BaseNode {
+  kind: "InputStatement";
+  name: string;
+  prompt?: ExpressionNode;
+}
+
+export interface IfStatementNode extends BaseNode {
+  kind: "IfStatement";
+  condition: ExpressionNode;
+  thenBranch: StatementNode[];
+  elseBranch: StatementNode[];
+}
+
+export interface MatchArmNode extends BaseNode {
+  kind: "MatchArm";
+  pattern: PatternNode;
+  body: StatementNode[];
+}
+
+export interface MatchStatementNode extends BaseNode {
+  kind: "MatchStatement";
+  expression: ExpressionNode;
+  arms: MatchArmNode[];
+}
+
+export interface UnsafeBlockNode extends BaseNode {
+  kind: "UnsafeBlock";
+  body: StatementNode[];
+}
+
+export interface AssertStatementNode extends BaseNode {
+  kind: "AssertStatement";
+  expression: ExpressionNode;
+}
+
+export interface SpawnStatementNode extends BaseNode {
+  kind: "SpawnStatement";
+  expression: ExpressionNode;
+}
+
+export interface BlockStatementNode extends BaseNode {
+  kind: "BlockStatement";
+  body: StatementNode[];
+}
+
+export interface ReturnStatementNode extends BaseNode {
+  kind: "ReturnStatement";
+  expression: ExpressionNode;
+}
+
+export interface ExpressionStatementNode extends BaseNode {
+  kind: "ExpressionStatement";
+  expression: ExpressionNode;
+}
+
+export type PatternNode = WildcardPatternNode | IdentifierPatternNode | VariantPatternNode | LiteralPatternNode;
+
+export interface WildcardPatternNode extends BaseNode {
+  kind: "WildcardPattern";
+}
+
+export interface IdentifierPatternNode extends BaseNode {
+  kind: "IdentifierPattern";
+  name: string;
+}
+
+export interface VariantPatternNode extends BaseNode {
+  kind: "VariantPattern";
+  variantName: string;
+  bindings: string[];
+}
+
+export interface LiteralPatternNode extends BaseNode {
+  kind: "LiteralPattern";
+  expression: ExpressionNode;
+}
+
+export type ExpressionNode =
+  | NumberLiteralNode
+  | StringLiteralNode
+  | BooleanLiteralNode
+  | IdentifierNode
+  | BinaryExpressionNode
+  | UnaryExpressionNode
+  | CallExpressionNode
+  | MacroInvocationNode
+  | TryExpressionNode
+  | MemberExpressionNode
+  | EnumConstructorExpressionNode
+  | ArrayLiteralNode;
+
+export interface NumberLiteralNode extends BaseNode {
+  kind: "NumberLiteral";
+  value: number;
+}
+
+export interface StringLiteralNode extends BaseNode {
+  kind: "StringLiteral";
+  value: string;
+}
+
+export interface BooleanLiteralNode extends BaseNode {
+  kind: "BooleanLiteral";
+  value: boolean;
+}
+
+export interface IdentifierNode extends BaseNode {
+  kind: "Identifier";
+  name: string;
+}
+
+export interface ArrayLiteralNode extends BaseNode {
+  kind: "ArrayLiteral";
+  items: ExpressionNode[];
+}
+
+export interface BinaryExpressionNode extends BaseNode {
+  kind: "BinaryExpression";
+  operator: string;
+  left: ExpressionNode;
+  right: ExpressionNode;
+}
+
+export interface UnaryExpressionNode extends BaseNode {
+  kind: "UnaryExpression";
+  operator: string;
+  operand: ExpressionNode;
+}
+
+export interface CallExpressionNode extends BaseNode {
+  kind: "CallExpression";
+  callee: ExpressionNode;
+  args: ExpressionNode[];
+}
+
+export interface MacroInvocationNode extends BaseNode {
+  kind: "MacroInvocation";
+  name: string;
+  args: ExpressionNode[];
+}
+
+export interface TryExpressionNode extends BaseNode {
+  kind: "TryExpression";
+  expression: ExpressionNode;
+}
+
+export interface MemberExpressionNode extends BaseNode {
+  kind: "MemberExpression";
+  object: ExpressionNode;
+  property: string;
+}
+
+export interface EnumConstructorExpressionNode extends BaseNode {
+  kind: "EnumConstructorExpression";
+  enumName?: string;
+  variantName: string;
+  fields: ExpressionNode[];
+}

package/compiler/src/backend/custom.d.ts

@@ -0,0 +1,8 @@
+import type { MIRProgram } from "../mir/types.js";
+import type { ProgramNode } from "../ast/types.js";
+export interface BackendOutput {
+    target: "js-custom-backend";
+    code: string;
+    instructionCount: number;
+}
+export declare function emitCustomBackend(program: ProgramNode, mir: MIRProgram, outputFilePath: string, stdlibDir: string): BackendOutput;