bonescript-compiler 0.5.2 → 0.5.4

package/src/commands/diff.ts

@@ -1,108 +0,0 @@
-/**
- * bonec diff <old.bone> <new.bone>
- * Show SQL schema migration diff between two .bone files.
- */
-
-import * as fs from "fs";
-import * as path from "path";
-import { createHash } from "crypto";
-import { Lexer } from "../lexer";
-import { Parser } from "../parser";
-import { Lowering } from "../lowering";
-import type * as IR from "../ir";
-
-const SQL_TYPE_MAP: Record<string, string> = {
-  string: "VARCHAR", uint: "BIGINT", int: "BIGINT", float: "DOUBLE PRECISION",
-  bool: "BOOLEAN", timestamp: "TIMESTAMPTZ", uuid: "UUID", bytes: "BYTEA", json: "JSONB",
-};
-
-function toSnakeCase(s: string): string {
-  return s.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
-}
-
-async function compileToIR(filePath: string): Promise<IR.IRSystem[]> {
-  const resolved = path.resolve(filePath);
-  try {
-    await fs.promises.access(resolved);
-  } catch {
-    console.error(`File not found: ${resolved}`);
-    process.exit(1);
-  }
-  const source = await fs.promises.readFile(resolved, "utf-8");
-  const tokens = new Lexer(source).tokenize();
-  const ast = new Parser(tokens).parse();
-  const hash = createHash("sha256").update(source).digest("hex").slice(0, 16);
-  return new Lowering().lower(ast, hash);
-}
-
-export async function runDiff(args: string[]): Promise<void> {
-  if (args.length < 2) {
-    console.error("Usage: bonec diff <old.bone> <new.bone>");
-    process.exit(1);
-  }
-
-  const [oldFile, newFile] = args;
-
-  // Load both files in parallel
-  const [oldIR, newIR] = await Promise.all([
-    compileToIR(oldFile),
-    compileToIR(newFile),
-  ]);
-
-  const collectModels = (systems: IR.IRSystem[]) => {
-    const models: IR.IRModel[] = [];
-    for (const sys of systems)
-      for (const mod of sys.modules)
-        for (const m of mod.models) models.push(m);
-    return models;
-  };
-
-  const oldByName = new Map(collectModels(oldIR).map(m => [m.name, m]));
-  const newByName = new Map(collectModels(newIR).map(m => [m.name, m]));
-  const statements: string[] = [];
-
-  for (const [name] of newByName) {
-    if (!oldByName.has(name)) {
-      statements.push(`-- NEW TABLE: ${name}`);
-      statements.push(`-- Run: bonec compile ${newFile} (generates full migration)`);
-    }
-  }
-
-  for (const [name] of oldByName) {
-    if (!newByName.has(name)) {
-      const table = toSnakeCase(name) + "s";
-      statements.push(`-- WARNING: Table '${table}' removed from schema`);
-      statements.push(`-- Manual: ALTER TABLE ${table} ... (or DROP TABLE ${table})`);
-    }
-  }
-
-  for (const [name, newModel] of newByName) {
-    const oldModel = oldByName.get(name);
-    if (!oldModel) continue;
-    const table = toSnakeCase(name) + "s";
-    const oldFields = new Map(oldModel.fields.map(f => [f.name, f]));
-    const newFields = new Map(newModel.fields.map(f => [f.name, f]));
-
-    for (const [fname, field] of newFields) {
-      if (!oldFields.has(fname)) {
-        const sqlType = SQL_TYPE_MAP[field.type] || "JSONB";
-        statements.push(`ALTER TABLE ${table} ADD COLUMN IF NOT EXISTS ${fname} ${sqlType};`);
-      }
-    }
-    for (const [fname] of oldFields) {
-      if (!newFields.has(fname)) {
-        statements.push(`-- WARNING: Column '${table}.${fname}' removed`);
-        statements.push(`-- Manual: ALTER TABLE ${table} DROP COLUMN ${fname};`);
-      }
-    }
-  }
-
-  if (statements.length === 0) {
-    console.log("No schema changes detected.");
-  } else {
-    console.log(`-- BoneScript schema diff: ${path.basename(oldFile)} → ${path.basename(newFile)}`);
-    console.log(`-- Generated: ${new Date().toISOString()}`);
-    console.log(``);
-    console.log(statements.join("\n"));
-  }
-}

package/src/commands/fmt.ts

@@ -1,22 +0,0 @@
-/**
- * bonec fmt <file>
- * Format a .bone file in place.
- */
-
-import * as fs from "fs";
-import { Lexer } from "../lexer";
-import { Parser } from "../parser";
-import { Formatter } from "../formatter";
-
-export async function runFormat(source: string, resolved: string): Promise<void> {
-  try {
-    const tokens = new Lexer(source).tokenize();
-    const ast = new Parser(tokens).parse();
-    const formatted = new Formatter().format(ast);
-    await fs.promises.writeFile(resolved, formatted, "utf-8");
-    console.log(`v Formatted ${resolved}`);
-  } catch (e: any) {
-    console.error(`x ${e.message}`);
-    process.exit(1);
-  }
-}

package/src/commands/init.ts

@@ -1,72 +0,0 @@
-/**
- * bonec init <name> [--domain <domain>] [--out <dir>] [--force]
- * Scaffold a new project from a domain template.
- */
-
-import * as path from "path";
-import * as fs from "fs";
-import { scaffold, ScaffoldDomain } from "../scaffold";
-
-const VALID_DOMAINS: ScaffoldDomain[] = [
-  "multiplayer_game", "saas_platform", "iot_system",
-  "social_network", "marketplace", "realtime_collaboration",
-];
-
-export async function runInit(args: string[]): Promise<void> {
-  // --list: show available domains
-  if (args.includes("--list") || args.includes("-l")) {
-    console.log("Available domains:");
-    for (const d of VALID_DOMAINS) console.log(`  ${d}`);
-    return;
-  }
-
-  if (args.length === 0) {
-    console.error("Error: bonec init requires a project name.");
-    console.error("Example: bonec init my-project --domain saas_platform");
-    console.error("         bonec init --list   (show available domains)");
-    process.exit(1);
-  }
-
-  const name = args[0];
-  let domain: ScaffoldDomain = "saas_platform";
-  let outDir = path.resolve(name);
-  let force = false;
-
-  for (let i = 1; i < args.length; i++) {
-    if (args[i] === "--domain" && args[i + 1]) {
-      domain = args[i + 1] as ScaffoldDomain;
-      i++;
-    } else if (args[i] === "--out" && args[i + 1]) {
-      outDir = path.resolve(args[i + 1]);
-      i++;
-    } else if (args[i] === "--force" || args[i] === "-f") {
-      force = true;
-    }
-  }
-
-  if (!VALID_DOMAINS.includes(domain)) {
-    console.error(`Error: Invalid domain '${domain}'. Valid: ${VALID_DOMAINS.join(", ")}`);
-    process.exit(1);
-  }
-
-  // Check if output directory already has files (unless --force)
-  if (!force) {
-    try {
-      const existing = await fs.promises.readdir(outDir);
-      if (existing.length > 0) {
-        console.error(`Error: Directory '${outDir}' already exists and is not empty.`);
-        console.error(`Use --force to overwrite.`);
-        process.exit(1);
-      }
-    } catch {
-      // Directory doesn't exist — fine
-    }
-  }
-
-  const result = await scaffold({ name, domain, outDir });
-  console.log(`✓ Created ${result.created.length} file(s):`);
-  for (const f of result.created) console.log(`  ${f}`);
-  console.log(`\nNext steps:`);
-  console.log(`  cd ${outDir}`);
-  console.log(`  bonec compile ${name}.bone`);
-}

package/src/commands/ir.ts

@@ -1,23 +0,0 @@
-/**
- * bonec ir <file>
- * Print the IR as JSON.
- */
-
-import { createHash } from "crypto";
-import { Lexer } from "../lexer";
-import { Parser } from "../parser";
-import { Lowering } from "../lowering";
-
-export function runIR(source: string): void {
-  try {
-    const tokens = new Lexer(source).tokenize();
-    const ast = new Parser(tokens).parse();
-    const sourceHash = createHash("sha256").update(source).digest("hex").slice(0, 16);
-    const irSystems = new Lowering().lower(ast, sourceHash);
-    console.log(JSON.stringify(irSystems, null, 2));
-    console.log(`\nv Lowered to ${irSystems.length} IR system(s).`);
-  } catch (e: any) {
-    console.error(`x ${e.message}`);
-    process.exit(1);
-  }
-}

package/src/commands/lex.ts

@@ -1,17 +0,0 @@
-/**
- * bonec lex <file>
- * Print the token stream as JSON.
- */
-
-import { Lexer } from "../lexer";
-
-export function runLex(source: string): void {
-  try {
-    const tokens = new Lexer(source).tokenize();
-    console.log(JSON.stringify(tokens, null, 2));
-    console.log(`\nv ${tokens.length} tokens produced.`);
-  } catch (e: any) {
-    console.error(`x ${e.message}`);
-    process.exit(1);
-  }
-}

package/src/commands/parse.ts

@@ -1,24 +0,0 @@
-/**
- * bonec parse <file>
- * Print the AST as JSON.
- */
-
-import { Lexer } from "../lexer";
-import { RecoveringParser } from "../parser_recovery";
-
-export function runParse(source: string): void {
-  try {
-    const tokens = new Lexer(source).tokenize();
-    const result = new RecoveringParser(tokens).parse();
-    if (result.errors.length > 0) {
-      console.error(`x ${result.errors.length} parse error(s):`);
-      for (const e of result.errors) console.error(`  ${e.message}`);
-      if (!result.ast) process.exit(1);
-    }
-    console.log(JSON.stringify(result.ast, null, 2));
-    console.log(`\nv Parsed ${result.ast?.systems.length || 0} system(s).`);
-  } catch (e: any) {
-    console.error(`x ${e.message}`);
-    process.exit(1);
-  }
-}

package/src/commands/test.ts

@@ -1,36 +0,0 @@
-/**
- * bonec test [output-dir]
- * Run the generated regression test suite against a live server.
- */
-
-import * as fs from "fs";
-import * as path from "path";
-import { execSync } from "child_process";
-
-export async function runTest(args: string[]): Promise<void> {
-  const outputDir = args[0] ? path.resolve(args[0]) : path.resolve("output");
-  const testFile = path.join(outputDir, "src", "tests.ts");
-
-  try {
-    await fs.promises.access(testFile);
-  } catch {
-    console.error(`No test file found at ${testFile}`);
-    console.error("Run 'bonec compile <file>' first to generate tests.");
-    process.exit(1);
-  }
-
-  console.log(`Running BoneScript regression tests...`);
-  console.log(`Test file: ${testFile}`);
-  console.log(`Target: ${process.env.TEST_BASE_URL || "http://localhost:3000"}`);
-  console.log(``);
-
-  try {
-    execSync(`npx ts-node ${testFile}`, {
-      cwd: outputDir,
-      stdio: "inherit",
-      env: { ...process.env },
-    });
-  } catch {
-    process.exit(1);
-  }
-}

package/src/commands/verify_determinism.ts

@@ -1,66 +0,0 @@
-/**
- * bonec verify-determinism <file>
- * Compile twice and assert bitwise-identical output.
- */
-
-import { createHash } from "crypto";
-import { Lexer } from "../lexer";
-import { Parser } from "../parser";
-import { Lowering } from "../lowering";
-import { FullEmitter } from "../emit_full";
-
-export function runVerifyDeterminism(source: string): void {
-  console.log("Verifying compilation determinism...");
-
-  const compile = (): string => {
-    const tokens = new Lexer(source).tokenize();
-    const ast = new Parser(tokens).parse();
-    const hash = createHash("sha256").update(source).digest("hex").slice(0, 16);
-    const ir = new Lowering().lower(ast, hash);
-    const emitter = new FullEmitter();
-    const files: { path: string; content: string }[] = [];
-    for (const sys of ir) {
-      for (const f of emitter.emit(sys)) {
-        files.push({ path: f.path, content: f.content });
-      }
-    }
-    files.sort((a, b) => a.path.localeCompare(b.path));
-    return JSON.stringify(files);
-  };
-
-  const run1 = compile();
-  const run2 = compile();
-
-  if (run1 === run2) {
-    const hash = createHash("sha256").update(run1).digest("hex").slice(0, 16);
-    console.log(`v Deterministic. Both runs produced identical output.`);
-    console.log(`  Output hash: ${hash}`);
-    return;
-  }
-
-  const files1: { path: string; content: string }[] = JSON.parse(run1);
-  const files2: { path: string; content: string }[] = JSON.parse(run2);
-
-  for (let i = 0; i < Math.max(files1.length, files2.length); i++) {
-    const f1 = files1[i];
-    const f2 = files2[i];
-    if (!f1 || !f2 || f1.path !== f2.path || f1.content !== f2.content) {
-      console.error(`x NON-DETERMINISTIC: First divergence at file ${i}`);
-      console.error(`  Run 1: ${f1?.path || "(missing)"}`);
-      console.error(`  Run 2: ${f2?.path || "(missing)"}`);
-      if (f1 && f2 && f1.path === f2.path) {
-        const lines1 = f1.content.split("\n");
-        const lines2 = f2.content.split("\n");
-        for (let j = 0; j < Math.max(lines1.length, lines2.length); j++) {
-          if (lines1[j] !== lines2[j]) {
-            console.error(`  First differing line ${j + 1}:`);
-            console.error(`    Run 1: ${lines1[j]}`);
-            console.error(`    Run 2: ${lines2[j]}`);
-            break;
-          }
-        }
-      }
-      process.exit(1);
-    }
-  }
-}

package/src/commands/watch.ts

@@ -1,25 +0,0 @@
-/**
- * bonec watch <file>
- * Recompile on every save.
- */
-
-import * as fs from "fs";
-import { runCompile } from "./compile";
-
-export function runWatch(_source: string, resolved: string): void {
-  console.log(`Watching ${resolved}...`);
-
-  const compile = () => {
-    fs.promises.readFile(resolved, "utf-8")
-      .then(fresh => {
-        console.log(`\n[${new Date().toLocaleTimeString()}] Compiling...`);
-        return runCompile(fresh, resolved);
-      })
-      .catch((e: any) => console.error(`x ${e.message}`));
-  };
-
-  compile();
-  fs.watchFile(resolved, { interval: 500 }, (curr, prev) => {
-    if (curr.mtimeMs !== prev.mtimeMs) compile();
-  });
-}