@ozsarman/clarityjs 0.6.0

package/src/cli.js

@@ -0,0 +1,453 @@
+#!/usr/bin/env node
+/**
+ * Clarity.js CLI
+ *
+ * Usage:
+ *   clarity build <file.clarity>       — compile a single file
+ *   clarity build <dir/>               — compile all .clarity files in a directory
+ *   clarity check <file.clarity>       — typecheck / lint without emitting
+ *   clarity demo                       — print a demo compilation
+ *
+ * Author: Claude (Anthropic)
+ */
+
+import { readFileSync, writeFileSync, readdirSync, statSync, mkdirSync } from 'fs';
+import { join, dirname, basename, extname } from 'path';
+import { compile } from './index.js';
+import { startDevServer } from './dev-server.js';
+import { bundle } from './clarity-bundle.js';
+import { formatCode, formatFile, lintCode, lintFile, processDirectory, formatLintReport, loadConfig } from './linter.js';
+import { generateStaticSite } from './ssg.js';
+import { analyzeBundle } from './analyze.js';
+
+// ─── Colors ──────────────────────────────────────────────────────────────────
+const c = {
+  reset:  '\x1b[0m',
+  bold:   '\x1b[1m',
+  dim:    '\x1b[2m',
+  green:  '\x1b[32m',
+  blue:   '\x1b[34m',
+  yellow: '\x1b[33m',
+  red:    '\x1b[31m',
+  cyan:   '\x1b[36m',
+  white:  '\x1b[37m',
+};
+
+function log(msg)    { console.log(msg); }
+function ok(msg)     { console.log(`${c.green}✓${c.reset} ${msg}`); }
+function info(msg)   { console.log(`${c.blue}ℹ${c.reset} ${msg}`); }
+function warn(msg)   { console.log(`${c.yellow}⚠${c.reset} ${msg}`); }
+function err(msg)    { console.error(`${c.red}✗${c.reset} ${msg}`); }
+function header(msg) { console.log(`\n${c.bold}${c.cyan}${msg}${c.reset}`); }
+
+// ─── Banner ───────────────────────────────────────────────────────────────────
+function printBanner() {
+  console.log(`
+${c.bold}${c.cyan}  ╔═══════════════════════════════════╗
+  ║   CLARITY.JS  v0.5.0              ║
+  ║   AI-Native UI Framework          ║
+  ║   by Claude (Anthropic)           ║
+  ╚═══════════════════════════════════╝${c.reset}
+`);
+}
+
+// ─── Commands ─────────────────────────────────────────────────────────────────
+function cmdBuild(target) {
+  let files = [];
+
+  try {
+    const stat = statSync(target);
+    if (stat.isDirectory()) {
+      files = readdirSync(target)
+        .filter(f => f.endsWith('.clarity'))
+        .map(f => join(target, f));
+    } else {
+      files = [target];
+    }
+  } catch (_) {
+    err(`Cannot read: ${target}`);
+    process.exit(1);
+  }
+
+  if (files.length === 0) {
+    warn(`No .clarity files found in: ${target}`);
+    return;
+  }
+
+  header(`Building ${files.length} file(s)...`);
+  let success = 0, failed = 0;
+
+  for (const file of files) {
+    const src = readFileSync(file, 'utf8');
+    try {
+      const { code } = compile(src, { filename: file, runtimePath: './clarity-runtime.js' });
+      const outFile  = file.replace(/\.clarity$/, '.js');
+      writeFileSync(outFile, code, 'utf8');
+      ok(`${basename(file)} → ${basename(outFile)} (${code.length} bytes)`);
+      success++;
+    } catch (e) {
+      err(`${basename(file)}: ${e.message}`);
+      failed++;
+    }
+  }
+
+  log('');
+  log(`${c.dim}Results: ${c.green}${success} ok${c.reset}${c.dim}, ${failed > 0 ? c.red : ''}${failed} failed${c.reset}`);
+}
+
+function cmdCheck(file) {
+  header(`Checking ${file}...`);
+  const src = readFileSync(file, 'utf8');
+  try {
+    const { ast, tokens } = compile(src, { filename: file });
+    ok(`No errors found`);
+    info(`${tokens.length} tokens, ${ast.components.length} component(s)`);
+    for (const comp of ast.components) {
+      const stateCount   = comp.body.filter(n => n.type === 'StateDecl').length;
+      const effectCount  = comp.body.filter(n => n.type === 'EffectDecl').length;
+      const hasRender    = comp.body.some(n => n.type === 'RenderBlock');
+      info(`  ${c.bold}${comp.name}${c.reset} — ${stateCount} state, ${effectCount} effects, render: ${hasRender ? 'yes' : 'no'}`);
+    }
+  } catch (e) {
+    err(e.message);
+    process.exit(1);
+  }
+}
+
+function cmdDemo() {
+  printBanner();
+  header('Demo: Compiling a Counter component');
+
+  const source = `
+component Counter() {
+  state count = 0
+
+  render {
+    <div class="counter">
+      <h1>{ count }</h1>
+      <button on:click={ count++ }>Artir</button>
+      <button on:click={ count-- }>Azalt</button>
+    </div>
+  }
+}
+`.trim();
+
+  log(`\n${c.dim}// Source (.clarity):${c.reset}`);
+  log(c.yellow + source + c.reset);
+
+  try {
+    const { code, tokens, ast } = compile(source, { filename: 'demo.clarity' });
+    log(`\n${c.dim}// Generated JavaScript:${c.reset}`);
+    log(c.green + code + c.reset);
+    log(`\n${c.dim}Tokens: ${tokens.length} | AST nodes: ${JSON.stringify(ast).length} chars${c.reset}`);
+  } catch (e) {
+    err(`Compilation failed: ${e.message}`);
+  }
+}
+
+function cmdAst(file) {
+  header(`AST for ${file}`);
+  const src = readFileSync(file, 'utf8');
+  try {
+    const { ast } = compile(src, { filename: file });
+    log(JSON.stringify(ast, null, 2));
+  } catch (e) {
+    err(e.message);
+    process.exit(1);
+  }
+}
+
+function cmdTypes(file) {
+  header(`Generating types for ${file}`);
+  const src = readFileSync(file, 'utf8');
+  try {
+    const { dts, ast } = compile(src, { filename: file, types: true });
+    const outFile = file.replace(/\.clarity$/, '.d.ts');
+    writeFileSync(outFile, dts, 'utf8');
+    ok(`${basename(file)} → ${basename(outFile)} (${dts.length} bytes)`);
+    info(`${ast.components.length} component type(s) generated`);
+    for (const comp of ast.components) {
+      const hasProps = comp.params.length > 0;
+      info(`  ${c.bold}${comp.name}${c.reset}${hasProps ? ` — ${comp.params.length} prop(s)` : ''}`);
+    }
+  } catch (e) {
+    err(e.message);
+    process.exit(1);
+  }
+}
+
+function cmdBundle(args) {
+  // Parse: clarity bundle <entry> [--out dist/bundle.js] [--minify] [--watch] [--prod]
+  const entry    = args.find(a => !a.startsWith('--'));
+  const outIdx   = args.indexOf('--out');
+  const outfile  = outIdx >= 0 && args[outIdx + 1] ? args[outIdx + 1] : 'dist/bundle.js';
+  const minify   = args.includes('--minify') || args.includes('--prod');
+  const watch    = args.includes('--watch');
+  const mode     = (minify || args.includes('--prod')) ? 'production' : 'development';
+
+  if (!entry) {
+    err('Usage: clarity bundle <entry.js> [--out dist/bundle.js] [--minify] [--watch]');
+    process.exit(1);
+  }
+
+  bundle({
+    entry:      entry,
+    projectDir: process.cwd(),
+    outfile,
+    minify,
+    watch,
+    mode,
+    sourcemap:  !minify,
+  }).then(({ ok }) => {
+    if (!ok && !watch) process.exit(1);
+  }).catch(e => {
+    err(e.message);
+    process.exit(1);
+  });
+}
+
+async function cmdFormat(args) {
+  // clarity format [target] [--check] [--stdin] [--write]
+  const check   = args.includes('--check');
+  const stdin   = args.includes('--stdin');
+  const target  = args.find(a => !a.startsWith('--')) ?? '.';
+
+  if (stdin) {
+    // stdin → stdout: editör pipe desteği
+    let input = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', d => input += d);
+    process.stdin.on('end', () => {
+      process.stdout.write(formatCode(input));
+    });
+    return;
+  }
+
+  let stat;
+  try { stat = statSync(target); } catch {
+    err(`Dosya/dizin bulunamadı: ${target}`);
+    process.exit(1);
+  }
+
+  if (stat.isDirectory()) {
+    header(`Formatting ${target}/**/*.clarity...`);
+    const results = await processDirectory(target, 'format', { write: !check });
+    const changed = results.filter(r => r.changed).length;
+    const total   = results.length;
+
+    if (check) {
+      if (changed > 0) {
+        warn(`${changed}/${total} dosya biçimlendirme gerektiriyor.`);
+        process.exit(1);
+      } else {
+        ok(`Tüm ${total} dosya doğru biçimlendirilmiş.`);
+      }
+    } else {
+      ok(`${changed} dosya biçimlendirildi (${total} toplam).`);
+    }
+  } else {
+    const { changed, content } = await formatFile(target, { write: !check });
+    if (check) {
+      if (changed) { warn(`${target} biçimlendirme gerektiriyor.`); process.exit(1); }
+      else ok(`${target} doğru biçimlendirilmiş.`);
+    } else {
+      if (changed) ok(`${target} biçimlendirildi.`);
+      else info(`${target} zaten doğru biçimde.`);
+    }
+  }
+}
+
+async function cmdLint(args) {
+  // clarity lint [target] [--fix] [--rule <name>] [--format json|compact|pretty]
+  const fix     = args.includes('--fix');
+  const fmtIdx  = args.indexOf('--format');
+  const fmtMode = fmtIdx >= 0 ? args[fmtIdx + 1] : 'pretty';
+  const ruleIdx = args.indexOf('--rule');
+  const ruleOverride = ruleIdx >= 0 ? args[ruleIdx + 1] : null;
+  const target  = args.find(a => !a.startsWith('--')) ?? '.';
+
+  let stat;
+  try { stat = statSync(target); } catch {
+    err(`Dosya/dizin bulunamadı: ${target}`);
+    process.exit(1);
+  }
+
+  const config  = await loadConfig();
+  const ruleOpts = ruleOverride
+    ? { ...config.rules, [ruleOverride]: 'error' }
+    : config.rules;
+
+  let results = [];
+
+  if (stat.isDirectory()) {
+    header(`Linting ${target}/**/*.clarity...`);
+    results = await processDirectory(target, 'lint', { fix, rules: ruleOpts });
+  } else {
+    results = [await lintFile(target, { fix, rules: ruleOpts })];
+  }
+
+  const report = formatLintReport(results, fmtMode);
+  log(report);
+
+  const totalErrors = results.reduce((s, r) => s + (r.errorCount ?? 0), 0);
+  if (fix) {
+    const fixed = results.filter(r => r.fixed).length;
+    if (fixed > 0) ok(`${fixed} dosyada otomatik düzeltme yapıldı.`);
+  }
+
+  if (totalErrors > 0) process.exit(1);
+}
+
+async function cmdSsg(args) {
+  // clarity ssg [pagesDir] [--out <outDir>] [--base <url>] [--concurrent N] [--verbose]
+  const outIdx    = args.indexOf('--out');
+  const baseIdx   = args.indexOf('--base');
+  const concIdx   = args.indexOf('--concurrent');
+  const outDir    = outIdx  >= 0 && args[outIdx  + 1] ? args[outIdx  + 1] : 'dist';
+  const baseUrl   = baseIdx >= 0 && args[baseIdx + 1] ? args[baseIdx + 1] : '';
+  const concurrent = concIdx >= 0 && args[concIdx + 1] ? parseInt(args[concIdx + 1], 10) : 4;
+  const verbose   = args.includes('--verbose') || args.includes('-v');
+  const pagesDir  = args.find(a => !a.startsWith('--')) ?? 'pages';
+
+  header(`Generating static site → ${outDir}/`);
+  info(`Pages: ${pagesDir}  |  Concurrent: ${concurrent}${baseUrl ? '  |  Base: ' + baseUrl : ''}`);
+
+  try {
+    const result = await generateStaticSite({
+      pagesDir,
+      outDir,
+      baseUrl,
+      concurrent,
+      verbose,
+    });
+
+    const { pages = [], duration = 0, errors = [] } = result ?? {};
+
+    log('');
+    if (errors.length > 0) {
+      for (const e of errors) err(`  ${e.path ?? e.file ?? '?'}: ${e.message ?? e}`);
+      warn(`${pages.length} page(s) generated, ${errors.length} error(s) — ${duration}ms`);
+      process.exit(1);
+    } else {
+      ok(`${pages.length} page(s) generated in ${duration}ms`);
+      if (verbose) for (const p of pages) info(`  → ${p}`);
+    }
+  } catch (e) {
+    err(`SSG failed: ${e.message}`);
+    if (verbose) console.error(e);
+    process.exit(1);
+  }
+}
+
+async function cmdAnalyze(args) {
+  // clarity analyze [distDir] [--json] [--open] [--out path] [--verbose]
+  const distDir = args.find(a => !a.startsWith('--')) ?? 'dist';
+  const outIdx  = args.indexOf('--out');
+  const outFile = outIdx >= 0 && args[outIdx + 1] ? args[outIdx + 1] : 'clarity-analyze.html';
+  const openBrowser = args.includes('--open');
+  const emitJson    = args.includes('--json');
+  const verbose     = args.includes('--verbose') || args.includes('-v');
+
+  header(`Analysing bundle in ${distDir}/...`);
+
+  try {
+    const report = await analyzeBundle({
+      distDir,
+      outFile,
+      open:    openBrowser,
+      json:    emitJson,
+      verbose: true,
+    });
+
+    ok(`Report generated → ${outFile}`);
+    info(`Total: ${(report.total / 1024).toFixed(1)} KB  |  JS: ${(report.totalJS / 1024).toFixed(1)} KB  |  ${report.fileCount} files`);
+
+    if (report.chunks.length > 0) {
+      info('Top 5 chunks:');
+      for (const c of report.chunks.slice(0, 5)) {
+        const bar = '▓'.repeat(Math.max(1, Math.round(c.size / report.chunks[0].size * 15)));
+        log(`  ${bar.padEnd(15)}  ${((c.size)/1024).toFixed(1).padStart(6)} KB  ${c.name}`);
+      }
+    }
+
+    if (openBrowser) info('Opening in browser…');
+  } catch (e) {
+    err(e.message);
+    process.exit(1);
+  }
+}
+
+function cmdDev(args) {
+  // Parse: clarity dev [dir] [--port N] [--open]
+  let dir  = process.cwd();
+  let port = 3000;
+  let open = false;
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--port' && args[i + 1]) { port = parseInt(args[i + 1], 10); i++; }
+    else if (args[i] === '--open')            { open = true; }
+    else if (!args[i].startsWith('--'))       { dir = args[i]; }
+  }
+
+  startDevServer({ dir, port, open });
+}
+
+function cmdHelp() {
+  printBanner();
+  log(`${c.bold}Usage:${c.reset}`);
+  log(`  clarity dev    [dir] [--port N] [--open]                  Start dev server with HMR`);
+  log(`  clarity bundle <entry.js> [--out dist/] [--minify] [--watch] [--prod]  Bundle for production`);
+  log(`  clarity build  <file.clarity>            Compile a .clarity file to .js`);
+  log(`  clarity build  <directory/>              Compile all .clarity files in a directory`);
+  log(`  clarity ssg     [pagesDir] [--out dist]  Generate static HTML for all pages`);
+  log(`  clarity analyze [dist]    [--open] [--json] [--out report.html]  Bundle size report`);;
+  log(`  clarity ssg    --base https://mysite.com --concurrent 8  Custom base URL & concurrency`);
+  log(`  clarity check  <file.clarity>            Check for errors without emitting`);
+  log(`  clarity format [dir|file] [--check]      Format .clarity files (--check: CI mode)`);
+  log(`  clarity format --stdin                   Read from stdin, write to stdout`);
+  log(`  clarity lint   [dir|file] [--fix]        Lint .clarity files`);
+  log(`  clarity lint   --rule <name> [dir|file]  Run a specific rule`);
+  log(`  clarity lint   --format json             JSON output`);
+  log(`  clarity types  <file.clarity>            Generate TypeScript .d.ts declarations`);
+  log(`  clarity ast    <file.clarity>            Print the AST as JSON`);
+  log(`  clarity demo                             Run a demo compilation`);
+  log(`  clarity help                             Show this help`);
+  log('');
+  log(`${c.bold}Examples:${c.reset}`);
+  log(`  clarity dev                         Serve cwd on port 3000`);
+  log(`  clarity dev ./my-app --port 8080    Serve ./my-app on port 8080`);
+  log(`  clarity build examples/counter.clarity`);
+  log(`  clarity build examples/`);
+  log(`  clarity ssg pages/ --out dist --base https://mysite.com`);
+  log(`  clarity ssg --verbose               SSG + ayrıntılı log`);
+  log(`  clarity format src/                 Biçimlendir`);
+  log(`  clarity format --check src/         CI kontrol (değişiklik yazmaz)`);
+  log(`  clarity lint src/ --fix             Lint + otomatik düzelt`);
+  log(`  clarity check src/App.clarity`);
+  log(`  clarity types src/App.clarity`);
+  log('');
+  log(`${c.dim}Clarity.js v0.5.0 — AI-Native UI Framework${c.reset}`);
+}
+
+// ─── Entry ───────────────────────────────────────────────────────────────────
+const [,, command, ...restArgs] = process.argv;
+const target = restArgs[0];
+
+switch (command) {
+  case 'dev':    cmdDev(restArgs); break;
+  case 'bundle': cmdBundle(restArgs); break;
+  case 'build': target ? cmdBuild(target) : (err('Usage: clarity build <file>'), process.exit(1)); break;
+  case 'check': target ? cmdCheck(target) : (err('Usage: clarity check <file>'), process.exit(1)); break;
+  case 'types': target ? cmdTypes(target) : (err('Usage: clarity types <file>'), process.exit(1)); break;
+  case 'ast':   target ? cmdAst(target)   : (err('Usage: clarity ast <file>'), process.exit(1));   break;
+  case 'format': cmdFormat(restArgs); break;
+  case 'lint':   cmdLint(restArgs);   break;
+  case 'ssg':     cmdSsg(restArgs);     break;
+  case 'analyze': cmdAnalyze(restArgs); break;
+  case 'demo':  cmdDemo(); break;
+  case 'help':
+  case '--help':
+  case '-h':
+  default:
+    cmdHelp();
+}