naidejs 1.2.0 → 1.4.0

package/SPEC-X.nx

@@ -6,7 +6,7 @@
 -- Rule: first char of line = intent
 --   > return    ? if       | elif     : else
 --   @ loop      * while    ! try      !! catch
---   $ server    ^ model    < import   % match
+--   $ server    ^ model    < import   % match   X patch
 --   f func      ~f async   + export
 --   s:i:n:b:l:m:a: typed vars
 --   ~ await     ~~ await.all
@@ -138,6 +138,12 @@ $app:PORT
   static "/public"
   crud "/api/users" User
   cookie
+  session JWT_SECRET
+  cache "/api/*" "5m"
+  view "./views"
+  sse "/events"
+  upload "/api/upload" "avatar" (req,res):
+    >{file:req.file.filename}
   group "/api/v1":
     G"/status"
       >{version:"1.0"}
@@ -185,6 +191,22 @@ $app:PORT
 -- sign({id:1})          → JWT (uses auth secret)
 -- sign({id:1},"secret") → JWT (explicit)
 
+-- Validate: auto-validate POST/PUT/PATCH bodies
+--   validate "/api/users" User
+
+-- Test (node:test)
+test "math":
+  assert 1+1==2
+  assert 2*3==6
+
+-- Queue (async job queue)
+queue jobs:
+  job "notify" (data):
+    log data.msg
+
+-- OpenAPI: auto-generate spec from schemas
+--   openapi "/docs"
+
 -- Scheduled tasks
 every "5m":
   log"cleanup"

package/SPEC.naide

@@ -183,6 +183,26 @@ server app port PORT:
   # クッキーパーサー
   cookie
 
+  # セッション管理 (cookie-based, ゼロ依存)
+  session JWT_SECRET
+
+  # レスポンスキャッシュ
+  cache "/api/*" "5m"
+
+  # テンプレートエンジン
+  view "./views"
+
+  # Server-Sent Events
+  sse "/events"
+
+  # ファイルアップロード (ゼロ依存)
+  upload "/api/upload" "avatar" (req, res):
+    ret {file: req.file.filename, size: req.file.size}
+
+  # 名前付きミドルウェア適用
+  # mid myMiddleware
+  # mid myMiddleware "/api"
+
   # ルートグループ
   group "/api/v1":
     get "/status":
@@ -230,6 +250,41 @@ server app port PORT:
 # any raw = await api.raw(url, opts)
 
 
+# ---- HTTPメソッド ----
+# get, post, put, del, patch がサーバー内で使える
+# patch "/api/users/:id" (req, res):
+#   ret {updated: true}
+
+
+# ---- リクエストバリデーション ----
+# validate パス スキーマ名 → POST/PUT/PATCHのボディをスキーマで自動検証
+# server app port 3000:
+#   validate "/api/users" User
+
+
+# ---- テスト (node:test ベース) ----
+test "math operations":
+  assert 1 + 1 == 2
+  assert 10 - 3 == 7
+
+test "string operations":
+  str name = "NAIDE"
+  assert name == "NAIDE"
+
+
+# ---- ジョブキュー (インメモリ非同期) ----
+queue jobs:
+  job "sendEmail" (data):
+    log "sending to {data.to}"
+  job "resize" (data):
+    log "resizing {data.path}"
+
+
+# ---- OpenAPI 自動生成 ----
+# server app port 3000:
+#   openapi "/docs"    # スキーマからOpenAPI仕様を自動生成して配信
+
+
 # ---- レスポンスヘルパー ----
 # ret {data}                → JSON応答
 # ret.status 404 {error}    → ステータスコード付き
@@ -237,6 +292,7 @@ server app port PORT:
 # ret.html "<h1>Hi</h1>"   → HTML応答
 # ret.text "pong"           → テキスト応答
 # ret.file "/path/to/file" → ファイル送信
+# ret.render "template" {data} → テンプレート描画
 
 
 # ---- 組み込み関数 (自動インポート) ----

package/bin/naide.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
-import { readFileSync, writeFileSync, unlinkSync, watch as fsWatch } from 'fs';
-import { resolve, basename, extname } from 'path';
+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';
 
@@ -36,6 +36,101 @@ for (let i = 0; i < args.length; i++) {
   }
 }
 
+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: { naidejs: '^1.3.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);
+}
+
 if (flags.help || files.length === 0) {
   console.log(`
   NAIDE - Node AI Development Environment
@@ -44,6 +139,8 @@ if (flags.help || files.length === 0) {
   Usage:
     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 --emit <file.nx>       Output generated JavaScript
     naide --mid <file.nx>        Output intermediate NAIDE v1 (debug)
     naide -x <file.naide>        Force NAIDE-X mode

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "naidejs",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "NAIDE - Node AI Development Environment. AI-specialized language with built-in server, auth, DB, WebSocket, and more — transpiles to Node.js. Standard mode (~40% fewer tokens) and X mode (~80% fewer tokens).",
   "main": "src/index.js",
   "exports": {

package/src/generator.js

@@ -12,6 +12,8 @@ export class Generator {
     this.authSecret = null;
     this.hasWs = false;
     this.wsNodes = [];
+    this.hasTests = false;
+    this.hasAsserts = false;
   }
 
   generate(ast) {
@@ -29,6 +31,14 @@ export class Generator {
       preamble.push('');
     }
 
+    if (this.hasTests) {
+      preamble.push("import { test } from 'node:test';");
+    }
+    if (this.hasTests || this.hasAsserts) {
+      preamble.push("import assert from 'node:assert/strict';");
+      if (this.hasTests) preamble.push('');
+    }
+
     if (this.needsEventBus) {
       preamble.push('const __eventBus = createEventBus();');
       preamble.push('');
@@ -96,6 +106,18 @@ export class Generator {
       case 'GroupDecl': return this.visitGroupTopLevel(node);
       case 'ErrorHandler': return this.visitErrorHandlerTopLevel(node);
       case 'CookieDecl': return this.visitCookieTopLevel(node);
+      case 'UploadDecl': return this.visitUploadTopLevel(node);
+      case 'SessionDecl': return this.visitSessionTopLevel(node);
+      case 'ViewDecl': return this.visitViewTopLevel(node);
+      case 'SseDecl': return this.visitSseTopLevel(node);
+      case 'CacheDecl': return this.visitCacheTopLevel(node);
+      case 'MiddlewareRef': return this.visitMiddlewareRefTopLevel(node);
+      case 'ReturnRender': return this.visitReturnRender(node);
+      case 'ValidateDecl': return this.visitValidateTopLevel(node);
+      case 'TestDecl': return this.visitTest(node);
+      case 'AssertStmt': return this.visitAssert(node);
+      case 'QueueDecl': return this.visitQueue(node);
+      case 'OpenapiDecl': return this.visitOpenapiTopLevel(node);
       default:
         this.emit(`/* unknown: ${node.type} */`);
     }
@@ -324,6 +346,24 @@ export class Generator {
         errorHandlers.push(child);
       } else if (child.type === 'CookieDecl') {
         this.visitCookie(node.name, child);
+      } else if (child.type === 'UploadDecl') {
+        this.visitUpload(node.name, child);
+      } else if (child.type === 'SessionDecl') {
+        this.visitSession(node.name, child);
+      } else if (child.type === 'ViewDecl') {
+        this.visitView(node.name, child);
+      } else if (child.type === 'SseDecl') {
+        this.visitSse(node.name, child);
+      } else if (child.type === 'CacheDecl') {
+        this.visitCache(node.name, child);
+      } else if (child.type === 'MiddlewareRef') {
+        this.visitMiddlewareRef(node.name, child);
+      } else if (child.type === 'ValidateDecl') {
+        this.visitValidate(node.name, child);
+      } else if (child.type === 'OpenapiDecl') {
+        this.visitOpenapi(node.name, child);
+      } else if (child.type === 'QueueDecl') {
+        this.visitQueue(child);
       } else {
         this.visitStatement(child);
       }
@@ -759,6 +799,165 @@ export class Generator {
     this.visitCookie('app', node);
   }
 
+  visitUpload(appName, node) {
+    this.runtimeImports.add('uploadMiddleware');
+    const path = this.stringValue(node.path);
+    const field = this.stringValue(node.fieldName);
+    const params = node.params.length > 0 ? node.params.join(', ') : 'req, res';
+    const needsAsync = this.bodyUsesAwait(node.body);
+    const asyncPrefix = needsAsync ? 'async ' : '';
+    this.emit(`${appName}.post(${path}, uploadMiddleware(${field}), ${asyncPrefix}(${params}) => {`);
+    this.indent++;
+    for (const stmt of node.body) {
+      if (stmt.type === 'Return' && stmt.value !== null) {
+        this.emit(`res.json(${this.expr(stmt.value)});`);
+      } else {
+        this.visitStatement(stmt);
+      }
+    }
+    this.indent--;
+    this.emit('});');
+    this.emitRaw('');
+  }
+
+  visitUploadTopLevel(node) {
+    this.visitUpload('app', node);
+  }
+
+  visitSession(appName, node) {
+    this.runtimeImports.add('sessionMiddleware');
+    const secret = this.expr(node.secret);
+    this.emit(`${appName}.use(sessionMiddleware(${secret}));`);
+    this.emitRaw('');
+  }
+
+  visitSessionTopLevel(node) {
+    this.visitSession('app', node);
+  }
+
+  visitView(appName, node) {
+    this.runtimeImports.add('createRenderer');
+    const dir = this.stringValue(node.dir);
+    this.emit(`const __render = createRenderer(${dir});`);
+    this.emitRaw('');
+  }
+
+  visitViewTopLevel(node) {
+    this.visitView('app', node);
+  }
+
+  visitSse(appName, node) {
+    this.runtimeImports.add('createSseManager');
+    const path = this.stringValue(node.path);
+    this.emit(`const sse = createSseManager();`);
+    this.emit(`${appName}.get(${path}, sse.handler());`);
+    this.emitRaw('');
+  }
+
+  visitSseTopLevel(node) {
+    this.visitSse('app', node);
+  }
+
+  visitCache(appName, node) {
+    this.runtimeImports.add('cacheMiddleware');
+    const path = this.stringValue(node.path);
+    const duration = this.expr(node.duration);
+    this.emit(`${appName}.use(${path}, cacheMiddleware(${duration}));`);
+    this.emitRaw('');
+  }
+
+  visitCacheTopLevel(node) {
+    this.visitCache('app', node);
+  }
+
+  visitMiddlewareRef(appName, node) {
+    if (node.path) {
+      this.emit(`${appName}.use(${this.stringValue(node.path)}, ${node.name});`);
+    } else {
+      this.emit(`${appName}.use(${node.name});`);
+    }
+    this.emitRaw('');
+  }
+
+  visitMiddlewareRefTopLevel(node) {
+    this.visitMiddlewareRef('app', node);
+  }
+
+  visitReturnRender(node) {
+    const template = this.expr(node.template);
+    const data = node.data ? this.expr(node.data) : '{}';
+    this.emit(`return res.type('html').send(__render(${template}, ${data}));`);
+  }
+
+  visitValidate(appName, node) {
+    this.runtimeImports.add('validateMiddleware');
+    const path = this.stringValue(node.path);
+    this.emit(`${appName}.use(${path}, validateMiddleware(${node.schemaName}Schema));`);
+    this.emitRaw('');
+  }
+
+  visitValidateTopLevel(node) {
+    this.visitValidate('app', node);
+  }
+
+  visitTest(node) {
+    this.hasTests = true;
+    const name = this.expr(node.name);
+    const needsAsync = this.bodyUsesAwait(node.body);
+    const asyncPrefix = needsAsync ? 'async ' : '';
+    this.emit(`test(${name}, ${asyncPrefix}() => {`);
+    this.indent++;
+    for (const stmt of node.body) this.visitStatement(stmt);
+    this.indent--;
+    this.emit('});');
+    this.emitRaw('');
+  }
+
+  visitAssert(node) {
+    this.hasAsserts = true;
+    const exprNode = node.expr;
+    if (exprNode.type === 'Binary' && exprNode.op === '===') {
+      this.emit(`assert.strictEqual(${this.expr(exprNode.left)}, ${this.expr(exprNode.right)});`);
+    } else if (exprNode.type === 'Binary' && exprNode.op === '!==') {
+      this.emit(`assert.notStrictEqual(${this.expr(exprNode.left)}, ${this.expr(exprNode.right)});`);
+    } else {
+      this.emit(`assert.ok(${this.expr(exprNode)});`);
+    }
+  }
+
+  visitQueue(node) {
+    this.runtimeImports.add('createQueue');
+    this.emit(`const ${node.name} = createQueue();`);
+    for (const job of node.jobs) {
+      const params = job.params.length > 0 ? job.params.join(', ') : 'data';
+      const needsAsync = this.bodyUsesAwait(job.body);
+      const asyncPrefix = needsAsync ? 'async ' : '';
+      this.emit(`${node.name}.register(${this.generateString(job.name)}, ${asyncPrefix}(${params}) => {`);
+      this.indent++;
+      for (const stmt of job.body) this.visitStatement(stmt);
+      this.indent--;
+      this.emit('});');
+    }
+    this.emitRaw('');
+  }
+
+  visitOpenapi(appName, node) {
+    this.runtimeImports.add('buildOpenApiSpec');
+    const path = this.stringValue(node.path);
+    const schemaNames = [...this.schemas.keys()];
+    const schemaArgs = schemaNames.map(n => `${n}Schema`).join(', ');
+    this.emit(`${appName}.get(${path}, (req, res) => {`);
+    this.indent++;
+    this.emit(`res.json(buildOpenApiSpec([${schemaArgs}]));`);
+    this.indent--;
+    this.emit('});');
+    this.emitRaw('');
+  }
+
+  visitOpenapiTopLevel(node) {
+    this.visitOpenapi('app', node);
+  }
+
   visitEnv(node) {
     this.runtimeImports.add('loadEnv');
 

package/src/index.js

@@ -4,16 +4,34 @@ import { Generator } from './generator.js';
 import { preprocess } from './preprocess.js';
 
 export function compile(source, { mode = 'naide', runtimePath } = {}) {
+  let processedSource = source;
   if (mode === 'x') {
-    source = preprocess(source);
+    processedSource = preprocess(source);
+  }
+  try {
+    const lexer = new Lexer(processedSource);
+    const tokens = lexer.tokenize();
+    const parser = new Parser(tokens);
+    const ast = parser.parse();
+    const generator = new Generator({ runtimePath });
+    const js = generator.generate(ast);
+    return { js, ast, tokens, naide: mode === 'x' ? processedSource : null };
+  } catch (e) {
+    const lineMatch = e.message.match(/line (\d+)/);
+    if (lineMatch) {
+      const lineNum = parseInt(lineMatch[1]);
+      const lines = processedSource.split('\n');
+      const start = Math.max(0, lineNum - 3);
+      const end = Math.min(lines.length, lineNum + 2);
+      const context = lines.slice(start, end).map((l, i) => {
+        const num = start + i + 1;
+        const marker = num === lineNum ? ' >> ' : '    ';
+        return `${marker}${num} | ${l}`;
+      }).join('\n');
+      e.message += `\n\n${context}\n`;
+    }
+    throw e;
   }
-  const lexer = new Lexer(source);
-  const tokens = lexer.tokenize();
-  const parser = new Parser(tokens);
-  const ast = parser.parse();
-  const generator = new Generator({ runtimePath });
-  const js = generator.generate(ast);
-  return { js, ast, tokens, naide: mode === 'x' ? source : null };
 }
 
 export function transpile(source, opts) {

package/src/lexer.js

@@ -11,7 +11,7 @@ class Token {
 
 export class Lexer {
   constructor(source) {
-    this.source = source;
+    this.source = source.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
     this.pos = 0;
     this.line = 1;
     this.col = 1;
@@ -78,6 +78,11 @@ export class Lexer {
         continue;
       }
 
+      if (ch === ';') {
+        this.advance();
+        continue;
+      }
+
       if (ch === '"' || ch === "'") {
         this.readString(ch);
         continue;
@@ -195,7 +200,11 @@ export class Lexer {
       }
     }
 
-    if (this.peek() === quote) this.advance(); // skip closing quote
+    if (this.peek() === quote) {
+      this.advance();
+    } else {
+      throw new Error(`[NAIDE Lexer Error] Unterminated string starting at line ${startLine}:${startCol}`);
+    }
 
     if (current) parts.push({ type: 'text', value: current });
 
@@ -221,7 +230,11 @@ export class Lexer {
         value += this.advance();
       }
     }
-    if (this.peek() === '`') this.advance();
+    if (this.peek() === '`') {
+      this.advance();
+    } else {
+      throw new Error(`[NAIDE Lexer Error] Unterminated template string starting at line ${startLine}:${startCol}`);
+    }
     this.tokens.push(new Token(T.STRING, { parts: [{ type: 'text', value }], raw: value }, startLine, startCol));
   }
 
@@ -371,7 +384,7 @@ export class Lexer {
       case ':': this.tokens.push(new Token(T.COLON, ':', startLine, startCol)); break;
       case ',': this.tokens.push(new Token(T.COMMA, ',', startLine, startCol)); break;
       default:
-        throw new Error(`Unexpected character '${ch}' at line ${startLine}:${startCol}`);
+        throw new Error(`[NAIDE Lexer Error] Unexpected character '${ch}' at line ${startLine}:${startCol}`);
     }
   }