naider 1.7.0

package/bin/naide.js

@@ -0,0 +1,519 @@
+#!/usr/bin/env node
+
+import { readFileSync, writeFileSync, unlinkSync, watch as fsWatch, existsSync, mkdirSync, readdirSync, statSync } from 'fs';
+import { resolve, basename, extname, join, relative } from 'path';
+import { compile } from '../src/index.js';
+import { spawn } from 'child_process';
+
+const args = process.argv.slice(2);
+
+const flags = {
+  run: true,
+  emit: false,
+  ast: false,
+  tokens: false,
+  output: null,
+  help: false,
+  mode: null,
+  mid: false,
+  watch: false,
+};
+
+const files = [];
+
+for (let i = 0; i < args.length; i++) {
+  const arg = args[i];
+  switch (arg) {
+    case '--emit': case '-e': flags.emit = true; flags.run = false; break;
+    case '--ast': flags.ast = true; flags.run = false; break;
+    case '--tokens': flags.tokens = true; flags.run = false; break;
+    case '--output': case '-o': flags.output = args[++i]; break;
+    case '--help': case '-h': flags.help = true; break;
+    case '--x': case '-x': flags.mode = 'x'; break;
+    case '--mid': flags.mid = true; flags.run = false; break;
+    case '--watch': case '-w': flags.watch = true; break;
+    default: files.push(arg);
+  }
+}
+
+// ── VS Code Extension Install ──
+if (files[0] === 'vscode') {
+  const os = await import('os');
+  const extSrc = new URL('../vscode-naide', import.meta.url).pathname.replace(/^\/([A-Z]:)/, '$1');
+  const extName = 'irxk.naide-lang-1.1.0';
+  const extDir = join(os.homedir(), '.vscode', 'extensions', extName);
+
+  if (existsSync(extDir)) {
+    console.log(`\n  NAIDE VS Code extension already installed at:\n  ${extDir}\n`);
+    console.log('  To reinstall, delete the folder and run again.');
+    process.exit(0);
+  }
+
+  const copyDir = (src, dest) => {
+    mkdirSync(dest, { recursive: true });
+    for (const entry of readdirSync(src)) {
+      const srcPath = join(src, entry);
+      const destPath = join(dest, entry);
+      if (statSync(srcPath).isDirectory()) {
+        copyDir(srcPath, destPath);
+      } else {
+        writeFileSync(destPath, readFileSync(srcPath));
+      }
+    }
+  };
+
+  try {
+    copyDir(extSrc, extDir);
+    console.log(`\n  NAIDE VS Code extension installed!
+
+  Location: ${extDir}
+
+  Restart VS Code to activate.
+  Features: syntax highlighting, LSP diagnostics, autocomplete, hover docs
+`);
+  } catch (e) {
+    console.error(`  Error: ${e.message}`);
+    console.log('\n  Manual install: copy vscode-naide/ to ~/.vscode/extensions/irxk.naide-lang-1.1.0/');
+    process.exit(1);
+  }
+  process.exit(0);
+}
+
+// ── LSP ──
+if (files[0] === 'lsp') {
+  await import('../lsp/server.js');
+  await new Promise(() => {});
+}
+
+// ── REPL ──
+if (files[0] === 'repl' || (files.length === 0 && !flags.help)) {
+  const { createInterface } = await import('readline');
+  const { transpile } = await import('../src/index.js');
+
+  console.log(`\n  NAIDE REPL v1.6.0 — type NAIDE code, see JavaScript output`);
+  console.log(`  Type .exit to quit, .eval to toggle eval mode\n`);
+
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: '>>> ',
+  });
+
+  let buffer = '';
+  let inBlock = false;
+  let evalMode = false;
+  const evalContext = {};
+
+  function processInput(code) {
+    try {
+      const js = transpile(code)
+        .split('\n')
+        .filter(l => !l.startsWith('import '))
+        .join('\n')
+        .trim();
+
+      if (!js) return;
+
+      if (evalMode) {
+        const evalCode = js.replace(/\bconst\b/g, 'let');
+        try {
+          const result = (new Function('ctx', `with(ctx){${evalCode}; return typeof __last !== 'undefined' ? __last : undefined}`))(evalContext);
+          if (result !== undefined) console.log(result);
+        } catch (e) {
+          try { (new Function('ctx', `with(ctx){${evalCode}}`))(evalContext); } catch (e2) { console.error(`  Error: ${e2.message}`); }
+        }
+      } else {
+        console.log(js);
+      }
+    } catch (e) {
+      console.error(`  ${e.message.split('\n')[0]}`);
+    }
+  }
+
+  rl.prompt();
+  rl.on('line', (line) => {
+    if (line.trim() === '.exit') { rl.close(); process.exit(0); }
+    if (line.trim() === '.eval') {
+      evalMode = !evalMode;
+      console.log(`  Eval mode: ${evalMode ? 'ON' : 'OFF'}`);
+      rl.prompt();
+      return;
+    }
+
+    if (inBlock) {
+      if (line.trim() === '' && buffer.trim()) {
+        processInput(buffer);
+        buffer = '';
+        inBlock = false;
+        rl.setPrompt('>>> ');
+      } else {
+        buffer += '\n' + line;
+        rl.prompt();
+        return;
+      }
+    } else if (line.trim().endsWith(':') && !line.trim().startsWith('#')) {
+      buffer = line;
+      inBlock = true;
+      rl.setPrompt('... ');
+    } else if (line.trim()) {
+      processInput(line);
+    }
+    rl.prompt();
+  });
+
+  rl.on('close', () => process.exit(0));
+
+  // Keep the process running
+  await new Promise(() => {});
+}
+
+// ── Format ──
+if (files[0] === 'fmt') {
+  const targets = files.slice(1);
+  if (targets.length === 0) {
+    console.log('  Usage: naide fmt <file.naide> [file2.naide ...]');
+    process.exit(0);
+  }
+
+  for (const file of targets) {
+    const filePath = resolve(file);
+    try {
+      const source = readFileSync(filePath, 'utf-8');
+      const lines = source.split('\n');
+      const result = [];
+      let prevEmpty = false;
+
+      for (const line of lines) {
+        const trimmed = line.trimEnd();
+        if (trimmed === '') {
+          if (!prevEmpty) result.push('');
+          prevEmpty = true;
+          continue;
+        }
+        prevEmpty = false;
+
+        const indent = line.match(/^(\s*)/)[1];
+        const content = line.trimStart();
+        const level = Math.round(indent.length / 2);
+        let formatted = '  '.repeat(level) + content;
+
+        // Remove trailing whitespace
+        formatted = formatted.trimEnd();
+
+        result.push(formatted);
+      }
+
+      // Remove trailing empty lines
+      while (result.length > 0 && result[result.length - 1] === '') result.pop();
+      const formatted = result.join('\n') + '\n';
+
+      if (formatted !== source) {
+        writeFileSync(filePath, formatted, 'utf-8');
+        console.log(`  formatted: ${file}`);
+      } else {
+        console.log(`  unchanged: ${file}`);
+      }
+    } catch (e) {
+      console.error(`  Error: ${file} — ${e.message}`);
+    }
+  }
+  process.exit(0);
+}
+
+if (files[0] === 'init') {
+  const dir = files[1] ? resolve(files[1]) : process.cwd();
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  const name = basename(dir === process.cwd() ? dir : dir);
+
+  if (!existsSync(resolve(dir, 'package.json'))) {
+    writeFileSync(resolve(dir, 'package.json'), JSON.stringify({
+      name, version: '1.0.0', type: 'module',
+      scripts: { start: 'naide app.naide', dev: 'naide -w app.naide', build: 'naide --emit app.naide -o dist/app.mjs' },
+      dependencies: { naider: '^1.7.0' }
+    }, null, 2) + '\n');
+  }
+
+  if (!existsSync(resolve(dir, 'app.naide'))) {
+    writeFileSync(resolve(dir, 'app.naide'), `db "data/"
+
+env:
+  PORT int default(3000)
+
+schema Item:
+  id auto
+  name str required min(1) max(100)
+  done bool default(false)
+
+server app port PORT:
+  cors "*"
+  cookie
+  static "/public"
+  crud "/api/items" Item
+
+  get "/":
+    ret.text "NAIDE server running"
+
+  get "/api/health":
+    ret {status: "ok", items: ItemStore.count()}
+`);
+  }
+
+  if (!existsSync(resolve(dir, 'public'))) mkdirSync(resolve(dir, 'public'), { recursive: true });
+
+  console.log(`\n  NAIDE project initialized!
+
+  ${dir === process.cwd() ? '' : `  cd ${basename(dir)}\n`}  npm install
+  npm run dev
+`);
+  process.exit(0);
+}
+
+if (files[0] === 'build') {
+  const dir = resolve(files[1] || '.');
+  const outDir = files[2] ? resolve(files[2]) : null;
+
+  function walkDir(d) {
+    const found = [];
+    for (const entry of readdirSync(d)) {
+      const full = join(d, entry);
+      if (statSync(full).isDirectory()) {
+        if (entry === 'node_modules' || entry === '.git' || entry === 'dist') continue;
+        found.push(...walkDir(full));
+      } else if (entry.endsWith('.naide') || entry.endsWith('.nx')) {
+        found.push(full);
+      }
+    }
+    return found;
+  }
+
+  const sourceFiles = walkDir(dir);
+  if (sourceFiles.length === 0) {
+    console.log('  No .naide or .nx files found.');
+    process.exit(0);
+  }
+
+  console.log(`\n  NAIDE build — ${sourceFiles.length} file(s)\n`);
+  let errors = 0;
+  for (const srcFile of sourceFiles) {
+    const rel = relative(dir, srcFile);
+    const mode = srcFile.endsWith('.nx') ? 'x' : 'naide';
+    try {
+      const source = readFileSync(srcFile, 'utf-8');
+      const { js } = compile(source, { mode });
+      const outName = rel.replace(/\.(naide|nx)$/, '.mjs');
+      const outPath = outDir ? join(outDir, outName) : join(dir, outName);
+      const outDirPath = resolve(outPath, '..');
+      if (!existsSync(outDirPath)) mkdirSync(outDirPath, { recursive: true });
+      writeFileSync(outPath, js);
+      console.log(`  ${rel} → ${outDir ? join(relative('.', outDir), outName) : outName}`);
+    } catch (e) {
+      console.error(`  FAIL ${rel}: ${e.message.split('\n')[0]}`);
+      errors++;
+    }
+  }
+  console.log(`\n  Done. ${sourceFiles.length - errors} compiled, ${errors} failed.`);
+  process.exit(errors > 0 ? 1 : 0);
+}
+
+// ── Deploy ──
+if (files[0] === 'deploy') {
+  const dir = resolve(files[1] || '.');
+
+  const dockerfileContent = `FROM node:20-alpine
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --production
+COPY . .
+RUN npx naide build . dist
+EXPOSE 3000
+CMD ["node", "dist/app.mjs"]
+`;
+
+  const dockerignoreContent = `node_modules
+.git
+*.naide
+*.nx
+.naide_tmp_*
+dist
+`;
+
+  writeFileSync(resolve(dir, 'Dockerfile'), dockerfileContent);
+  writeFileSync(resolve(dir, '.dockerignore'), dockerignoreContent);
+
+  const pkgPath = resolve(dir, 'package.json');
+  if (existsSync(pkgPath)) {
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+    if (!pkg.scripts) pkg.scripts = {};
+    pkg.scripts['docker:build'] = 'docker build -t naide-app .';
+    pkg.scripts['docker:run'] = 'docker run -p 3000:3000 naide-app';
+    writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+  }
+
+  console.log(`\n  NAIDE deploy files generated!
+
+  Files created:
+    Dockerfile
+    .dockerignore
+
+  Commands:
+    docker build -t naide-app .
+    docker run -p 3000:3000 naide-app
+
+  Or use npm scripts:
+    npm run docker:build
+    npm run docker:run
+`);
+  process.exit(0);
+}
+
+if (flags.help) {
+  console.log(`
+  NAIDE - Node AI Development Environment
+  A language designed for AI-speed code generation
+
+  Usage:
+    naide                        Start interactive REPL
+    naide <file.naide>           Run a NAIDE file
+    naide <file.nx>              Run a NAIDE-X file (auto-detected)
+    naide init [dir]             Create a new NAIDE project
+    naide build [dir] [outdir]   Transpile all files to JavaScript
+    naide repl                   Start interactive REPL
+    naide lsp                    Start language server (LSP)
+    naide vscode                 Install VS Code extension
+    naide deploy [dir]           Generate Dockerfile for deployment
+    naide fmt <files...>         Format NAIDE files
+    naide --emit <file>          Output generated JavaScript
+    naide --mid <file.nx>        Output intermediate NAIDE v1 (debug)
+    naide -x <file.naide>        Force NAIDE-X mode
+    naide -w <file.naide>        Watch mode (auto-restart on changes)
+
+  Modes:
+    .naide  Standard NAIDE (~40% fewer tokens than JS)
+    .nx     NAIDE-X extreme (~80% fewer tokens than JS)
+
+  Options:
+    -e, --emit     Print generated JavaScript
+    -o, --output   Write generated JavaScript to file
+    -x             Force NAIDE-X mode
+    -w, --watch    Watch mode: restart on file changes
+    --mid          Show intermediate NAIDE v1 (X mode only)
+    --ast          Print AST
+    --tokens       Print tokens
+    -h, --help     Show this help
+`);
+  process.exit(0);
+}
+
+const runtimeUrl = new URL('../src/runtime.js', import.meta.url).href;
+
+for (const file of files) {
+  const filePath = resolve(file);
+  let source;
+  try {
+    source = readFileSync(filePath, 'utf-8');
+  } catch (err) {
+    console.error(`Error: Cannot read file '${file}'`);
+    process.exit(1);
+  }
+
+  const ext = extname(file);
+  const mode = flags.mode || (ext === '.nx' ? 'x' : 'naide');
+
+  try {
+    if (flags.mid && mode === 'x') {
+      const { preprocess } = await import('../src/preprocess.js');
+      console.log(preprocess(source));
+      continue;
+    }
+
+    const runtimePath = flags.emit || flags.output ? 'naider/runtime' : runtimeUrl;
+
+    if (flags.watch) {
+      const tempFile = resolve(`.naide_tmp_${basename(file, ext)}.mjs`);
+      let child = null;
+
+      function start() {
+        try {
+          source = readFileSync(filePath, 'utf-8');
+          const result = compile(source, { mode, runtimePath });
+          writeFileSync(tempFile, result.js, 'utf-8');
+          child = spawn(process.execPath, [tempFile], { stdio: 'inherit' });
+          child.on('error', (err) => console.error(`[NAIDE] Process error: ${err.message}`));
+          child.on('exit', (code) => {
+            if (code !== null && code !== 0) console.log(`[NAIDE] Process exited with code ${code}`);
+          });
+        } catch (err) {
+          console.error(`\n${err.message}`);
+        }
+      }
+
+      function restart() {
+        console.log('\n[NAIDE] Change detected. Restarting...');
+        if (child) { child.kill(); child = null; }
+        start();
+      }
+
+      console.log(`[NAIDE] Watch mode — ${file}`);
+      start();
+
+      let debounce = null;
+      fsWatch(filePath, () => {
+        if (debounce) clearTimeout(debounce);
+        debounce = setTimeout(restart, 200);
+      });
+
+      process.on('SIGINT', () => {
+        if (child) child.kill();
+        try { unlinkSync(tempFile); } catch {}
+        process.exit(0);
+      });
+
+      process.on('SIGTERM', () => {
+        if (child) child.kill();
+        process.exit(0);
+      });
+
+      continue;
+    }
+
+    const result = compile(source, { mode, runtimePath });
+
+    if (flags.tokens) {
+      console.log(JSON.stringify(result.tokens, null, 2));
+      continue;
+    }
+
+    if (flags.ast) {
+      console.log(JSON.stringify(result.ast, null, 2));
+      continue;
+    }
+
+    if (flags.output) {
+      writeFileSync(flags.output, result.js, 'utf-8');
+      console.log(`Written to ${flags.output}`);
+      continue;
+    }
+
+    if (flags.emit) {
+      console.log(result.js);
+      continue;
+    }
+
+    // Run mode
+    const tempFile = resolve(`.naide_tmp_${basename(file, ext)}.mjs`);
+    writeFileSync(tempFile, result.js, 'utf-8');
+
+    try {
+      await import('file:///' + tempFile.replace(/\\/g, '/'));
+    } finally {
+      try {
+        const { unlinkSync } = await import('fs');
+        unlinkSync(tempFile);
+      } catch {}
+    }
+  } catch (err) {
+    console.error(`\n${err.message}`);
+    if (process.env.NAIDE_DEBUG) console.error(err.stack);
+    process.exit(1);
+  }
+}

package/examples/ai-app.naide

@@ -0,0 +1,21 @@
+# AI-powered API
+# Set AI_KEY or OPENAI_API_KEY env var
+
+server app port 3000:
+  cors "*"
+
+  post "/api/ask" (req, res):
+    str answer = await ai.ask(req.body.prompt)
+    ret {answer}
+
+  post "/api/summarize" (req, res):
+    str summary = await ai.ask("Summarize this text concisely: {req.body.text}")
+    ret {summary}
+
+  post "/api/extract" (req, res):
+    map data = await ai.json("Extract name, email, and phone from: {req.body.text}", {name: "string", email: "string", phone: "string"})
+    ret data
+
+  post "/api/chat" (req, res):
+    str reply = await ai.chat(req.body.messages)
+    ret {reply}

package/examples/ai-app.nx

@@ -0,0 +1,21 @@
+-- AI-powered API (NAIDE-X)
+-- Set AI_KEY or OPENAI_API_KEY env var
+
+$app:3000
+  cors "*"
+
+  P"/api/ask"(req,res)
+    s:answer=~ai.ask(req.body.prompt)
+    >{answer}
+
+  P"/api/summarize"(req,res)
+    s:summary=~ai.ask("Summarize: {req.body.text}")
+    >{summary}
+
+  P"/api/extract"(req,res)
+    m:data=~ai.json("Extract name, email, phone: {req.body.text}",{name:"string",email:"string",phone:"string"})
+    >data
+
+  P"/api/chat"(req,res)
+    s:reply=~ai.chat(req.body.messages)
+    >{reply}

package/examples/async.naide

@@ -0,0 +1,50 @@
+# NAIDE - Async/Await & エラーハンドリング
+# 非同期処理がシンプル
+
+# 非同期関数
+fn.async fetchData(str url) -> any:
+  any response = await fetch(url)
+  any data = await response.json()
+  ret data
+
+# パイプで変換チェーン
+fn.async getTopUsers() -> list:
+  any data = await fetchData("https://jsonplaceholder.typicode.com/users")
+  list result = data
+    |> filter((u) => u.name.length > 5)
+    |> map((u) => {name: u.name, email: u.email})
+  ret result
+
+# エラーハンドリング
+fn.async safeFetch(str url) -> map:
+  try:
+    any data = await fetchData(url)
+    ret {ok: true, data: data}
+  fail e:
+    log.error "Fetch failed: {e.message}"
+    ret {ok: false, error: e.message}
+
+# await.all で並列実行
+fn.async loadDashboard() -> map:
+  list urls = [
+    "https://jsonplaceholder.typicode.com/users",
+    "https://jsonplaceholder.typicode.com/posts",
+    "https://jsonplaceholder.typicode.com/todos"
+  ]
+  list results = await.all urls.map((url) => fetchData(url))
+  ret {
+    users: results[0],
+    posts: results[1],
+    todos: results[2]
+  }
+
+# 実行
+fn.async main():
+  log "Fetching data..."
+  map dashboard = await safeFetch("https://jsonplaceholder.typicode.com/users")
+  if dashboard.ok:
+    log "Got {dashboard.data.length} items"
+  else:
+    log.error dashboard.error
+
+main()

package/examples/async.nx

@@ -0,0 +1,40 @@
+-- NAIDE-X async/await
+
+~f fetchData(s:url)a
+  a:res=~fetch(url)
+  a:data=~res.json()
+  >data
+
+~f getTopUsers()l
+  a:data=~fetchData("https://jsonplaceholder.typicode.com/users")
+  l:result=data
+    |>filter((u)=>u.name.length>5)
+    |>map((u)=>({name:u.name,email:u.email}))
+  >result
+
+~f safeFetch(s:url)m
+  !
+    a:data=~fetchData(url)
+    >{ok:true,data:data}
+  !!e
+    log.e"Fetch failed: {e.message}"
+    >{ok:false,error:e.message}
+
+~f loadDash()m
+  l:urls=[
+    "https://jsonplaceholder.typicode.com/users",
+    "https://jsonplaceholder.typicode.com/posts",
+    "https://jsonplaceholder.typicode.com/todos"
+  ]
+  l:results=~~urls.map((url)=>fetchData(url))
+  >{users:results[0],posts:results[1],todos:results[2]}
+
+~f main()
+  log"Fetching data..."
+  m:dash=~safeFetch("https://jsonplaceholder.typicode.com/users")
+  ?dash.ok
+    log"Got {dash.data.length} items"
+  :
+    log.e dash.error
+
+main()