thyscript 1.0.0

package/bin/thy.js

@@ -0,0 +1,828 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * thy - ThyScript multi-command CLI
+ * Commands: compile, check, use, new, run, repl, test, build, serve
+ */
+
+const path      = require('path');
+const fs        = require('fs');
+const { execSync, spawn } = require('child_process');
+
+// ─── Bootstrap optional deps ─────────────────────────────────────────────────
+let chalk, ora, commander;
+try { chalk = require('chalk'); }
+catch {
+  chalk = new Proxy({}, {
+    get: (_, k) => k === 'bold' || k === 'bgGreen' || k === 'bgRed'
+      ? new Proxy({}, { get: (_, k2) => (s) => s })
+      : (s) => s,
+  });
+}
+try { ora = require('ora'); }
+catch {
+  ora = (text) => ({
+    text, start() { process.stdout.write(`  ⏳  ${this.text}...\n`); return this; },
+    succeed(m) { process.stdout.write(`  ✅  ${m || this.text}\n`); return this; },
+    fail(m)    { process.stdout.write(`  ❌  ${m || this.text}\n`); return this; },
+    info(m)    { process.stdout.write(`  ℹ️   ${m || this.text}\n`); return this; },
+    stop()     { return this; },
+  });
+}
+try { commander = require('commander'); }
+catch {
+  console.error('commander not found. Run: npm install commander');
+  process.exit(1);
+}
+
+const { Command } = commander;
+
+// ─── Constants ────────────────────────────────────────────────────────────────
+const THYSCRIPT_ROOT = path.resolve(__dirname, '..');
+const PKG_PATH       = path.join(THYSCRIPT_ROOT, 'package.json');
+let   VERSION        = '1.0.0';
+try   { VERSION = require(PKG_PATH).version || VERSION; } catch {}
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+const log  = (...a) => console.log(...a);
+const info = (msg)  => log(chalk.cyan(`  ℹ️   ${msg}`));
+const ok   = (msg)  => log(chalk.green(`  ✔   ${msg}`));
+const warn = (msg)  => log(chalk.yellow(`  ⚠️   ${msg}`));
+const fail = (msg)  => log(chalk.red(`  ✖   ${msg}`));
+const sep  = ()     => log(chalk.cyan('  ' + '─'.repeat(68)));
+
+function header(title) {
+  sep();
+  log(chalk.bold.cyan(`  ${title}`));
+  sep();
+}
+
+function ensureThyFile(f) {
+  const abs = path.resolve(process.cwd(), f);
+  if (!fs.existsSync(abs)) { fail(`File not found: ${abs}`); process.exit(1); }
+  return abs;
+}
+
+function tryRequire(rel) {
+  try { return require(path.join(THYSCRIPT_ROOT, rel)); } catch { return null; }
+}
+
+function npmInstall(pkg, cwd) {
+  const spinner = ora(`Installing ${pkg}...`).start();
+  try {
+    execSync(`npm install ${pkg}`, { cwd, stdio: 'pipe' });
+    spinner.succeed(chalk.green(`Installed ${pkg}`));
+    return true;
+  } catch (err) {
+    spinner.fail(chalk.red(`Failed to install ${pkg}: ${err.message}`));
+    return false;
+  }
+}
+
+// ─── Mini banner (no full ASCII for subcommand output) ────────────────────────
+function miniBanner() {
+  log('');
+  log(chalk.bold.cyan('  ⚡ ThyScript v' + VERSION));
+  log(chalk.gray('  High-Performance Language Built on Node.js'));
+  log('');
+}
+
+// ─── Scaffold templates ───────────────────────────────────────────────────────
+function getMainTemplate(name) {
+  return `// ${name} - ThyScript Application
+// Generated by ThyScript CLI v${VERSION}
+
+print("Hello from ${name}!")
+let x: int = 42
+print("The answer is: " + x)
+
+// Define a simple reusable function
+func greet(person):
+  return "Hello, " + person + "!"
+end()
+print(greet("ThyScript"))
+`;
+}
+
+function getPackageJsonTemplate(name) {
+  return JSON.stringify({
+    name: name.toLowerCase().replace(/\s+/g, '-'),
+    version: '0.1.0',
+    description: `ThyScript project: ${name}`,
+    main: 'src/main.thy',
+    scripts: {
+      start: `thy run src/main.thy`,
+      build: `thy build src/main.thy`,
+      test:  `thy test`,
+    },
+    keywords: ['thyscript'],
+    license: 'MIT',
+    dependencies: {},
+    devDependencies: {},
+    thyscript: {
+      version: VERSION,
+      entry: 'src/main.thy',
+      outDir: 'dist',
+    },
+  }, null, 2);
+}
+
+function getReadmeTemplate(name) {
+  return `# ${name}
+
+A ThyScript project.
+
+## Getting Started
+
+\`\`\`bash
+thy run src/main.thy
+\`\`\`
+
+## Build
+
+\`\`\`bash
+thy build src/main.thy
+\`\`\`
+
+## Test
+
+\`\`\`bash
+thy test
+\`\`\`
+`;
+}
+
+function getGitignoreTemplate() {
+  return `node_modules/
+dist/
+*.thy.js
+*.thy.map
+.env
+.thy-cache/
+`;
+}
+
+// ─── Program definition ───────────────────────────────────────────────────────
+const program = new Command();
+
+program
+  .name('thy')
+  .description('ThyScript - High-performance language CLI')
+  .version(VERSION, '-v, --version', 'Show ThyScript version');
+
+// ╔══════════════════════════════════════╗
+// ║  thy compile <filename>              ║
+// ╚══════════════════════════════════════╝
+program
+  .command('compile <filename>')
+  .description('Compile a .thy file to Node.js JavaScript')
+  .option('-o, --out <outfile>', 'Output filename (default: <filename>.js)')
+  .option('--minify', 'Minify output')
+  .option('--sourcemap', 'Generate source map')
+  .action(async (filename, opts) => {
+    miniBanner();
+    header('COMPILE');
+
+    const abs     = ensureThyFile(filename);
+    const outFile = opts.out || abs + '.js';
+    const source  = fs.readFileSync(abs, 'utf8');
+    const display = path.basename(abs);
+
+    const spinner = ora(chalk.cyan(`Compiling ${display}...`)).start();
+
+    const ThyMod = tryRequire('src/index.js');
+    if (!ThyMod || typeof ThyMod.compile !== 'function') {
+      spinner.fail(chalk.red('ThyScript compiler not found. Run: thy check'));
+      process.exit(1);
+    }
+
+    try {
+      const t0    = Date.now();
+      let   js    = ThyMod.compile(source, abs);
+
+      if (opts.minify) {
+        // Basic whitespace minification (real minifier hooked via UglifyJS if available)
+        try {
+          const uglify = require('uglify-js');
+          const res    = uglify.minify(js);
+          if (!res.error) js = res.code;
+        } catch {
+          warn('uglify-js not available — skipping minification. Install with: npm install uglify-js');
+        }
+      }
+
+      fs.writeFileSync(outFile, js, 'utf8');
+
+      if (opts.sourcemap) {
+        // Stub source map
+        const map = JSON.stringify({
+          version: 3, file: path.basename(outFile),
+          sources: [display], mappings: '',
+        });
+        fs.writeFileSync(outFile + '.map', map, 'utf8');
+        ok(`Source map: ${outFile}.map`);
+      }
+
+      const ms = Date.now() - t0;
+      spinner.succeed(chalk.green(`Compiled in ${ms}ms → ${outFile}`));
+    } catch (err) {
+      spinner.fail(chalk.red(`Compile error: ${err.message}`));
+      if (err.line) fail(`  at line ${err.line}, col ${err.column}`);
+      if (err.suggestion) warn(`  Fix: ${err.suggestion}`);
+      process.exit(1);
+    }
+  });
+
+// ╔══════════════════════════════════════╗
+// ║  thy check                           ║
+// ╚══════════════════════════════════════╝
+program
+  .command('check')
+  .description('Check npm dependencies and install missing ones')
+  .option('--fix', 'Automatically install missing packages')
+  .action((opts) => {
+    miniBanner();
+    header('DEPENDENCY CHECK');
+
+    const required = [
+      'chalk', 'ora', 'commander', 'chokidar', 'express',
+      'ws', 'better-sqlite3', 'jsonwebtoken', 'bcryptjs',
+    ];
+    const optional = [
+      'uglify-js', 'terser', 'readline-sync',
+    ];
+
+    const cwd = process.cwd();
+    const hasPkg = fs.existsSync(path.join(cwd, 'package.json'));
+    if (!hasPkg) {
+      warn('No package.json found in current directory.');
+      if (opts.fix) {
+        log(chalk.cyan('  Running npm init -y...'));
+        execSync('npm init -y', { cwd, stdio: 'inherit' });
+      }
+    }
+
+    let missing = [];
+    log(chalk.bold.white('  Required packages:'));
+    for (const pkg of required) {
+      try {
+        require.resolve(pkg);
+        log(chalk.green(`    ✔  ${pkg}`));
+      } catch {
+        log(chalk.red(`    ✖  ${pkg} (missing)`));
+        missing.push(pkg);
+      }
+    }
+
+    log('');
+    log(chalk.bold.white('  Optional packages:'));
+    for (const pkg of optional) {
+      try {
+        require.resolve(pkg);
+        log(chalk.green(`    ✔  ${pkg}`));
+      } catch {
+        log(chalk.gray(`    ○  ${pkg} (not installed)`));
+      }
+    }
+
+    log('');
+    if (missing.length === 0) {
+      ok('All required dependencies are present!');
+    } else {
+      warn(`${missing.length} package(s) missing: ${missing.join(', ')}`);
+      if (opts.fix) {
+        log('');
+        log(chalk.cyan('  Installing missing packages...'));
+        for (const pkg of missing) npmInstall(pkg, cwd);
+      } else {
+        log(chalk.yellow('  Run: thy check --fix   to auto-install'));
+      }
+    }
+  });
+
+// ╔══════════════════════════════════════╗
+// ║  thy use <package>                   ║
+// ╚══════════════════════════════════════╝
+program
+  .command('use <package>')
+  .description('Install an npm package and register it in the project')
+  .option('-D, --dev', 'Save as devDependency')
+  .action((pkg, opts) => {
+    miniBanner();
+    header(`ADDING PACKAGE: ${pkg}`);
+
+    const cwd     = process.cwd();
+    const flag    = opts.dev ? '--save-dev' : '--save';
+    const spinner = ora(`Installing ${pkg}...`).start();
+
+    try {
+      execSync(`npm install ${pkg} ${flag}`, { cwd, stdio: 'pipe' });
+      spinner.succeed(chalk.green(`Package '${pkg}' installed and saved.`));
+
+      // Update thyscript block in package.json if present
+      const pkgPath = path.join(cwd, 'package.json');
+      if (fs.existsSync(pkgPath)) {
+        const pkgJson = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        pkgJson.thyscript = pkgJson.thyscript || {};
+        pkgJson.thyscript.uses = pkgJson.thyscript.uses || [];
+        if (!pkgJson.thyscript.uses.includes(pkg)) {
+          pkgJson.thyscript.uses.push(pkg);
+          fs.writeFileSync(pkgPath, JSON.stringify(pkgJson, null, 2), 'utf8');
+          ok(`Registered '${pkg}' in package.json [thyscript.uses]`);
+        }
+      }
+    } catch (err) {
+      spinner.fail(chalk.red(`Failed to install '${pkg}': ${err.message}`));
+      process.exit(1);
+    }
+  });
+
+// ╔══════════════════════════════════════╗
+// ║  thy new <project-name>              ║
+// ╚══════════════════════════════════════╝
+program
+  .command('new <project-name>')
+  .description('Scaffold a new ThyScript project')
+  .option('--no-git', 'Skip git initialization')
+  .option('--no-install', 'Skip npm install')
+  .action((name, opts) => {
+    miniBanner();
+    header(`NEW PROJECT: ${name}`);
+
+    const projectDir = path.resolve(process.cwd(), name);
+    if (fs.existsSync(projectDir)) {
+      fail(`Directory already exists: ${projectDir}`);
+      process.exit(1);
+    }
+
+    const spinner = ora('Scaffolding project...').start();
+
+    try {
+      // Create directory structure
+      const dirs = [
+        projectDir,
+        path.join(projectDir, 'src'),
+        path.join(projectDir, 'tests'),
+        path.join(projectDir, 'dist'),
+        path.join(projectDir, 'docs'),
+      ];
+      dirs.forEach(d => fs.mkdirSync(d, { recursive: true }));
+
+      // Write files
+      fs.writeFileSync(path.join(projectDir, 'src', 'main.thy'),
+        getMainTemplate(name), 'utf8');
+      fs.writeFileSync(path.join(projectDir, 'package.json'),
+        getPackageJsonTemplate(name), 'utf8');
+      fs.writeFileSync(path.join(projectDir, 'README.md'),
+        getReadmeTemplate(name), 'utf8');
+      fs.writeFileSync(path.join(projectDir, '.gitignore'),
+        getGitignoreTemplate(), 'utf8');
+      fs.writeFileSync(path.join(projectDir, 'tests', 'main.test.thy'),
+        `// Tests for ${name}\nprint("Test suite for ${name} passed!")\n`, 'utf8');
+
+      spinner.succeed(chalk.green(`Project scaffolded: ${projectDir}`));
+
+      // Git init
+      if (opts.git !== false) {
+        try {
+          execSync('git init', { cwd: projectDir, stdio: 'pipe' });
+          ok('Initialized git repository');
+        } catch { warn('git not available — skipping'); }
+      }
+
+      // npm install
+      if (opts.install !== false) {
+        const installSpinner = ora('Installing ThyScript dependencies...').start();
+        try {
+          execSync(`npm install thyscript chalk ora commander`, {
+            cwd: projectDir, stdio: 'pipe',
+          });
+          installSpinner.succeed('Dependencies installed');
+        } catch {
+          installSpinner.fail('npm install failed — run manually inside the project');
+        }
+      }
+
+      log('');
+      ok(`Done! Your ThyScript project is ready.`);
+      log('');
+      log(chalk.cyan(`  Next steps:`));
+      log(chalk.white(`    cd ${name}`));
+      log(chalk.white(`    thy run src/main.thy`));
+      log('');
+    } catch (err) {
+      spinner.fail(chalk.red(`Failed: ${err.message}`));
+      process.exit(1);
+    }
+  });
+
+// ╔══════════════════════════════════════╗
+// ║  thy run <filename>                  ║
+// ╚══════════════════════════════════════╝
+program
+  .command('run <filename>')
+  .description('Run a .thy file (alias for thy-node)')
+  .option('--no-stats', 'Skip performance stats')
+  .action((filename, opts) => {
+    const thyNode = path.join(__dirname, 'thy-node.js');
+    const args    = [thyNode, filename];
+    if (opts.stats === false) args.push('--no-stats');
+
+    const child = spawn(process.execPath, args, {
+      stdio: 'inherit',
+      env: process.env,
+    });
+    child.on('exit', code => process.exit(code || 0));
+  });
+
+// ╔══════════════════════════════════════╗
+// ║  thy repl                            ║
+// ╚══════════════════════════════════════╝
+program
+  .command('repl')
+  .description('Start the interactive ThyScript REPL')
+  .action(async () => {
+    miniBanner();
+    header('THYSCRIPT REPL  (type .exit to quit, .help for commands)');
+
+    const readline = require('readline');
+    const rl = readline.createInterface({
+      input:  process.stdin,
+      output: process.stdout,
+      prompt: chalk.cyan('thy> '),
+    });
+
+    const ThyMod  = tryRequire('src/index.js');
+    const history = [];
+    let   scope   = {};
+    let   multi   = '';       // multi-line buffer
+    let   depth   = 0;        // brace depth
+
+    log(chalk.gray('  ThyScript Interactive REPL'));
+    log(chalk.gray('  .help  .clear  .history  .exit'));
+    log('');
+    rl.prompt();
+
+    rl.on('line', async (line) => {
+      const trimmed = line.trim();
+
+      // REPL commands
+      if (trimmed === '.exit') { log(chalk.cyan('  Goodbye!')); rl.close(); process.exit(0); }
+      if (trimmed === '.clear') { scope = {}; multi = ''; depth = 0; ok('Scope cleared.'); rl.prompt(); return; }
+      if (trimmed === '.help') {
+        log(chalk.yellow('  .exit     — quit REPL'));
+        log(chalk.yellow('  .clear    — clear scope'));
+        log(chalk.yellow('  .history  — show history'));
+        log(chalk.yellow('  .scope    — show current variables'));
+        rl.prompt(); return;
+      }
+      if (trimmed === '.history') {
+        history.forEach((h, i) => log(chalk.gray(`  ${i + 1}: ${h}`)));
+        rl.prompt(); return;
+      }
+      if (trimmed === '.scope') {
+        log(JSON.stringify(scope, null, 2));
+        rl.prompt(); return;
+      }
+
+      if (!trimmed) { rl.prompt(); return; }
+
+      // Multi-line detection: count braces
+      for (const ch of line) {
+        if (ch === '{') depth++;
+        else if (ch === '}') depth--;
+      }
+      multi += line + '\n';
+
+      if (depth > 0) {
+        rl.setPrompt(chalk.cyan('... '));
+        rl.prompt();
+        return;
+      }
+
+      // Execute
+      const code = multi.trim();
+      multi = ''; depth = 0;
+      rl.setPrompt(chalk.cyan('thy> '));
+
+      if (code) {
+        history.push(code);
+        try {
+          if (ThyMod && typeof ThyMod.compile === 'function') {
+            const js  = ThyMod.compile(code, '<repl>');
+            const fn  = new Function('__scope__', `with(__scope__){ ${js} }`);
+            const res = await fn(scope);
+            if (res !== undefined) log(chalk.green('  => ') + chalk.white(JSON.stringify(res)));
+          } else {
+            warn('ThyScript compiler not available — showing raw input.');
+            log(chalk.gray(`  > ${code}`));
+          }
+        } catch (err) {
+          log(chalk.red(`  ✖ ${err.message}`));
+          if (err.line) log(chalk.gray(`    at line ${err.line}`));
+        }
+      }
+      rl.prompt();
+    });
+
+    rl.on('close', () => { log(''); process.exit(0); });
+  });
+
+// ╔══════════════════════════════════════╗
+// ║  thy test                            ║
+// ╚══════════════════════════════════════╝
+program
+  .command('test [pattern]')
+  .description('Run ThyScript test files (*.test.thy)')
+  .option('--watch', 'Watch for changes and re-run')
+  .action(async (pattern, opts) => {
+    miniBanner();
+    header('TEST RUNNER');
+
+    const cwd     = process.cwd();
+    const glob    = pattern || '**/*.test.thy';
+    const ThyMod  = tryRequire('src/index.js');
+
+    // Find test files
+    let testFiles = [];
+    function findTests(dir) {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const e of entries) {
+        if (e.name === 'node_modules') continue;
+        const full = path.join(dir, e.name);
+        if (e.isDirectory()) findTests(full);
+        else if (e.name.endsWith('.test.thy')) testFiles.push(full);
+      }
+    }
+    try { findTests(cwd); } catch {}
+
+    if (!testFiles.length) {
+      warn('No test files found (*.test.thy)');
+      process.exit(0);
+    }
+
+    info(`Found ${testFiles.length} test file(s)`);
+    log('');
+
+    async function runTests() {
+      let passed = 0, failed = 0, skipped = 0;
+      const startAll = Date.now();
+
+      for (const file of testFiles) {
+        const display = path.relative(cwd, file);
+        const source  = fs.readFileSync(file, 'utf8');
+        const t0      = Date.now();
+
+        try {
+          if (ThyMod && typeof ThyMod.run === 'function') {
+            await ThyMod.run(file);
+            const ms = Date.now() - t0;
+            log(chalk.green(`  ✔  ${display}`) + chalk.gray(` (${ms}ms)`));
+            passed++;
+          } else {
+            log(chalk.yellow(`  ○  ${display} (skipped — runtime unavailable)`));
+            skipped++;
+          }
+        } catch (err) {
+          const ms = Date.now() - t0;
+          log(chalk.red(`  ✖  ${display}`) + chalk.gray(` (${ms}ms)`));
+          log(chalk.red(`       ${err.message}`));
+          failed++;
+        }
+      }
+
+      const totalMs = Date.now() - startAll;
+      log('');
+      sep();
+      log(chalk.bold.white(`  Results: `) +
+          chalk.green(`${passed} passed`) + chalk.gray('  ') +
+          chalk.red(`${failed} failed`) + chalk.gray('  ') +
+          chalk.yellow(`${skipped} skipped`) +
+          chalk.gray(`  •  ${totalMs}ms`));
+      sep();
+      log('');
+      if (failed) process.exit(1);
+    }
+
+    await runTests();
+
+    if (opts.watch) {
+      let chokidar;
+      try { chokidar = require('chokidar'); } catch {
+        warn('chokidar not installed — watch mode unavailable. Run: thy use chokidar');
+        process.exit(1);
+      }
+      log(chalk.cyan('  👁  Watching for changes...'));
+      chokidar.watch('**/*.test.thy', { cwd, ignoreInitial: true })
+        .on('change', async (f) => {
+          log('');
+          info(`Changed: ${f}. Re-running tests...`);
+          testFiles = [];
+          findTests(cwd);
+          await runTests();
+        });
+    }
+  });
+
+// ╔══════════════════════════════════════╗
+// ║  thy build <filename>                ║
+// ╚══════════════════════════════════════╝
+program
+  .command('build <filename>')
+  .description('Production build: compile, minify, and optimise')
+  .option('-o, --out <dir>', 'Output directory', 'dist')
+  .option('--no-minify', 'Skip minification')
+  .action(async (filename, opts) => {
+    miniBanner();
+    header('PRODUCTION BUILD');
+
+    const abs     = ensureThyFile(filename);
+    const outDir  = path.resolve(process.cwd(), opts.out);
+    const outFile = path.join(outDir, path.basename(abs) + '.js');
+    const source  = fs.readFileSync(abs, 'utf8');
+    const ThyMod  = tryRequire('src/index.js');
+
+    fs.mkdirSync(outDir, { recursive: true });
+
+    const s1 = ora('Compiling...').start();
+    let js;
+    try {
+      js = ThyMod && typeof ThyMod.compile === 'function'
+        ? ThyMod.compile(source, abs)
+        : `// Stub build: ${path.basename(abs)}\n${source}`;
+      s1.succeed('Compiled');
+    } catch (err) {
+      s1.fail(`Compile failed: ${err.message}`);
+      process.exit(1);
+    }
+
+    if (opts.minify !== false) {
+      const s2 = ora('Minifying...').start();
+      try {
+        const terser = require('terser');
+        const res    = await terser.minify(js, { compress: true, mangle: true });
+        js           = res.code || js;
+        s2.succeed(`Minified (${(js.length / 1024).toFixed(1)} KB)`);
+      } catch {
+        try {
+          const ug  = require('uglify-js');
+          const res = ug.minify(js);
+          if (!res.error) js = res.code;
+          s2.succeed(`Minified (${(js.length / 1024).toFixed(1)} KB)`);
+        } catch {
+          s2.info('Minification skipped — terser/uglify-js not available');
+        }
+      }
+    }
+
+    const s3 = ora('Writing output...').start();
+    fs.writeFileSync(outFile, js, 'utf8');
+    s3.succeed(chalk.green(`Output: ${outFile}`));
+
+    // Write build manifest
+    const manifest = {
+      entry: abs, outFile, size: fs.statSync(outFile).size,
+      builtAt: new Date().toISOString(), version: VERSION,
+    };
+    fs.writeFileSync(path.join(outDir, 'thy-build.json'),
+      JSON.stringify(manifest, null, 2), 'utf8');
+
+    ok('Production build complete!');
+    log('');
+  });
+
+// ╔══════════════════════════════════════╗
+// ║  thy serve <filename>                ║
+// ╚══════════════════════════════════════╝
+program
+  .command('serve <filename>')
+  .description('Run a .thy file as an HTTP web server')
+  .option('-p, --port <port>', 'Port to listen on', '3000')
+  .option('--host <host>', 'Host to bind to', 'localhost')
+  .option('--watch', 'Restart on file change')
+  .action(async (filename, opts) => {
+    miniBanner();
+    header('THY SERVER');
+
+    const abs    = ensureThyFile(filename);
+    const port   = parseInt(opts.port, 10) || 3000;
+    const host   = opts.host || 'localhost';
+    const ThyMod = tryRequire('src/index.js');
+
+    info(`Starting server: ${path.basename(abs)}`);
+    info(`Listening on http://${host}:${port}`);
+    log('');
+
+    async function startServer() {
+      try {
+        if (ThyMod && ThyMod.ServerEngine) {
+          const engine = new ThyMod.ServerEngine({ filename: abs, port, host });
+          await engine.start();
+        } else {
+          // Fallback: plain express stub
+          let express;
+          try { express = require('express'); } catch {
+            fail('express not installed. Run: thy use express');
+            process.exit(1);
+          }
+          const source = fs.readFileSync(abs, 'utf8');
+          const app    = express();
+          app.get('*', (_req, res) =>
+            res.send(`<pre>ThyScript stub server\n\nSource:\n${source}</pre>`));
+          app.listen(port, host, () =>
+            ok(`Server running at http://${host}:${port} (stub mode)`));
+        }
+      } catch (err) {
+        if (err.code === 'EADDRINUSE') {
+          fail(`Port ${port} is already in use.`);
+          warn(`Try: thy serve ${filename} --port ${port + 1}`);
+        } else {
+          fail(`Server error: ${err.message}`);
+        }
+        process.exit(1);
+      }
+    }
+
+    await startServer();
+
+    if (opts.watch) {
+      let chokidar;
+      try { chokidar = require('chokidar'); } catch {
+        warn('chokidar not installed — watch disabled');
+        return;
+      }
+      log(chalk.cyan('  👁  Watching for file changes...'));
+      chokidar.watch(abs).on('change', async () => {
+        warn('File changed. Restarting server...');
+        await startServer();
+      });
+    }
+  });
+
+// ╔══════════════════════════════════════╗
+// ║  thy panel                           ║
+// ╚══════════════════════════════════════╝
+program
+  .command('panel')
+  .alias('control-panel')
+  .description('Start the ThyScript Web Control Panel (Live Host Server without compile)')
+  .option('-p, --port <port>', 'Port to listen on', '7777')
+  .option('--host <host>', 'Host to bind to', '0.0.0.0')
+  .option('--token <token>', 'Secret authorization token')
+  .action(async (opts) => {
+    miniBanner();
+    header('THYSCRIPT CONTROL PANEL');
+
+    const port = parseInt(opts.port, 10) || 7777;
+    const host = opts.host || '0.0.0.0';
+    const ControlPanel = tryRequire('src/server/ControlPanel.js');
+    if (!ControlPanel) {
+      fail('ControlPanel module not found.');
+      process.exit(1);
+    }
+
+    const panel = new ControlPanel({
+      port,
+      host,
+      authToken: opts.token || null,
+      workspaceDir: process.cwd(),
+    });
+
+    try {
+      await panel.start();
+      ok(`Control Panel running on http://localhost:${port}`);
+      log('');
+      log(chalk.bold.white('  🌐 Access from any device on your local network (WiFi/LAN):'));
+      for (const net of panel.getNetworkAddresses()) {
+        log(chalk.cyan(`     ▶ http://${net.address}:${port}`) + chalk.gray(` (${net.interface})`));
+      }
+      log('');
+      log(chalk.gray('  ⚡ Live Execution Sandbox Active (Zero disk compile needed)'));
+      log(chalk.gray('  Press Ctrl+C to stop the server.'));
+      log('');
+    } catch (err) {
+      fail(`Failed to start Control Panel: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+// ─── Default: show help if no command given ──────────────────────────────────
+program.addHelpText('after', `
+${chalk.cyan('Examples:')}
+  ${chalk.white('thy new my-app')}             Scaffold new project
+  ${chalk.white('thy run src/main.thy')}       Run a ThyScript file
+  ${chalk.white('thy compile src/main.thy')}   Compile to JavaScript
+  ${chalk.white('thy check --fix')}            Install missing dependencies
+  ${chalk.white('thy repl')}                   Start interactive REPL
+  ${chalk.white('thy serve src/server.thy')}   Run as web server
+  ${chalk.white('thy test')}                   Run test suite
+  ${chalk.white('thy build src/main.thy')}     Production build
+`);
+
+program.parse(process.argv);
+
+if (!process.argv.slice(2).length) {
+  miniBanner();
+  program.outputHelp();
+}