stone-lang 0.1.0

package/cli/entry.js

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+
+/**
+ * Stone CLI - Command-line interface for Stone language
+ *
+ * Usage:
+ *   stone run <file.stn>           Execute a Stone script
+ *   stone check <file.stn>         Type-check without executing
+ *   stone ps                       List running processes
+ *   stone kill <id>                Kill a running process
+ *   stone daemon <action>          Manage the daemon
+ *
+ * Package management:
+ *   stone init                     Create a new package.son
+ *   stone install                  Install dependencies from package.son
+ *   stone install <pkg> --source   Add and install a package
+ *   stone install -g <pkg>         Install package globally
+ *   stone remove <pkg>             Remove a package
+ *   stone update                   Update dependencies
+ *   stone list                     List installed packages
+ *
+ * Run `stone --help` for full usage information.
+ */
+
+import { Command } from 'commander';
+import { runCommand } from './commands/run.js';
+import { checkCommand } from './commands/check.js';
+import { psCommand } from './commands/ps.js';
+import { killCommand } from './commands/kill.js';
+import { daemonCommand } from './commands/daemon.js';
+import {
+  initCommand,
+  installCommand,
+  removeCommand,
+  updateCommand,
+  listCommand,
+} from './commands/package.js';
+
+const VERSION = '0.1.0';
+
+const program = new Command();
+
+program
+  .name('stone')
+  .description('Stone language command-line interface')
+  .version(VERSION, '-v, --version', 'Show version number');
+
+// run command
+program
+  .command('run <file>')
+  .description('Execute a Stone script')
+  .option('--json', 'Output JSON Lines for IDE integration')
+  .option('--headless', 'No browser for graphs, export to files')
+  .option('--no-serve', 'Exit immediately after execution (don\'t keep server running)')
+  .option('--verbose', 'Show detailed execution info')
+  .option('-q, --quiet', 'Suppress non-essential output')
+  .option('--ast', 'Print AST and exit')
+  .option('--bytecode', 'Print bytecode and exit')
+  .option('--no-daemon', 'Skip daemon, use direct execution')
+  .action((file, options) => {
+    runCommand(file, options);
+  });
+
+// check command
+program
+  .command('check <file>')
+  .description('Type-check a Stone script without executing')
+  .option('--json', 'Output JSON')
+  .option('--verbose', 'Show detailed info')
+  .action((file, options) => {
+    checkCommand(file, options);
+  });
+
+// ps command
+program
+  .command('ps')
+  .description('List running Stone processes')
+  .option('--mine', 'Only show my processes')
+  .option('--status <status>', 'Filter by status (running, completed, failed)')
+  .option('--json', 'Output JSON')
+  .action((options) => {
+    psCommand(options);
+  });
+
+// kill command
+program
+  .command('kill <processId>')
+  .description('Kill a running Stone process')
+  .option('--json', 'Output JSON')
+  .action((processId, options) => {
+    killCommand(processId, options);
+  });
+
+// daemon command
+program
+  .command('daemon <action>')
+  .description('Manage the Stone daemon (status|start|stop)')
+  .option('--json', 'Output JSON')
+  .option('--force', 'Force action (e.g., stop when others connected)')
+  .action((action, options) => {
+    daemonCommand(action, options);
+  });
+
+// Package management commands
+
+// init command
+program
+  .command('init')
+  .description('Create a new package.son')
+  .option('--json', 'Output JSON')
+  .option('--force', 'Overwrite existing package.son')
+  .action((options) => {
+    initCommand(options);
+  });
+
+// install command
+program
+  .command('install [package]')
+  .alias('i')
+  .description('Install dependencies or a specific package')
+  .option('--json', 'Output JSON')
+  .option('-g, --global', 'Install globally to ~/.stone/stone_modules')
+  .option('--source <url>', 'Package source URL')
+  .option('--no-save', 'Do not update package.son')
+  .action((pkg, options) => {
+    installCommand(pkg, options);
+  });
+
+// remove command
+program
+  .command('remove <package>')
+  .alias('rm')
+  .description('Remove a package')
+  .option('--json', 'Output JSON')
+  .option('-g, --global', 'Remove from global packages')
+  .action((pkg, options) => {
+    removeCommand(pkg, options);
+  });
+
+// update command
+program
+  .command('update [package]')
+  .alias('up')
+  .description('Update dependencies')
+  .option('--json', 'Output JSON')
+  .action((pkg, options) => {
+    updateCommand(pkg, options);
+  });
+
+// list command
+program
+  .command('list')
+  .alias('ls')
+  .description('List installed packages')
+  .option('--json', 'Output JSON')
+  .option('-g, --global', 'List global packages')
+  .action((options) => {
+    listCommand(options);
+  });
+
+// Parse arguments - but check for no-args first to start REPL
+if (!process.argv.slice(2).length) {
+  // No arguments - start interactive REPL
+  const { ReplSession } = await import('./ReplSession.js');
+  const repl = new ReplSession({ version: VERSION });
+  await repl.start();
+} else {
+  program.parse(process.argv);
+}

package/cli/index.js

@@ -0,0 +1,14 @@
+/**
+ * Stone CLI - Exports for CLI module
+ */
+
+export { CLIOutputAdapter } from './CLIOutputAdapter.js';
+export { JSONOutputAdapter } from './JSONOutputAdapter.js';
+export { DaemonClient } from './DaemonClient.js';
+
+// Commands
+export { runCommand } from './commands/run.js';
+export { checkCommand } from './commands/check.js';
+export { psCommand } from './commands/ps.js';
+export { killCommand } from './commands/kill.js';
+export { daemonCommand } from './commands/daemon.js';

package/cli/stonec.js

@@ -0,0 +1,358 @@
+#!/usr/bin/env node
+
+/**
+ * Stone Compiler CLI
+ *
+ * Command-line interface for Stone compilation to multiple targets.
+ *
+ * Usage:
+ *   stonec input.stn                    # Compile to JS VM (default)
+ *   stonec input.stn --target=wasm      # Compile to WebAssembly
+ *   stonec input.stn --target=c         # Compile to C source
+ *   stonec input.stn -o output          # Specify output file
+ *   stonec input.stn -O2                # Optimization level
+ *   stonec input.stn --emit-hir         # Output HIR (debugging)
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import {
+  StoneCompiler,
+  StoneCompilerOptions,
+  CompilationTarget,
+} from '../compiler.js';
+import { OptimizationLevel } from '../optimization/optimization-manager.js';
+
+// ============================================================================
+// CLI ARGUMENT PARSING
+// ============================================================================
+
+function parseArgs(argv) {
+  const args = {
+    input: null,
+    output: null,
+    target: 'js-vm',
+    optimizationLevel: OptimizationLevel.STANDARD,
+    emitHir: false,
+    emitSourceMap: false,
+    debug: false,
+    verbose: false,
+    help: false,
+    version: false,
+    printTimings: false,
+    printAnalysis: false,
+  };
+
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+
+    if (arg === '-h' || arg === '--help') {
+      args.help = true;
+    } else if (arg === '-v' || arg === '--version') {
+      args.version = true;
+    } else if (arg === '--verbose') {
+      args.verbose = true;
+    } else if (arg === '--debug') {
+      args.debug = true;
+    } else if (arg === '--emit-hir') {
+      args.emitHir = true;
+    } else if (arg === '--emit-source-map') {
+      args.emitSourceMap = true;
+    } else if (arg === '--timings') {
+      args.printTimings = true;
+    } else if (arg === '--analysis') {
+      args.printAnalysis = true;
+    }
+    // Target
+    else if (arg.startsWith('--target=')) {
+      args.target = arg.slice('--target='.length);
+    } else if (arg === '-t' && i + 1 < argv.length) {
+      args.target = argv[++i];
+    }
+    // Output
+    else if (arg.startsWith('-o')) {
+      if (arg === '-o' && i + 1 < argv.length) {
+        args.output = argv[++i];
+      } else if (arg.length > 2) {
+        args.output = arg.slice(2);
+      }
+    } else if (arg.startsWith('--output=')) {
+      args.output = arg.slice('--output='.length);
+    }
+    // Optimization level
+    else if (arg === '-O0') {
+      args.optimizationLevel = OptimizationLevel.NONE;
+    } else if (arg === '-O1') {
+      args.optimizationLevel = OptimizationLevel.BASIC;
+    } else if (arg === '-O2') {
+      args.optimizationLevel = OptimizationLevel.STANDARD;
+    } else if (arg === '-O3') {
+      args.optimizationLevel = OptimizationLevel.AGGRESSIVE;
+    }
+    // Input file
+    else if (!arg.startsWith('-')) {
+      args.input = arg;
+    }
+    // Unknown flag
+    else {
+      console.error(`Unknown option: ${arg}`);
+      process.exit(1);
+    }
+  }
+
+  return args;
+}
+
+// ============================================================================
+// HELP AND VERSION
+// ============================================================================
+
+function printHelp() {
+  console.log(`
+Stone Compiler (stonec)
+
+USAGE:
+  stonec <input.stn> [options]
+
+OPTIONS:
+  -o <file>           Output file (default: derived from input)
+  --output=<file>     Same as -o
+
+  -t <target>         Compilation target
+  --target=<target>   Targets: js-vm (default), wasm, c, hir
+
+  -O0                 No optimization
+  -O1                 Basic optimizations
+  -O2                 Standard optimizations (default)
+  -O3                 Aggressive optimizations
+
+  --emit-hir          Output HIR intermediate representation
+  --emit-source-map   Generate source map
+  --debug             Include debug information
+  --verbose           Verbose output
+  --timings           Print compilation timings
+  --analysis          Print analysis results
+
+  -h, --help          Show this help message
+  -v, --version       Show version
+
+EXAMPLES:
+  stonec program.stn                     # Compile to JS VM
+  stonec program.stn -t wasm -o out.wasm # Compile to WASM
+  stonec program.stn -t c -o out.c       # Compile to C
+  stonec program.stn -O3                 # Maximum optimization
+  stonec program.stn --emit-hir          # Debug: show HIR
+
+TARGETS:
+  js-vm   JavaScript bytecode for Stone VM (default)
+  wasm    WebAssembly binary
+  c       C source code with Makefile
+  hir     HIR output for debugging
+`);
+}
+
+function printVersion() {
+  console.log('Stone Compiler (stonec) v1.0.0');
+  console.log('Part of the Stone Language Project');
+}
+
+// ============================================================================
+// OUTPUT HANDLING
+// ============================================================================
+
+function getDefaultOutputPath(inputPath, target) {
+  const dir = path.dirname(inputPath);
+  const base = path.basename(inputPath, '.stn');
+
+  switch (target) {
+    case 'wasm':
+      return path.join(dir, `${base}.wasm`);
+    case 'c':
+      return path.join(dir, base); // Will create base.c, base.h, Makefile
+    case 'hir':
+      return path.join(dir, `${base}.hir`);
+    case 'js-vm':
+    default:
+      return path.join(dir, `${base}.stb`); // Stone bytecode
+  }
+}
+
+function writeOutput(result, outputPath, target, args) {
+  const dir = path.dirname(outputPath);
+
+  // Ensure directory exists
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  switch (target) {
+    case 'wasm':
+      // Write WASM binary
+      fs.writeFileSync(outputPath, result.binary);
+      if (args.verbose) {
+        console.log(`Wrote WASM binary: ${outputPath} (${result.binary.length} bytes)`);
+      }
+      break;
+
+    case 'c':
+      // Write C source files
+      const base = path.basename(outputPath);
+      const cFile = path.join(dir, `${base}.c`);
+      const hFile = path.join(dir, `${base}.h`);
+      const makeFile = path.join(dir, 'Makefile');
+
+      fs.writeFileSync(cFile, result.source);
+      if (args.verbose) {
+        console.log(`Wrote C source: ${cFile}`);
+      }
+
+      if (result.header) {
+        fs.writeFileSync(hFile, result.header);
+        if (args.verbose) {
+          console.log(`Wrote C header: ${hFile}`);
+        }
+      }
+
+      if (result.makefile) {
+        fs.writeFileSync(makeFile, result.makefile);
+        if (args.verbose) {
+          console.log(`Wrote Makefile: ${makeFile}`);
+        }
+      }
+      break;
+
+    case 'hir':
+      // Write HIR text
+      fs.writeFileSync(outputPath, result.text);
+      if (args.verbose) {
+        console.log(`Wrote HIR: ${outputPath}`);
+      }
+      break;
+
+    case 'js-vm':
+    default:
+      // Write JSON representation (for now)
+      fs.writeFileSync(outputPath, JSON.stringify(result, null, 2));
+      if (args.verbose) {
+        console.log(`Wrote bytecode: ${outputPath}`);
+      }
+      break;
+  }
+}
+
+// ============================================================================
+// MAIN
+// ============================================================================
+
+async function main() {
+  const args = parseArgs(process.argv);
+
+  // Handle help and version
+  if (args.help) {
+    printHelp();
+    process.exit(0);
+  }
+
+  if (args.version) {
+    printVersion();
+    process.exit(0);
+  }
+
+  // Validate input
+  if (!args.input) {
+    console.error('Error: No input file specified');
+    console.error('Usage: stonec <input.stn> [options]');
+    console.error('Run `stonec --help` for more information');
+    process.exit(1);
+  }
+
+  // Check input file exists
+  if (!fs.existsSync(args.input)) {
+    console.error(`Error: Input file not found: ${args.input}`);
+    process.exit(1);
+  }
+
+  // Map target string to CompilationTarget
+  const targetMap = {
+    'js-vm': CompilationTarget.JS_VM,
+    'wasm': CompilationTarget.WASM,
+    'c': CompilationTarget.C,
+    'hir': CompilationTarget.HIR,
+  };
+
+  const target = targetMap[args.target];
+  if (!target) {
+    console.error(`Error: Unknown target: ${args.target}`);
+    console.error('Valid targets: js-vm, wasm, c, hir');
+    process.exit(1);
+  }
+
+  // Determine output path
+  const outputPath = args.output || getDefaultOutputPath(args.input, args.target);
+
+  // Read input
+  const source = fs.readFileSync(args.input, 'utf-8');
+
+  if (args.verbose) {
+    console.log(`Compiling: ${args.input}`);
+    console.log(`Target: ${args.target}`);
+    console.log(`Output: ${outputPath}`);
+    console.log(`Optimization: O${args.optimizationLevel}`);
+    console.log('');
+  }
+
+  // Create compiler options
+  const options = new StoneCompilerOptions({
+    target,
+    optimizationLevel: args.optimizationLevel,
+    sourceFile: args.input,
+    outputFile: outputPath,
+    emitSourceMap: args.emitSourceMap,
+    emitDebugInfo: args.debug,
+    printHIR: args.emitHir,
+    printAnalysis: args.printAnalysis,
+  });
+
+  // Compile
+  const compiler = new StoneCompiler(options);
+  const result = compiler.compile(source);
+
+  // Handle errors
+  if (!result.success) {
+    console.error(`\nCompilation failed at stage: ${result.error.stage}`);
+    console.error(`Error: ${result.error.message}`);
+    if (args.debug) {
+      console.error('\nStack trace:');
+      console.error(result.error.stack);
+    }
+    process.exit(1);
+  }
+
+  // Print timings if requested
+  if (args.printTimings || args.verbose) {
+    console.log('\nCompilation timings:');
+    for (const [stage, time] of Object.entries(result.metadata.timings)) {
+      console.log(`  ${stage}: ${time}ms`);
+    }
+    console.log(`  total: ${result.metadata.totalTime}ms`);
+  }
+
+  // Write output
+  writeOutput(result.output, outputPath, args.target, args);
+
+  // Success message
+  if (!args.verbose) {
+    console.log(`Compiled ${args.input} -> ${outputPath}`);
+  } else {
+    console.log('\nCompilation successful!');
+  }
+
+  process.exit(0);
+}
+
+// Run main
+main().catch((error) => {
+  console.error('Fatal error:', error.message);
+  process.exit(1);
+});