naider 1.18.0 → 1.20.0

package/bin/naide.js

@@ -8,6 +8,42 @@ import { spawn } from 'child_process';
 import { createRequire } from 'module';
 const _require = createRequire(import.meta.url);
 
+const NAIDE_VERSION = '1.20.0';
+
+function crashReport(err, context = {}) {
+  const info = [
+    `NAIDE v${NAIDE_VERSION}`,
+    `Node ${process.version}`,
+    `${process.platform} ${process.arch}`,
+  ];
+  if (context.file) info.push(`File: ${context.file}`);
+  if (context.target) info.push(`Target: ${context.target}`);
+
+  console.error(`\n  ┌─ NAIDE Internal Error ───────────────────────────`);
+  console.error(`  │ ${err.message}`);
+  console.error(`  │`);
+  console.error(`  │ ${info.join(' | ')}`);
+  if (err.stack) {
+    const frames = err.stack.split('\n').slice(1, 4).map(l => l.trim());
+    for (const f of frames) console.error(`  │   ${f}`);
+  }
+  console.error(`  │`);
+  console.error(`  │ This is a compiler bug, not a syntax error.`);
+  console.error(`  │ Report: https://github.com/irxk/naide/issues/new`);
+  console.error(`  │   Include the .naide file and the info above.`);
+  console.error(`  └──────────────────────────────────────────────────\n`);
+}
+
+process.on('uncaughtException', (err) => {
+  crashReport(err);
+  process.exit(99);
+});
+
+process.on('unhandledRejection', (reason) => {
+  crashReport(reason instanceof Error ? reason : new Error(String(reason)));
+  process.exit(99);
+});
+
 function checkDependencies(jsCode) {
   const depMap = {
     "from 'express'": { pkg: 'express', reason: 'server' },
@@ -77,6 +113,7 @@ const flags = {
   debug: false,
   check: false,
   target: 'node',
+  expand: false,
 };
 
 const files = [];
@@ -95,10 +132,108 @@ for (let i = 0; i < args.length; i++) {
     case '--debug': case '-d': flags.debug = true; break;
     case '--check': flags.check = true; flags.run = false; break;
     case '--target': case '-t': flags.target = args[++i]; break;
+    case '--expand': flags.expand = true; flags.run = false; break;
     default: files.push(arg);
   }
 }
 
+// ── Code Generator (~~) ──
+if (files[0] === 'gen' || files[0] === '~~') {
+  const instruction = files.slice(1).join(' ');
+  if (!instruction) {
+    console.log(`
+  NAIDE Code Generator (~~)
+
+  Usage:
+    naide ~~ "REST API for users with auth"
+    naide gen "todo app with database"
+    naide gen "Discord bot with hello command"
+
+  Generates valid NAIDE code from natural language instructions.
+  No AI, no network — pure pattern matching with self-healing validation.
+
+  Examples:
+    naide ~~ "REST API for products with name price stock"
+    naide ~~ "blog app with auth and database"
+    naide ~~ "Discord bot with hello and help commands"
+    naide ~~ "CLI tool"
+    naide ~~ "chat app with websocket"
+    naide ~~ "user management fullstack app"
+    naide ~~ "ユーザー管理APIを認証付きで"
+    naide ~~ "掲示板アプリ"
+
+  In .naide files:
+    ~~ "REST API for users with auth"
+    # Expands at compile time to full NAIDE code
+
+  Debug:
+    naide --expand app.naide     Show ~~ expansion results
+
+  API:
+    import { generate } from 'naider';
+    const result = generate("REST API for users");
+    console.log(result.code);
+
+  ── Keyword Cheat Sheet ──────────────────────────────────────
+
+  Intent     server, api, rest, bot, cli, page, test, database,
+             ai, crud, auth, websocket, mail, graphql
+  Composite  todo, blog, chat, shop, fullstack, board
+  Platform   discord, slack, telegram, line
+  DB Type    sqlite, postgres
+  JP Intent  サーバー, 認証, ログイン, 会員, CRUD, 管理, データベース,
+             ボット, テスト, ページ, メール, リアルタイム
+  JP Entity  ユーザー, 商品, 記事, タスク, 注文, コメント, イベント,
+             問い合わせ, 通知, カテゴリ, プロジェクト, 掲示板, 決済
+  Fields     "with name email age" — auto-inferred types & validators
+  Field Alias  e-mail→email, pwd→password, tel→phone, desc→description
+
+  ────────────────────────────────────────────────────────────
+`);
+    process.exit(0);
+  }
+
+  const { generate } = await import('../src/gen.js');
+  const result = generate(instruction);
+
+  if (flags.output) {
+    writeFileSync(flags.output, result.code, 'utf-8');
+    console.log(`  Generated: ${flags.output} (${result.intents.join(' + ')})`);
+  } else {
+    console.log(result.code);
+    const meta = [`[${result.intents.join(' + ')}]`];
+    if (result.schema) meta.push(`→ ${result.schema}`);
+    meta.push(`valid: ${result.valid}`);
+    if (result.fixed) meta.push('(auto-fixed)');
+    process.stderr.write(`\n  ── gen ~~ ${meta.join(' ')} ──\n`);
+    if (result.repairs.length > 0) {
+      process.stderr.write('  Repairs:\n');
+      for (const r of result.repairs) process.stderr.write(`    - ${r}\n`);
+    }
+    if (result.suggestion) {
+      process.stderr.write(`\n${result.suggestion}\n`);
+    }
+  }
+  process.exit(0);
+}
+
+// ── Expand Debug ──
+if (flags.expand && files.length > 0) {
+  const { expandDirectives } = await import('../src/gen.js');
+  for (const file of files) {
+    const filePath = resolve(file);
+    const source = readFileSync(filePath, 'utf-8');
+    const { source: expanded, expanded: didExpand } = expandDirectives(source);
+    if (didExpand) {
+      console.log(`  ── ${file} (expanded) ──\n`);
+      console.log(expanded);
+    } else {
+      console.log(`  ${file}: no ~~ directives found`);
+    }
+  }
+  process.exit(0);
+}
+
 // ── VS Code Extension Install ──
 if (files[0] === 'vscode') {
   const os = await import('os');
@@ -357,24 +492,67 @@ if (files[0] === 'build') {
 
   console.log(`\n  NAIDE build — ${sourceFiles.length} file(s)\n`);
   let errors = 0;
+  const schemaMap = {};
+  const routeMap = {};
+
   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 { js, ast } = 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}`);
+
+      if (ast && ast.body) {
+        for (const node of ast.body) {
+          if (node.type === 'SchemaDecl' && node.name) {
+            (schemaMap[node.name] = schemaMap[node.name] || []).push(rel);
+          }
+          if (node.type === 'Server' && node.routes) {
+            for (const s of node.routes) {
+              if (s.type === 'CrudDecl' && s.path) {
+                const key = `CRUD ${s.path.raw || s.path}`;
+                (routeMap[key] = routeMap[key] || []).push(rel);
+              }
+              if (s.type === 'Route' && s.path) {
+                const key = `${(s.method || 'get').toUpperCase()} ${s.path.raw || s.path}`;
+                (routeMap[key] = routeMap[key] || []).push(rel);
+              }
+            }
+          }
+        }
+      }
     } catch (e) {
-      console.error(`  FAIL ${rel}: ${e.message.split('\n')[0]}`);
+      const isSyntaxErr = e.message.includes('line ') || e.message.includes('Unexpected') || e.message.includes('Expected');
+      if (isSyntaxErr) {
+        console.error(`  FAIL ${rel}: ${e.message.split('\n')[0]}`);
+      } else {
+        crashReport(e, { file: rel });
+      }
       errors++;
     }
   }
-  console.log(`\n  Done. ${sourceFiles.length - errors} compiled, ${errors} failed.`);
+
+  let warnings = 0;
+  for (const [name, files] of Object.entries(schemaMap)) {
+    if (files.length > 1) {
+      console.error(`  WARN: schema "${name}" defined in ${files.length} files: ${files.join(', ')}`);
+      warnings++;
+    }
+  }
+  for (const [route, files] of Object.entries(routeMap)) {
+    if (files.length > 1) {
+      console.error(`  WARN: route ${route} defined in ${files.length} files: ${files.join(', ')}`);
+      warnings++;
+    }
+  }
+
+  console.log(`\n  Done. ${sourceFiles.length - errors} compiled, ${errors} failed${warnings > 0 ? `, ${warnings} warning(s)` : ''}.`);
   process.exit(errors > 0 ? 1 : 0);
 }
 
@@ -664,6 +842,8 @@ if (flags.help) {
     naide                        Start interactive REPL
     naide <file.naide>           Run a NAIDE file
     naide <file.nx>              Run a NAIDE-X file (auto-detected)
+    naide ~~ "instruction"       Generate NAIDE code from instruction (no AI)
+    naide gen "instruction"      Same as ~~ (alias)
     naide init [dir]             Create a new NAIDE project
     naide build [dir] [outdir]   Transpile all files to JavaScript
     naide check <files...>       Type-check without running
@@ -683,10 +863,28 @@ if (flags.help) {
     naide -w <file.naide>        Watch mode (auto-restart on changes)
     naide -d <file>              Debug mode (Node.js inspector)
 
-  Targets:
+  Code Generation (~~):
+    naide ~~ "instruction"       Generate code from instruction (no AI)
+    naide gen "instruction"      Alias for ~~
+    naide --expand <file>        Show ~~ directive expansion results
+    In .naide files: ~~ "instruction" expands at compile time
+
+  Targets (15):
     node    Node.js / JavaScript (default)
     bun     Bun-optimized JavaScript
-    python  Python (Flask for servers)
+    ts      TypeScript
+    python  Python (Flask)
+    go      Go (net/http)
+    java    Java (HttpServer)
+    rust    Rust (actix-web)
+    cpp     C++ (cpp-httplib)
+    c       C (libmicrohttpd)
+    csharp  C# (ASP.NET)
+    kotlin  Kotlin (Ktor)
+    swift   Swift (Vapor)
+    dart    Dart (shelf)
+    php     PHP
+    ruby    Ruby (Sinatra)
 
   Modes:
     .naide  Standard NAIDE (~40% fewer tokens than JS)
@@ -701,9 +899,18 @@ if (flags.help) {
     -t, --target   Compile target: node (default), bun, python/py
     --check        Type-check files without running
     --mid          Show intermediate NAIDE v1 (X mode only)
+    --expand       Show ~~ directive expansion (debug)
     --ast          Print AST
     --tokens       Print tokens
     -h, --help     Show this help
+
+  ~~ Keyword Cheat Sheet:
+    Intent     server api rest bot cli page test database ai crud auth ws mail graphql
+    Composite  todo blog chat shop fullstack board
+    Platform   discord slack telegram line
+    JP Intent  サーバー 認証 ログイン 会員 CRUD 管理 データベース ボット テスト ページ
+    JP Entity  ユーザー 商品 記事 タスク 注文 コメント イベント 問い合わせ 掲示板 決済
+    Fields     "with name email age done" → auto-inferred types
 `);
   process.exit(0);
 }
@@ -872,7 +1079,12 @@ for (const file of files) {
       } catch {}
     }
   } catch (err) {
-    console.error(`\n${err.message}`);
+    const isSyntaxErr = err.message.includes('line ') || err.message.includes('Unexpected') || err.message.includes('Expected');
+    if (isSyntaxErr) {
+      console.error(`\n${err.message}`);
+    } else {
+      crashReport(err, { file, target: flags.target });
+    }
     if (process.env.NAIDE_DEBUG) console.error(err.stack);
     process.exit(1);
   }

package/mcp/server.js

@@ -0,0 +1,249 @@
+#!/usr/bin/env node
+
+import { createInterface } from 'readline';
+import { resolve, dirname } from 'path';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+let compileModule = null;
+async function getCompiler() {
+  if (!compileModule) {
+    compileModule = await import(resolve(__dirname, '..', 'src', 'index.js'));
+  }
+  return compileModule;
+}
+
+function send(msg) {
+  const json = JSON.stringify(msg);
+  const buf = Buffer.from(json, 'utf-8');
+  process.stdout.write(`Content-Length: ${buf.length}\r\n\r\n`);
+  process.stdout.write(buf);
+}
+
+function respond(id, result) {
+  send({ jsonrpc: '2.0', id, result });
+}
+
+function respondError(id, code, message) {
+  send({ jsonrpc: '2.0', id, error: { code, message } });
+}
+
+const TOOLS = [
+  {
+    name: 'naide_compile',
+    description: 'Compile NAIDE code to a target language. NAIDE is an AI-optimized language that transpiles to 15 targets.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        code: { type: 'string', description: 'NAIDE source code to compile' },
+        target: {
+          type: 'string',
+          description: 'Target language (default: node)',
+          enum: ['node', 'python', 'bun', 'typescript', 'go', 'java', 'rust', 'cpp', 'c', 'csharp', 'kotlin', 'swift', 'dart', 'php', 'ruby']
+        }
+      },
+      required: ['code']
+    }
+  },
+  {
+    name: 'naide_run',
+    description: 'Compile NAIDE code to JavaScript and execute it. Returns stdout output.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        code: { type: 'string', description: 'NAIDE source code to run' }
+      },
+      required: ['code']
+    }
+  },
+  {
+    name: 'naide_targets',
+    description: 'List all available NAIDE compilation targets with details.',
+    inputSchema: { type: 'object', properties: {} }
+  },
+  {
+    name: 'naide_generate',
+    description: 'Generate NAIDE code from a natural language instruction. No AI — uses pattern matching and template composition with self-healing parser validation. Extremely lightweight, runs in microseconds.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        instruction: { type: 'string', description: 'Natural language instruction (e.g. "REST API for users with auth", "Discord bot", "todo app")' },
+        port: { type: 'number', description: 'Server port (default: 3000)' },
+        schemaName: { type: 'string', description: 'Override schema/entity name' }
+      },
+      required: ['instruction']
+    }
+  },
+  {
+    name: 'naide_spec',
+    description: 'Get the NAIDE language specification. Use this to understand NAIDE syntax before writing code.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        section: {
+          type: 'string',
+          description: 'Optional section to retrieve (e.g. "variables", "functions", "server"). Omit for full spec.'
+        }
+      }
+    }
+  }
+];
+
+const TARGETS_INFO = [
+  { name: 'node', language: 'JavaScript (ES Modules)', server: 'Express', flag: 'default' },
+  { name: 'python', language: 'Python', server: 'Flask', flag: '--target python' },
+  { name: 'bun', language: 'JavaScript (Bun)', server: 'Bun.serve', flag: '--target bun' },
+  { name: 'typescript', language: 'TypeScript', server: 'Express', flag: '--target ts' },
+  { name: 'go', language: 'Go', server: 'net/http', flag: '--target go' },
+  { name: 'java', language: 'Java', server: 'HttpServer', flag: '--target java' },
+  { name: 'rust', language: 'Rust', server: 'actix-web', flag: '--target rust' },
+  { name: 'cpp', language: 'C++', server: 'cpp-httplib', flag: '--target cpp' },
+  { name: 'c', language: 'C', server: 'libmicrohttpd', flag: '--target c' },
+  { name: 'csharp', language: 'C#', server: 'ASP.NET', flag: '--target csharp' },
+  { name: 'kotlin', language: 'Kotlin', server: 'Ktor', flag: '--target kotlin' },
+  { name: 'swift', language: 'Swift', server: 'Vapor', flag: '--target swift' },
+  { name: 'dart', language: 'Dart', server: 'shelf', flag: '--target dart' },
+  { name: 'php', language: 'PHP', server: 'Built-in / Laravel', flag: '--target php' },
+  { name: 'ruby', language: 'Ruby', server: 'Sinatra', flag: '--target ruby' },
+];
+
+async function handleToolCall(name, args) {
+  const { compile, compileAsync } = await getCompiler();
+
+  switch (name) {
+    case 'naide_compile': {
+      const target = args.target || 'node';
+      try {
+        if (target === 'node') {
+          const result = compile(args.code);
+          return { content: [{ type: 'text', text: result.js }] };
+        }
+        const result = await compileAsync(args.code, { target });
+        return { content: [{ type: 'text', text: result.code }] };
+      } catch (e) {
+        return { content: [{ type: 'text', text: `Compilation error: ${e.message}` }], isError: true };
+      }
+    }
+
+    case 'naide_run': {
+      try {
+        const result = compile(args.code);
+        const AsyncFunction = Object.getPrototypeOf(async function(){}).constructor;
+        let output = '';
+        const fakeConsole = { log: (...a) => { output += a.map(String).join(' ') + '\n'; }, error: (...a) => { output += a.map(String).join(' ') + '\n'; } };
+        const fn = new AsyncFunction('console', result.js);
+        await fn(fakeConsole);
+        return { content: [{ type: 'text', text: output || '(no output)' }] };
+      } catch (e) {
+        return { content: [{ type: 'text', text: `Error: ${e.message}` }], isError: true };
+      }
+    }
+
+    case 'naide_targets': {
+      const text = TARGETS_INFO.map(t => `${t.name.padEnd(12)} ${t.language.padEnd(25)} ${t.server.padEnd(20)} ${t.flag}`).join('\n');
+      return { content: [{ type: 'text', text: `NAIDE Compilation Targets (15):\n\n${'Target'.padEnd(12)} ${'Language'.padEnd(25)} ${'Server'.padEnd(20)} Flag\n${'─'.repeat(75)}\n${text}` }] };
+    }
+
+    case 'naide_generate': {
+      try {
+        const { generate } = await import(resolve(__dirname, '..', 'src', 'gen.js'));
+        const opts = {};
+        if (args.port) opts.port = args.port;
+        if (args.schemaName) opts.schemaName = args.schemaName;
+        const result = generate(args.instruction, opts);
+        const meta = `[${result.intents.join(' + ')}]${result.schema ? ` → ${result.schema}` : ''} | valid: ${result.valid}${result.fixed ? ' (auto-fixed)' : ''}`;
+        return { content: [{ type: 'text', text: `${result.code}\n# ${meta}` }] };
+      } catch (e) {
+        return { content: [{ type: 'text', text: `Generation error: ${e.message}` }], isError: true };
+      }
+    }
+
+    case 'naide_spec': {
+      try {
+        let spec = readFileSync(resolve(__dirname, '..', 'SPEC.naide'), 'utf-8');
+        if (args.section) {
+          const s = args.section.toLowerCase();
+          const lines = spec.split('\n');
+          const chunks = [];
+          let capturing = false;
+          for (const line of lines) {
+            if (line.startsWith('# ---- ') && line.toLowerCase().includes(s)) capturing = true;
+            else if (line.startsWith('# ---- ') && capturing) break;
+            if (capturing) chunks.push(line);
+          }
+          if (chunks.length > 0) spec = chunks.join('\n');
+        }
+        return { content: [{ type: 'text', text: spec }] };
+      } catch (e) {
+        return { content: [{ type: 'text', text: `Error reading spec: ${e.message}` }], isError: true };
+      }
+    }
+
+    default:
+      return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
+  }
+}
+
+async function handleMessage(msg) {
+  switch (msg.method) {
+    case 'initialize':
+      respond(msg.id, {
+        protocolVersion: '2024-11-05',
+        capabilities: { tools: {} },
+        serverInfo: { name: 'naide-mcp', version: '1.20.0' }
+      });
+      break;
+
+    case 'notifications/initialized':
+      break;
+
+    case 'tools/list':
+      respond(msg.id, { tools: TOOLS });
+      break;
+
+    case 'tools/call':
+      try {
+        const result = await handleToolCall(msg.params.name, msg.params.arguments || {});
+        respond(msg.id, result);
+      } catch (e) {
+        respondError(msg.id, -32000, e.message);
+      }
+      break;
+
+    case 'ping':
+      respond(msg.id, {});
+      break;
+
+    default:
+      if (msg.id !== undefined) {
+        respondError(msg.id, -32601, `Method not found: ${msg.method}`);
+      }
+  }
+}
+
+let buffer = '';
+process.stdin.setEncoding('utf-8');
+process.stdin.on('data', (chunk) => {
+  buffer += chunk;
+  while (true) {
+    const headerEnd = buffer.indexOf('\r\n\r\n');
+    if (headerEnd === -1) break;
+    const header = buffer.slice(0, headerEnd);
+    const match = header.match(/Content-Length:\s*(\d+)/i);
+    if (!match) { buffer = buffer.slice(headerEnd + 4); continue; }
+    const len = parseInt(match[1], 10);
+    const bodyStart = headerEnd + 4;
+    if (buffer.length < bodyStart + len) break;
+    const body = buffer.slice(bodyStart, bodyStart + len);
+    buffer = buffer.slice(bodyStart + len);
+    try {
+      handleMessage(JSON.parse(body));
+    } catch (e) {
+      process.stderr.write(`Parse error: ${e.message}\n`);
+    }
+  }
+});
+
+process.stderr.write('NAIDE MCP Server running on stdio\n');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "naider",
-  "version": "1.18.0",
+  "version": "1.20.0",
   "description": "NAIDE - Simpler than Python, compiles to 15 targets. AI-specialized language with 35+ built-in functions, syntax sugar (unless/until/repeat/swap/is/isnt), and 47 features. Targets: Node.js, Python, TypeScript, C, C++, Java, Go, Rust, PHP, Ruby, Kotlin, Swift, Dart, C#, Bun.",
   "main": "src/index.js",
   "exports": {
@@ -8,13 +8,15 @@
     "./runtime": "./src/runtime.js"
   },
   "bin": {
-    "naide": "bin/naide.js"
+    "naide": "bin/naide.js",
+    "naide-mcp": "mcp/server.js"
   },
   "type": "module",
   "files": [
     "bin/",
     "src/",
     "assets/",
+    "mcp/",
     "lsp/",
     "examples/",
     "vscode-naide/",