naider 1.19.0 → 1.21.0

package/README.md

@@ -77,6 +77,9 @@ naide pkg install <name>      # Install a NAIDE package
 naide pkg publish             # Publish package to npm
 naide -w <file>               # Watch mode (auto-restart on changes)
 naide -d <file>               # Debug mode (Node.js inspector)
+naide ~~ "instruction"        # Generate NAIDE code from natural language
+naide gen "instruction"       # Same as ~~ (alias)
+naide --expand <file>         # Show ~~ directive expansion results
 naide --emit <file>           # Print generated JavaScript
 naide -o <out.js> <file>      # Write JavaScript to file
 naide --mid <file.nx>         # Show intermediate NAIDE v1 (debug X mode)
@@ -84,11 +87,80 @@ naide --ast <file>            # Print AST
 naide --tokens <file>         # Print token stream
 ```
 
+### Code Generation (`~~`)
+
+Generate valid NAIDE code from natural language instructions — no AI, no network, no dependencies. Pure pattern matching + template composition with self-healing parser validation. Multi-entity support with automatic relationship detection, paginated CRUD, soft delete, batch operations, nested routes, seed data, tests, and full project scaffolding.
+
+```bash
+# Single entity
+naide ~~ "REST API for users with auth"
+naide ~~ "todo app with database"
+
+# Multi-entity (auto-detects relationships, injects foreign keys)
+naide ~~ "users and products and orders with auth"
+
+# Composite presets
+naide ~~ "shop"        # User + Product + Order
+naide ~~ "crm"         # User + Contact + Deal + Activity
+naide ~~ "sns"         # User + Post + Comment + Message + Notification
+naide ~~ "booking"     # User + Event + Reservation
+
+# Project mode (generates full directory)
+naide ~~ "e-commerce app with auth" --project
+
+# File write mode (merge into existing file)
+naide ~~ "REST API for users" --write app.naide
+
+# Japanese
+naide ~~ "ECサイト"
+naide ~~ "ユーザー管理APIを認証付きで"
+```
+
+Generated routes per entity: paginated list, CRUD, soft delete, restore, batch create/delete, nested routes (from relationships), file upload, webhooks. With auth: register, login, profile, admin stats, audit log.
+
+Project mode (`--project`) generates: `app.naide`, `package.json`, `.env`, `Dockerfile`, `README.md`, `openapi.json`, `admin.html`, `client.mjs`.
+
+API usage:
+
+```javascript
+import { generate, generateProject } from 'naider';
+
+const result = generate("users and products with auth");
+console.log(result.entities);      // ['User', 'Product']
+console.log(result.relationships); // [{parent:'User', child:'Product', fk:'user_id'}]
+console.log(result.valid);         // true
+console.log(result.analysis);      // {entities, relationships, plan, ...}
+
+const project = generateProject("e-commerce with auth");
+project.files.forEach(f => console.log(f.path));
+```
+
+**Self-healing**: Generated code is validated against the actual NAIDE parser. Parse errors are auto-fixed (up to 5 retries) — missing colons, indent issues, reserved keyword conflicts.
+
+**Field normalization**: Smart aliases — `e-mail` → `email`, `pwd` → `password`, `tel` → `phone`, `desc` → `description`. Field types are auto-inferred from names (`email` → `str + email`, `age` → `int`, `done` → `bool`).
+
+<details>
+<summary>Keyword Cheat Sheet</summary>
+
+| Category | Keywords |
+|----------|----------|
+| Intent | `server` `api` `rest` `bot` `cli` `page` `test` `database` `ai` `crud` `auth` `websocket` `mail` `graphql` |
+| Composite | `todo` `blog` `chat` `shop` `fullstack` `board` `crm` `inventory` `booking` `sns` |
+| Platform | `discord` `slack` `telegram` `line` |
+| DB Type | `sqlite` `postgres` |
+| JP Intent | `サーバー` `認証` `ログイン` `会員` `CRUD` `管理` `データベース` `ボット` `テスト` `ページ` `メール` |
+| JP Entity | `ユーザー` `商品` `記事` `タスク` `注文` `コメント` `イベント` `問い合わせ` `通知` `カテゴリ` `掲示板` `決済` `予約` `社員` |
+| JP Composite | `管理システム` `やることリスト` `ブログ` `チャットアプリ` `ECサイト` `掲示板` |
+| NL Phrases | `"users can comment"` `"admin manage"` `"upload"` `"search"` `"notification"` `"deploy"` `"seed"` |
+| Fields | `"with name email age"` — auto-inferred types & validators |
+
+</details>
+
 ### REPL
 
 ```
 $ naide
-NAIDE REPL v1.11.0 — type NAIDE code, see JavaScript output
+NAIDE REPL v1.21.0 — type NAIDE code, see JavaScript output
 Type .exit to quit, .eval to toggle eval mode
 
 >>> str name = "hello"

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.21.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,10 @@ const flags = {
   debug: false,
   check: false,
   target: 'node',
+  expand: false,
+  project: false,
+  write: null,
+  replace: false,
 };
 
 const files = [];
@@ -95,10 +135,198 @@ 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;
+    case '--project': case '-p': flags.project = true; break;
+    case '--write': flags.write = args[++i]; break;
+    case '--replace': flags.replace = true; break;
     default: files.push(arg);
   }
 }
 
+// ── Code Generator (~~) ──
+if (files[0] === 'gen' || files[0] === '~~') {
+  const instruction = files.slice(1).join(' ');
+  if (!instruction) {
+    console.log(`
+  NAIDE Agent Coder (~~)
+
+  Usage:
+    naide ~~ "REST API for users with auth"
+    naide gen "todo app with database"
+    naide gen "users and products and orders with auth"
+    naide ~~ "ECサイト" --project
+
+  Autonomous code generator with analysis, multi-entity support,
+  relationship detection, and full auth routes. No AI, no network.
+
+  Examples:
+    naide ~~ "REST API for products with name price stock"
+    naide ~~ "users and products with auth"            # multi-entity
+    naide ~~ "SNS app"                                 # User+Post+Comment
+    naide ~~ "ECサイト"                                 # User+Product+Order
+    naide ~~ "予約システム"                              # User+Reservation
+    naide ~~ "Discord bot with hello and help commands"
+    naide ~~ "ユーザーと商品と注文の管理APIを認証付きで"   # JP multi-entity
+
+  Project Mode (--project):
+    naide ~~ "e-commerce app with auth" --project
+    # Creates: app.naide, package.json, .env, .gitignore,
+    #          Dockerfile, .dockerignore, README.md
+
+  File Write Mode:
+    naide ~~ "add auth" app.naide              # merge into existing file
+    naide ~~ "add websocket" --write app.naide # explicit --write
+    naide ~~ "REST API" --write app.naide --replace  # overwrite file
+
+  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, generateProject, writeToFile } from 'naider';
+    const result = generate("users and products with auth");
+    console.log(result.analysis);  // agent analysis
+    console.log(result.entities);  // ['User', 'Product']
+    writeToFile("app.naide", "add auth");  // merge into file
+
+  ── 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,
+             crm, inventory, booking, sns
+  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
+  Relations  Auto-detected: User→Post, User→Order, Product→Order, etc.
+
+  ────────────────────────────────────────────────────────────
+`);
+    process.exit(0);
+  }
+
+  const { generate, generateProject, writeToFile } = await import('../src/gen.js');
+
+  // Write mode: inject into existing .naide/.nx file
+  const targetFile = instruction.match(/\S+\.(?:naide|nx)$/)?.[0];
+  if (targetFile || flags.write) {
+    const file = flags.write || targetFile;
+    const cleanInstruction = targetFile ? instruction.replace(/\s+\S+\.(?:naide|nx)$/, '') : instruction;
+    const mode = flags.replace ? 'replace' : 'append';
+    const result = writeToFile(resolve(file), cleanInstruction, { mode });
+    const a = result.analysis;
+    process.stderr.write('\n  ── NAIDE Agent ──────────────────────────────────────────\n');
+    process.stderr.write(`  Input:    "${a.instruction}"\n`);
+    process.stderr.write(`  Action:   ${result.action} → ${file}\n`);
+    if (a.entities.length > 0) {
+      process.stderr.write(`  Entities: ${a.entities.map(e => `${e.name} (${e.fieldCount} fields)`).join(', ')}\n`);
+    }
+    process.stderr.write('  ────────────────────────────────────────────────────────\n\n');
+    console.log(result.code);
+    process.stderr.write(`  ── ${result.action}: ${file} (valid: ${result.valid}) ──\n`);
+    process.exit(0);
+  }
+
+  // Project mode: generate full project directory
+  if (flags.project) {
+    const result = generateProject(instruction);
+    const primaryName = (result.entities[0] || 'app').toLowerCase().replace(/[^a-z0-9]/g, '');
+    const dir = flags.output || (primaryName + '-app');
+    const outDir = resolve(dir);
+    if (!existsSync(outDir)) mkdirSync(outDir, { recursive: true });
+    for (const f of result.files) {
+      const fp = resolve(outDir, f.path);
+      writeFileSync(fp, f.content, 'utf-8');
+    }
+    const a = result.analysis;
+    process.stderr.write('\n  ── NAIDE Agent ──────────────────────────────────────────\n');
+    process.stderr.write(`  Input:    "${a.instruction}"\n`);
+    if (a.entities.length > 0) {
+      process.stderr.write(`  Entities: ${a.entities.map(e => `${e.name} (${e.fieldCount} fields)`).join(', ')}\n`);
+    }
+    if (a.relationships.length > 0) {
+      for (const r of a.relationships) process.stderr.write(`  Relation: ${r.parent} 1→N ${r.child} (${r.fk})\n`);
+    }
+    process.stderr.write(`  Plan:\n`);
+    for (const step of a.plan) process.stderr.write(`    + ${step}\n`);
+    process.stderr.write('  ────────────────────────────────────────────────────────\n\n');
+    console.log(`  Project created: ${dir}/`);
+    for (const f of result.files) console.log(`    ${f.path}`);
+    console.log(`\n  cd ${dir} && npm install && npm run dev\n`);
+    process.exit(0);
+  }
+
+  const result = generate(instruction);
+
+  if (flags.output) {
+    writeFileSync(flags.output, result.code, 'utf-8');
+    console.log(`  Generated: ${flags.output} (${result.intents.join(' + ')})`);
+  } else {
+    // Agent-style analysis header
+    const a = result.analysis;
+    process.stderr.write('\n  ── NAIDE Agent ──────────────────────────────────────────\n');
+    process.stderr.write(`  Input:    "${a.instruction}"\n`);
+    if (a.entities.length > 0) {
+      process.stderr.write(`  Entities: ${a.entities.map(e => `${e.name} (${e.fieldCount} fields)`).join(', ')}\n`);
+    }
+    if (a.relationships.length > 0) {
+      for (const r of a.relationships) {
+        process.stderr.write(`  Relation: ${r.parent} 1→N ${r.child} (${r.fk})\n`);
+      }
+    }
+    process.stderr.write(`  Plan:\n`);
+    for (const step of a.plan) {
+      process.stderr.write(`    + ${step}\n`);
+    }
+    process.stderr.write('  ────────────────────────────────────────────────────────\n\n');
+
+    console.log(result.code);
+
+    const meta = [`[${result.intents.join(' + ')}]`];
+    if (result.entities && result.entities.length > 1) {
+      meta.push(`→ ${result.entities.join(', ')}`);
+    } else if (result.schema) {
+      meta.push(`→ ${result.schema}`);
+    }
+    meta.push(`valid: ${result.valid}`);
+    if (result.fixed) meta.push('(auto-fixed)');
+    process.stderr.write(`  ── 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 +585,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 +935,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 +956,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 +992,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 +1172,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

@@ -63,6 +63,19 @@ const TOOLS = [
     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.',
@@ -133,6 +146,20 @@ async function handleToolCall(name, args) {
       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');
@@ -165,7 +192,7 @@ async function handleMessage(msg) {
       respond(msg.id, {
         protocolVersion: '2024-11-05',
         capabilities: { tools: {} },
-        serverInfo: { name: 'naide-mcp', version: '1.18.0' }
+        serverInfo: { name: 'naide-mcp', version: '1.21.0' }
       });
       break;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "naider",
-  "version": "1.19.0",
+  "version": "1.21.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": {