naider 1.7.0 → 1.8.0

package/README.md

@@ -46,11 +46,17 @@ naide                         # Start interactive REPL
 naide repl                    # Start interactive REPL
 naide init [dir]              # Scaffold a new project
 naide build [dir] [outdir]    # Transpile all files to JavaScript
+naide check <files...>        # Type-check without running
 naide fmt <files...>          # Format NAIDE files
 naide lsp                     # Start Language Server (LSP)
 naide vscode                  # Install VS Code extension
 naide deploy [dir]            # Generate Dockerfile for deployment
+naide convert <files...>      # Convert .nx ↔ .naide (bidirectional)
+naide pkg init                # Create naide.pkg.json manifest
+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 --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)
@@ -62,7 +68,7 @@ naide --tokens <file>         # Print token stream
 
 ```
 $ naide
-NAIDE REPL v1.6.0 — type NAIDE code, see JavaScript output
+NAIDE REPL v1.8.0 — type NAIDE code, see JavaScript output
 Type .exit to quit, .eval to toggle eval mode
 
 >>> str name = "hello"
@@ -72,7 +78,7 @@ const name = "hello";
 ...   ret a + b
 ...
 function add(a, b) {
-  return (a + b);
+  return a + b;
 }
 ```
 
@@ -497,6 +503,31 @@ test "math":
 
 `assert a == b` generates `assert.strictEqual` for better error messages. Run with `node --test`.
 
+### Mock / Spy (Test Utilities)
+
+```python
+fn.async main():
+  # Create a mock function
+  any mock = createMock()
+  mock(1, 2)
+  mock("hello")
+  log mock.callCount()        # 2
+  log mock.calledWith(1, 2)   # true
+
+  # Mock with return value
+  mock.returns(42)
+  log mock()                  # 42
+
+  # Spy on an existing method
+  any spy = createSpy(obj, "method")
+  obj.method("arg")
+  log spy.callCount()         # 1
+  spy.restore()               # restores original method
+```
+
+`createMock(fn?)` — create a mock function with `.calls`, `.callCount()`, `.calledWith(...)`, `.returns(val)`, `.impl(fn)`, `.reset()`.
+`createSpy(obj, method)` — wraps an existing method with a mock. `.restore()` reverts it.
+
 ## Job Queue
 
 In-memory async job queue for background processing:
@@ -662,6 +693,8 @@ server app port 3000:
 
 Schemas with `db.sql` auto-use SQL storage instead of JSON files. Same API: `getAll`, `getById`, `create`, `update`, `delete`, `where`, `count`, `clear`.
 
+Schema migration is automatic — when you add new fields to a schema, `ALTER TABLE ADD COLUMN` runs at startup. No manual migration needed.
+
 PostgreSQL:
 
 ```python
@@ -869,6 +902,110 @@ High-level keywords work in both modes: `schema`, `crud`, `auth`, `cors`, `limit
 
 NAIDE-X log shorthands: `log.e` = error, `log.w` = warn, `log.i` = info, `log.d` = debug.
 
+## Plugin System
+
+Register and use plugins for extensibility:
+
+```python
+registerPlugin("logger", (opts) =>
+  ret {log: (msg) => log "[{opts.prefix}] {msg}"}
+)
+
+any logger = usePlugin("logger", {prefix: "APP"})
+logger.log("started")
+
+list names = listPlugins()
+```
+
+`registerPlugin(name, setup)` — registers a plugin factory. `usePlugin(name, opts?)` — initializes on first call, returns cached exports. `listPlugins()` — returns registered plugin names.
+
+## Convert (NX ↔ NAIDE)
+
+Bidirectional conversion between `.nx` and `.naide`:
+
+```bash
+naide convert file.nx         # → file.naide (expand to readable syntax)
+naide convert file.naide      # → file.nx (compress to NX syntax)
+```
+
+## Source Maps & Error Remapping
+
+Runtime errors are automatically remapped to source file line numbers:
+
+```
+Error in app.naide:12
+  10 |   user = UserStore.getById(id)
+  11 |   if not user:
+>>12 |     throw "not found"
+```
+
+The CLI tracks source-to-output line mappings and shows context from your `.naide`/`.nx` file, not the generated JavaScript.
+
+## Native Dependency Detection
+
+When you run a `.naide` file, the CLI scans generated JavaScript for missing dependencies (`express`, `better-sqlite3`, `pg`, `ws`) and prints install hints:
+
+```
+[NAIDE] Missing: express — run: npm install express
+```
+
+## Type Checker
+
+Compile-time type checking without running the code:
+
+```bash
+naide check app.naide
+```
+
+Catches type mismatches at compile time:
+
+```
+  app.naide:3 ERROR: Type mismatch: cannot assign str to int
+  app.naide:7 WARN: Type warning: reassigning int variable 'count' with str
+```
+
+The type checker understands NAIDE's type annotations (`str`, `int`, `num`, `bool`, `list`, `map`), infers types from expressions and function return values, and checks assignments for compatibility. `num` accepts `int` values. `any` and `json` accept all types.
+
+Also available as a flag: `naide --check app.naide` or programmatically via `compile(source, { typeCheck: true })`.
+
+## Async Error Handling
+
+Async route handlers are automatically wrapped with try/catch to prevent unhandled rejections:
+
+```python
+server app port 3000:
+  post "/api/data" (req, res):
+    any data = await fetchData()    # if this throws...
+    ret data                        # ...a 500 JSON error is returned automatically
+```
+
+Generated code includes `try { ... } catch (__err) { res.status(500).json({ error: __err.message }) }` around async handlers. Routes with explicit `try/fail` blocks are left as-is.
+
+A global `process.on('unhandledRejection')` handler is also added to server code to catch any remaining async errors.
+
+## Debugger
+
+Debug NAIDE programs with the Node.js inspector:
+
+```bash
+naide -d app.naide              # starts with --inspect-brk
+```
+
+Then open `chrome://inspect` in Chrome to connect. The program pauses at the first line so you can set breakpoints before execution.
+
+## Package Ecosystem
+
+Manage NAIDE packages via npm:
+
+```bash
+naide pkg init                  # create naide.pkg.json manifest
+naide pkg install my-plugin     # install from npm + add to manifest
+naide pkg publish               # publish to npm with naide-plugin keyword
+naide pkg list                  # list installed NAIDE packages
+```
+
+The `naide.pkg.json` manifest tracks NAIDE-specific metadata (main entry, exports, dependencies) while using npm as the underlying registry.
+
 ## Why NAIDE?
 
 AI code generation speed depends on:

package/bin/naide.js

@@ -5,6 +5,63 @@ import { resolve, basename, extname, join, relative } from 'path';
 import { compile } from '../src/index.js';
 import { spawn } from 'child_process';
 
+import { createRequire } from 'module';
+const _require = createRequire(import.meta.url);
+
+function checkDependencies(jsCode) {
+  const depMap = {
+    "from 'express'": { pkg: 'express', reason: 'server' },
+    "from 'better-sqlite3'": { pkg: 'better-sqlite3', reason: 'db.sql "sqlite"' },
+    "from 'pg'": { pkg: 'pg', reason: 'db.sql "postgres"' },
+    "from 'ws'": { pkg: 'ws', reason: 'WebSocket (ws)' },
+  };
+  const missing = [];
+  for (const [pattern, info] of Object.entries(depMap)) {
+    if (jsCode.includes(pattern)) {
+      try { _require.resolve(info.pkg); } catch {
+        missing.push(info);
+      }
+    }
+  }
+  if (missing.length > 0) {
+    console.log('\n  [NAIDE] Missing dependencies detected:\n');
+    for (const m of missing) {
+      console.log(`    npm install ${m.pkg}    # required for: ${m.reason}`);
+    }
+    console.log(`\n  Run: npm install ${missing.map(m => m.pkg).join(' ')}\n`);
+  }
+}
+
+function remapError(err, sourceMap, sourceFile, sourceCode) {
+  if (!err.stack || !sourceMap || sourceMap.length === 0) return;
+  const lines = sourceCode.split('\n');
+  const tempPattern = /\.naide_tmp_[^:]+\.mjs:(\d+)/g;
+  let match;
+  const remapped = [];
+  while ((match = tempPattern.exec(err.stack)) !== null) {
+    const jsLine = parseInt(match[1]) - 1;
+    const srcLine = sourceMap[jsLine];
+    if (srcLine && srcLine > 0) {
+      remapped.push(srcLine);
+    }
+  }
+  if (remapped.length > 0) {
+    const srcLine = remapped[0];
+    const context = [];
+    const start = Math.max(0, srcLine - 3);
+    const end = Math.min(lines.length, srcLine + 2);
+    for (let i = start; i < end; i++) {
+      const marker = i + 1 === srcLine ? ' >> ' : '    ';
+      context.push(`${marker}${i + 1} | ${lines[i]}`);
+    }
+    console.error(`\n  [NAIDE Error] ${sourceFile}:${srcLine}\n`);
+    console.error(context.join('\n'));
+    console.error(`\n  ${err.message}\n`);
+    return true;
+  }
+  return false;
+}
+
 const args = process.argv.slice(2);
 
 const flags = {
@@ -17,6 +74,8 @@ const flags = {
   mode: null,
   mid: false,
   watch: false,
+  debug: false,
+  check: false,
 };
 
 const files = [];
@@ -32,6 +91,8 @@ for (let i = 0; i < args.length; i++) {
     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;
+    case '--debug': case '-d': flags.debug = true; break;
+    case '--check': flags.check = true; flags.run = false; break;
     default: files.push(arg);
   }
 }
@@ -90,7 +151,7 @@ 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(`\n  NAIDE REPL v1.8.0 — type NAIDE code, see JavaScript output`);
   console.log(`  Type .exit to quit, .eval to toggle eval mode\n`);
 
   const rl = createInterface({
@@ -229,7 +290,7 @@ if (files[0] === 'init') {
     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' }
+      dependencies: { naider: '^1.8.0' }
     }, null, 2) + '\n');
   }
 
@@ -315,6 +376,232 @@ if (files[0] === 'build') {
   process.exit(errors > 0 ? 1 : 0);
 }
 
+// ── Convert (NX ↔ NAIDE) ──
+if (files[0] === 'convert') {
+  const targets = files.slice(1);
+  if (targets.length === 0) {
+    console.log('  Usage: naide convert <file.nx|file.naide>');
+    console.log('    .nx → .naide    Expand NX shorthand to readable NAIDE');
+    console.log('    .naide → .nx    Compress NAIDE to AI-optimized NX');
+    process.exit(0);
+  }
+
+  for (const file of targets) {
+    const filePath = resolve(file);
+    const ext = extname(file);
+    try {
+      const source = readFileSync(filePath, 'utf-8');
+
+      if (ext === '.nx') {
+        const { preprocess } = await import('../src/preprocess.js');
+        const naide = preprocess(source);
+        const outPath = filePath.replace(/\.nx$/, '.naide');
+        writeFileSync(outPath, naide);
+        console.log(`  ${file} → ${basename(outPath)}`);
+      } else if (ext === '.naide') {
+        const lines = source.split('\n');
+        const nxLines = [];
+        for (const line of lines) {
+          let nx = line;
+          nx = nx.replace(/^(\s*)#\s?(.*)/, '$1-- $2');
+          nx = nx.replace(/^(\s*)fn\.async\s+/, '$1~f ');
+          nx = nx.replace(/^(\s*)fn\s+/, '$1f ');
+          nx = nx.replace(/^(\s*)use\s+\{(.+?)\}\s+from\s+/, '$1<{$2}');
+          nx = nx.replace(/^(\s*)use\s+/, '$1<');
+          nx = nx.replace(/\bret\b/, '>');
+          nx = nx.replace(/\beach\s+(\w+)\s+in\s+/, '@$1<');
+          nx = nx.replace(/\bawait\s+/, '~');
+          nx = nx.replace(/\bstr\b/g, 's');
+          nx = nx.replace(/\bint\b/g, 'i');
+          nx = nx.replace(/\bnum\b/g, 'n');
+          nx = nx.replace(/\bbool\b/g, 'b');
+          nx = nx.replace(/\blist\b/g, 'l');
+          nx = nx.replace(/\bmap\b/g, 'm');
+          nx = nx.replace(/\bany\b/g, 'a');
+          nx = nx.replace(/\bconsole\.log\b/, 'log');
+          nxLines.push(nx);
+        }
+        const outPath = filePath.replace(/\.naide$/, '.nx');
+        writeFileSync(outPath, nxLines.join('\n'));
+        console.log(`  ${file} → ${basename(outPath)}`);
+      } else {
+        console.error(`  Unsupported: ${file} (use .naide or .nx)`);
+      }
+    } catch (e) {
+      console.error(`  Error: ${file} — ${e.message}`);
+    }
+  }
+  process.exit(0);
+}
+
+// ── Type Check ──
+if (files[0] === 'check') {
+  const targets = files.slice(1);
+  if (targets.length === 0) {
+    console.log('  Usage: naide check <file.naide|file.nx> [files...]');
+    process.exit(0);
+  }
+
+  let totalErrors = 0;
+  let totalWarnings = 0;
+  for (const file of targets) {
+    const filePath = resolve(file);
+    try {
+      const source = readFileSync(filePath, 'utf-8');
+      const ext = extname(file);
+      const mode = ext === '.nx' ? 'x' : 'naide';
+      const result = compile(source, { mode, typeCheck: true });
+      const { typeErrors } = result;
+
+      if (typeErrors) {
+        for (const e of typeErrors.errors) {
+          console.log(`  ${file}:${e.line} ERROR: ${e.message}`);
+          totalErrors++;
+        }
+        for (const w of typeErrors.warnings) {
+          console.log(`  ${file}:${w.line} WARN: ${w.message}`);
+          totalWarnings++;
+        }
+      }
+
+      if (!typeErrors || (typeErrors.errors.length === 0 && typeErrors.warnings.length === 0)) {
+        console.log(`  ${file}: OK`);
+      }
+    } catch (e) {
+      console.error(`  ${file}: ${e.message.split('\n')[0]}`);
+      totalErrors++;
+    }
+  }
+
+  console.log(`\n  ${totalErrors} error(s), ${totalWarnings} warning(s)`);
+  process.exit(totalErrors > 0 ? 1 : 0);
+}
+
+// ── Package Ecosystem ──
+if (files[0] === 'pkg') {
+  const subcmd = files[1];
+
+  if (!subcmd || subcmd === 'help') {
+    console.log(`
+  NAIDE Package Manager
+
+  Usage:
+    naide pkg init                Create naide.pkg.json manifest
+    naide pkg install <name>      Install a NAIDE package from npm
+    naide pkg publish             Publish current package to npm
+    naide pkg list                List installed NAIDE packages
+`);
+    process.exit(0);
+  }
+
+  const pkgManifestPath = resolve('naide.pkg.json');
+
+  if (subcmd === 'init') {
+    if (existsSync(pkgManifestPath)) {
+      console.log('  naide.pkg.json already exists.');
+      process.exit(0);
+    }
+    const npmPkgPath = resolve('package.json');
+    let name = 'my-naide-pkg';
+    if (existsSync(npmPkgPath)) {
+      try { name = JSON.parse(readFileSync(npmPkgPath, 'utf-8')).name || name; } catch {}
+    }
+    const manifest = {
+      name,
+      version: '1.0.0',
+      description: '',
+      main: 'index.naide',
+      keywords: ['naide', 'naide-plugin'],
+      exports: {},
+      dependencies: {},
+    };
+    writeFileSync(pkgManifestPath, JSON.stringify(manifest, null, 2) + '\n');
+    console.log(`\n  Created naide.pkg.json\n`);
+    process.exit(0);
+  }
+
+  if (subcmd === 'install') {
+    const pkgName = files[2];
+    if (!pkgName) {
+      console.log('  Usage: naide pkg install <package-name>');
+      process.exit(1);
+    }
+
+    console.log(`  Installing ${pkgName}...`);
+    const child = spawn('npm', ['install', pkgName], { stdio: 'inherit', shell: true });
+    child.on('close', (code) => {
+      if (code === 0) {
+        if (existsSync(pkgManifestPath)) {
+          try {
+            const manifest = JSON.parse(readFileSync(pkgManifestPath, 'utf-8'));
+            const npmPkg = resolve('node_modules', pkgName, 'package.json');
+            if (existsSync(npmPkg)) {
+              const ver = JSON.parse(readFileSync(npmPkg, 'utf-8')).version;
+              manifest.dependencies[pkgName] = `^${ver}`;
+              writeFileSync(pkgManifestPath, JSON.stringify(manifest, null, 2) + '\n');
+            }
+          } catch {}
+        }
+        console.log(`\n  Installed ${pkgName}`);
+      }
+      process.exit(code);
+    });
+    await new Promise(() => {});
+  }
+
+  if (subcmd === 'publish') {
+    if (!existsSync(pkgManifestPath)) {
+      console.log('  No naide.pkg.json found. Run: naide pkg init');
+      process.exit(1);
+    }
+
+    const manifest = JSON.parse(readFileSync(pkgManifestPath, 'utf-8'));
+    const npmPkgPath = resolve('package.json');
+    if (!existsSync(npmPkgPath)) {
+      writeFileSync(npmPkgPath, JSON.stringify({
+        name: manifest.name,
+        version: manifest.version,
+        description: manifest.description,
+        type: 'module',
+        main: manifest.main,
+        keywords: manifest.keywords,
+        files: ['*.naide', '*.nx', 'src/', 'naide.pkg.json'],
+      }, null, 2) + '\n');
+    }
+
+    console.log(`  Publishing ${manifest.name}@${manifest.version}...`);
+    const child = spawn('npm', ['publish', '--access', 'public'], { stdio: 'inherit', shell: true });
+    child.on('close', (code) => {
+      if (code === 0) console.log(`\n  Published ${manifest.name}@${manifest.version}`);
+      process.exit(code);
+    });
+    await new Promise(() => {});
+  }
+
+  if (subcmd === 'list') {
+    if (!existsSync(pkgManifestPath)) {
+      console.log('  No naide.pkg.json found.');
+      process.exit(0);
+    }
+    const manifest = JSON.parse(readFileSync(pkgManifestPath, 'utf-8'));
+    const deps = Object.entries(manifest.dependencies || {});
+    if (deps.length === 0) {
+      console.log('  No NAIDE packages installed.');
+    } else {
+      console.log('\n  NAIDE packages:\n');
+      for (const [name, ver] of deps) {
+        console.log(`    ${name}  ${ver}`);
+      }
+      console.log('');
+    }
+    process.exit(0);
+  }
+
+  console.log(`  Unknown subcommand: naide pkg ${subcmd}`);
+  console.log('  Run: naide pkg help');
+  process.exit(1);
+}
+
 // ── Deploy ──
 if (files[0] === 'deploy') {
   const dir = resolve(files[1] || '.');
@@ -377,15 +664,22 @@ if (flags.help) {
     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 check <files...>       Type-check without running
     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 convert <files...>     Convert between .naide and .nx formats
     naide fmt <files...>         Format NAIDE files
+    naide pkg init               Create naide.pkg.json manifest
+    naide pkg install <name>     Install a NAIDE package
+    naide pkg publish            Publish package to npm
+    naide pkg list               List NAIDE dependencies
     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)
+    naide -d <file>              Debug mode (Node.js inspector)
 
   Modes:
     .naide  Standard NAIDE (~40% fewer tokens than JS)
@@ -396,6 +690,8 @@ if (flags.help) {
     -o, --output   Write generated JavaScript to file
     -x             Force NAIDE-X mode
     -w, --watch    Watch mode: restart on file changes
+    -d, --debug    Start with Node.js debugger (--inspect-brk)
+    --check        Type-check files without running
     --mid          Show intermediate NAIDE v1 (X mode only)
     --ast          Print AST
     --tokens       Print tokens
@@ -476,7 +772,17 @@ for (const file of files) {
       continue;
     }
 
-    const result = compile(source, { mode, runtimePath });
+    const result = compile(source, { mode, runtimePath, sourceFile: file, typeCheck: flags.check });
+
+    if (flags.check) {
+      const { typeErrors } = result;
+      if (typeErrors) {
+        for (const e of typeErrors.errors) console.log(`  ${file}:${e.line} ERROR: ${e.message}`);
+        for (const w of typeErrors.warnings) console.log(`  ${file}:${w.line} WARN: ${w.message}`);
+        if (typeErrors.errors.length === 0 && typeErrors.warnings.length === 0) console.log(`  ${file}: OK`);
+      }
+      continue;
+    }
 
     if (flags.tokens) {
       console.log(JSON.stringify(result.tokens, null, 2));
@@ -503,8 +809,29 @@ for (const file of files) {
     const tempFile = resolve(`.naide_tmp_${basename(file, ext)}.mjs`);
     writeFileSync(tempFile, result.js, 'utf-8');
 
+    if (flags.debug) {
+      console.log(`\n  [NAIDE] Debugger starting — ${file}`);
+      console.log('  Open Chrome → chrome://inspect to connect\n');
+      const debugChild = spawn(process.execPath, ['--inspect-brk', tempFile], { stdio: 'inherit' });
+      debugChild.on('close', (code) => {
+        try { unlinkSync(tempFile); } catch {}
+        process.exit(code || 0);
+      });
+      process.on('SIGINT', () => {
+        debugChild.kill();
+        try { unlinkSync(tempFile); } catch {}
+        process.exit(0);
+      });
+      await new Promise(() => {});
+    }
+
     try {
       await import('file:///' + tempFile.replace(/\\/g, '/'));
+    } catch (runErr) {
+      if (!remapError(runErr, result.sourceMap, file, source)) {
+        console.error(`\n${runErr.message}`);
+      }
+      if (process.env.NAIDE_DEBUG) console.error(runErr.stack);
     } finally {
       try {
         const { unlinkSync } = await import('fs');

package/lsp/server.js

@@ -89,7 +89,38 @@ function validateDocument(uri) {
   const diagnostics = [];
 
   try {
-    compile(text, { mode });
+    const result = compile(text, { mode });
+
+    const lines = text.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (!line || line.startsWith('#') || line.startsWith('--')) continue;
+
+      const typeMatch = line.match(/^(str|int|num|bool)\s+\w+\s*=\s*(.+)/);
+      if (typeMatch) {
+        const declType = typeMatch[1];
+        const val = typeMatch[2].trim();
+        if (declType === 'int' && /^["']/.test(val)) {
+          diagnostics.push({
+            range: { start: { line: i, character: 0 }, end: { line: i, character: lines[i].length } },
+            severity: 2, source: 'naide',
+            message: `Type hint: assigning string to int variable`
+          });
+        } else if (declType === 'str' && /^\d+$/.test(val)) {
+          diagnostics.push({
+            range: { start: { line: i, character: 0 }, end: { line: i, character: lines[i].length } },
+            severity: 2, source: 'naide',
+            message: `Type hint: assigning number to str variable`
+          });
+        } else if (declType === 'bool' && !['true', 'false'].includes(val) && !/\b(not|and|or|==|!=|>|<)\b/.test(val)) {
+          diagnostics.push({
+            range: { start: { line: i, character: 0 }, end: { line: i, character: lines[i].length } },
+            severity: 2, source: 'naide',
+            message: `Type hint: value may not be boolean`
+          });
+        }
+      }
+    }
   } catch (e) {
     const lineMatch = e.message.match(/line (\d+):(\d+)/);
     const line = lineMatch ? parseInt(lineMatch[1]) - 1 : 0;
@@ -131,6 +162,10 @@ function getCompletions() {
     { label: 'api.get(url)', detail: 'HTTP GET', insertText: 'api.get(' },
     { label: 'api.post(url, body)', detail: 'HTTP POST', insertText: 'api.post(' },
     { label: 'prompt', detail: 'Reusable prompt template', insertText: 'prompt ' },
+    { label: 'createMock(fn)', detail: 'Create mock function', insertText: 'createMock(' },
+    { label: 'createSpy(obj, method)', detail: 'Spy on method', insertText: 'createSpy(' },
+    { label: 'registerPlugin(name, setup)', detail: 'Register plugin', insertText: 'registerPlugin(' },
+    { label: 'usePlugin(name)', detail: 'Use registered plugin', insertText: 'usePlugin(' },
   ];
 
   return [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "naider",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "description": "NAIDE - Node AI Development Environment. AI-specialized language with built-in server, auth, DB, SQL, AI/LLM, WebSocket, and more — transpiles to Node.js.",
   "main": "src/index.js",
   "exports": {

package/src/generator.js

@@ -16,6 +16,9 @@ export class Generator {
     this.hasAsserts = false;
     this.dbSql = false;
     this.sqlDriver = null;
+    this.sourceMap = [];
+    this.currentSourceLine = 0;
+    this.sourceFile = options.sourceFile || null;
   }
 
   generate(ast) {
@@ -46,6 +49,11 @@ export class Generator {
       preamble.push('');
     }
 
+    if (this.usesExpress) {
+      this.output.push('');
+      this.output.push("process.on('unhandledRejection', (err) => { console.error('[NAIDE] Unhandled async error:', err.message || err); });");
+    }
+
     if (preamble.length > 0) {
       this.output.unshift(...preamble);
     }
@@ -55,10 +63,12 @@ export class Generator {
 
   emit(line) {
     this.output.push('  '.repeat(this.indent) + line);
+    this.sourceMap.push(this.currentSourceLine);
   }
 
   emitRaw(line) {
     this.output.push(line);
+    this.sourceMap.push(this.currentSourceLine);
   }
 
   visitProgram(node) {
@@ -67,7 +77,15 @@ export class Generator {
     }
   }
 
+  normalizeRoutePath(pathStr) {
+    return pathStr.replace(/(["'])(.+?)\1/g, (m, q, p) => {
+      const normalized = p.replace(/(?<!\()(?<!\.\*)\*(?!\))/g, '(.*)');
+      return q + normalized + q;
+    });
+  }
+
   visitStatement(node) {
+    if (node._line) this.currentSourceLine = node._line;
     switch (node.type) {
       case 'Use': return this.visitUse(node);
       case 'UseDestructured': return this.visitUseDestructured(node);
@@ -321,6 +339,7 @@ export class Generator {
   }
 
   visitServer(node) {
+    this.usesExpress = true;
     const hasWs = node.routes.some(r => r.type === 'WsDecl');
 
     this.emit(`import express from 'express';`);
@@ -423,6 +442,12 @@ export class Generator {
     this.indent++;
 
     const hasRes = params.includes('res');
+    const hasTryCatch = route.body.some(s => s.type === 'Try');
+
+    if (needsAsync && !hasTryCatch) {
+      this.emit('try {');
+      this.indent++;
+    }
 
     for (let i = 0; i < route.body.length; i++) {
       const stmt = route.body[i];
@@ -437,6 +462,15 @@ export class Generator {
       }
     }
 
+    if (needsAsync && !hasTryCatch) {
+      this.indent--;
+      this.emit('} catch (__err) {');
+      this.indent++;
+      this.emit('if (!res.headersSent) res.status(500).json({ error: __err.message });');
+      this.indent--;
+      this.emit('}');
+    }
+
     this.indent--;
     this.emit('});');
     this.emitRaw('');
@@ -679,7 +713,7 @@ export class Generator {
     const optStr = options.length > 0 ? `, { ${options.join(', ')} }` : '';
 
     if (node.protectedPaths.length > 0) {
-      const path = this.stringValue(node.protectedPaths[0]);
+      const path = this.normalizeRoutePath(this.stringValue(node.protectedPaths[0]));
       this.emit(`${appName}.use(${path}, jwtAuth(${secret}${optStr}));`);
     } else {
       this.emit(`${appName}.use(jwtAuth(${secret}${optStr}));`);
@@ -710,7 +744,7 @@ export class Generator {
   visitLimit(appName, node) {
     this.runtimeImports.add('rateLimit');
 
-    const path = this.stringValue(node.path);
+    const path = this.normalizeRoutePath(this.stringValue(node.path));
     const max = this.expr(node.max);
     const window = this.expr(node.window);
     this.emit(`${appName}.use(${path}, rateLimit(${max}, ${window}));`);
@@ -901,7 +935,7 @@ export class Generator {
 
   visitCache(appName, node) {
     this.runtimeImports.add('cacheMiddleware');
-    const path = this.stringValue(node.path);
+    const path = this.normalizeRoutePath(this.stringValue(node.path));
     const duration = this.expr(node.duration);
     this.emit(`${appName}.use(${path}, cacheMiddleware(${duration}));`);
     this.emitRaw('');
@@ -940,7 +974,7 @@ export class Generator {
 
   visitValidate(appName, node) {
     this.runtimeImports.add('validateMiddleware');
-    const path = this.stringValue(node.path);
+    const path = this.normalizeRoutePath(this.stringValue(node.path));
     this.emit(`${appName}.use(${path}, validateMiddleware(${node.schemaName}Schema));`);
     this.emitRaw('');
   }
@@ -1092,8 +1126,12 @@ export class Generator {
       case 'Self': return 'this';
       case 'Identifier': return node.name;
 
-      case 'Binary':
-        return `(${this.expr(node.left)} ${node.op} ${this.expr(node.right)})`;
+      case 'Binary': {
+        const l = this.expr(node.left);
+        const r = this.expr(node.right);
+        const simple = node.left.type !== 'Binary' && node.right.type !== 'Binary';
+        return simple ? `${l} ${node.op} ${r}` : `(${l} ${node.op} ${r})`;
+      }
 
       case 'Unary':
         return `${node.op}${this.expr(node.expr)}`;
@@ -1174,7 +1212,9 @@ export class Generator {
   }
 
   generateCall(node) {
-    const AUTO_IMPORT = { 'hash': 'hash', 'verify': 'verify', 'uuid': 'uuid' };
+    const AUTO_IMPORT = { 'hash': 'hash', 'verify': 'verify', 'uuid': 'uuid',
+      'createMock': 'createMock', 'createSpy': 'createSpy',
+      'registerPlugin': 'registerPlugin', 'usePlugin': 'usePlugin' };
 
     if (node.callee.type === 'Identifier' && AUTO_IMPORT[node.callee.name]) {
       const runtimeFn = AUTO_IMPORT[node.callee.name];

package/src/index.js

@@ -2,8 +2,9 @@ import { Lexer } from './lexer.js';
 import { Parser } from './parser.js';
 import { Generator } from './generator.js';
 import { preprocess } from './preprocess.js';
+import { TypeChecker } from './typechecker.js';
 
-export function compile(source, { mode = 'naide', runtimePath } = {}) {
+export function compile(source, { mode = 'naide', runtimePath, sourceFile, typeCheck = false } = {}) {
   let processedSource = source;
   if (mode === 'x') {
     processedSource = preprocess(source);
@@ -13,9 +14,16 @@ export function compile(source, { mode = 'naide', runtimePath } = {}) {
     const tokens = lexer.tokenize();
     const parser = new Parser(tokens);
     const ast = parser.parse();
-    const generator = new Generator({ runtimePath });
+
+    let typeErrors = null;
+    if (typeCheck) {
+      const checker = new TypeChecker();
+      typeErrors = checker.check(ast);
+    }
+
+    const generator = new Generator({ runtimePath, sourceFile });
     const js = generator.generate(ast);
-    return { js, ast, tokens, naide: mode === 'x' ? processedSource : null };
+    return { js, ast, tokens, sourceMap: generator.sourceMap, naide: mode === 'x' ? processedSource : null, typeErrors };
   } catch (e) {
     const lineMatch = e.message.match(/line (\d+)/);
     if (lineMatch) {

package/src/lexer.js

@@ -18,6 +18,8 @@ export class Lexer {
     this.tokens = [];
     this.indentStack = [0];
     this.atLineStart = true;
+    this.indentUnit = 0;
+    this.tabSize = 4;
   }
 
   peek() {
@@ -125,7 +127,7 @@ export class Lexer {
         this.pos++;
         this.col++;
       } else if (ch === '\t') {
-        indent += 2;
+        indent += this.tabSize;
         this.pos++;
         this.col++;
       } else {
@@ -133,7 +135,6 @@ export class Lexer {
       }
     }
 
-    // Skip blank lines and comment-only lines
     if (this.pos >= this.source.length || this.source[this.pos] === '\n' || this.source[this.pos] === '#') {
       return;
     }
@@ -141,6 +142,10 @@ export class Lexer {
     const currentIndent = this.indentStack[this.indentStack.length - 1];
 
     if (indent > currentIndent) {
+      if (!this.indentUnit) {
+        this.indentUnit = indent - currentIndent;
+        this.tabSize = this.indentUnit;
+      }
       this.indentStack.push(indent);
       this.tokens.push(this.makeToken(T.INDENT, indent));
     } else if (indent < currentIndent) {

package/src/parser.js

@@ -1,8 +1,9 @@
 import { T, TYPE_TOKENS } from './tokens.js';
 
 class ASTNode {
-  constructor(type, props = {}) {
+  constructor(type, props = {}, line = 0) {
     this.type = type;
+    this._line = line;
     Object.assign(this, props);
   }
 }
@@ -119,6 +120,10 @@ export class Parser {
     throw this.error(`Expected property name but got ${tok.type} ('${tok.value}')`, tok);
   }
 
+  node(type, props = {}) {
+    return new ASTNode(type, props, this.peek().line);
+  }
+
   error(msg, tok) {
     const t = tok || this.peek();
     return new Error(`[NAIDE Parse Error] ${msg} at line ${t.line}:${t.col}`);

package/src/runtime.js

@@ -833,6 +833,7 @@ export function createSqliteStore(db, tableName, schema) {
   }).join(', ');
 
   db.exec(`CREATE TABLE IF NOT EXISTS "${tableName}" (${columns})`);
+  migrateSqliteSchema(db, tableName, schema);
 
   function toRow(data) {
     const row = { ...data };
@@ -952,6 +953,83 @@ export function createPrompt(template, defaults = {}) {
   };
 }
 
+// ===== Schema Migration (auto ALTER TABLE for SQLite) =====
+export function migrateSqliteSchema(db, tableName, schema) {
+  const fields = Object.entries(schema.fields);
+  const info = db.prepare(`PRAGMA table_info("${tableName}")`).all();
+  const existing = new Set(info.map(c => c.name));
+  let changed = 0;
+
+  for (const [name, rules] of fields) {
+    if (!existing.has(name)) {
+      let type = 'TEXT';
+      if (rules.type === 'integer') type = 'INTEGER';
+      if (rules.type === 'number') type = 'REAL';
+      if (rules.type === 'boolean') type = 'INTEGER';
+      let def = '';
+      if (rules.default !== undefined) {
+        const d = typeof rules.default === 'boolean' ? (rules.default ? 1 : 0) :
+                  typeof rules.default === 'string' ? `'${rules.default}'` : rules.default;
+        def = ` DEFAULT ${d}`;
+      }
+      db.exec(`ALTER TABLE "${tableName}" ADD COLUMN "${name}" ${type}${def}`);
+      changed++;
+    }
+  }
+  return changed;
+}
+
+// ===== Mock / Spy (test utilities) =====
+export function createMock(fn) {
+  const calls = [];
+  let impl = fn || (() => undefined);
+  const mock = function(...args) {
+    calls.push({ args, timestamp: Date.now() });
+    return impl.apply(this, args);
+  };
+  mock.calls = calls;
+  mock.callCount = () => calls.length;
+  mock.calledWith = (...expected) => calls.some(c =>
+    c.args.length === expected.length && c.args.every((a, i) => a === expected[i])
+  );
+  mock.returns = (val) => { impl = () => val; return mock; };
+  mock.impl = (f) => { impl = f; return mock; };
+  mock.reset = () => { calls.length = 0; return mock; };
+  return mock;
+}
+
+export function createSpy(obj, method) {
+  const original = obj[method];
+  const mock = createMock(original.bind(obj));
+  obj[method] = mock;
+  mock.restore = () => { obj[method] = original; };
+  return mock;
+}
+
+// ===== Plugin System =====
+const _plugins = new Map();
+
+export function registerPlugin(name, setup) {
+  _plugins.set(name, { name, setup, initialized: false, exports: {} });
+}
+
+export function usePlugin(name, options = {}) {
+  const plugin = _plugins.get(name);
+  if (!plugin) throw new Error(`Plugin not found: ${name}`);
+  if (!plugin.initialized) {
+    const result = plugin.setup(options);
+    if (result && typeof result === 'object') {
+      plugin.exports = result;
+    }
+    plugin.initialized = true;
+  }
+  return plugin.exports;
+}
+
+export function listPlugins() {
+  return [..._plugins.keys()];
+}
+
 // ===== Helpers =====
 function parseMs(str) {
   if (typeof str === 'number') return str;

package/src/typechecker.js

@@ -0,0 +1,261 @@
+export class TypeChecker {
+  constructor() {
+    this.scopes = [new Map()];
+    this.errors = [];
+    this.warnings = [];
+    this.functions = new Map();
+  }
+
+  pushScope() { this.scopes.push(new Map()); }
+  popScope() { this.scopes.pop(); }
+
+  setType(name, type) {
+    this.scopes[this.scopes.length - 1].set(name, type);
+  }
+
+  getType(name) {
+    for (let i = this.scopes.length - 1; i >= 0; i--) {
+      if (this.scopes[i].has(name)) return this.scopes[i].get(name);
+    }
+    return null;
+  }
+
+  error(msg, line) {
+    this.errors.push({ message: msg, line: line || 0, severity: 'error' });
+  }
+
+  warn(msg, line) {
+    this.warnings.push({ message: msg, line: line || 0, severity: 'warning' });
+  }
+
+  check(ast) {
+    this.visitProgram(ast);
+    return { errors: this.errors, warnings: this.warnings };
+  }
+
+  visitProgram(node) {
+    for (const stmt of node.body) {
+      this.visitStatement(stmt);
+    }
+  }
+
+  visitStatement(node) {
+    const line = node._line || 0;
+    switch (node.type) {
+      case 'TypedVar': return this.visitTypedVar(node, line);
+      case 'Function': return this.visitFunction(node, line);
+      case 'Assignment': return this.visitAssignment(node, line);
+      case 'Return': return this.visitReturn(node, line);
+      case 'If': return this.visitIf(node, line);
+      case 'Each': return this.visitEach(node, line);
+      case 'For': return this.visitFor(node, line);
+      case 'While': return this.visitWhile(node, line);
+      case 'Try': return this.visitTry(node, line);
+      case 'Server': return this.visitBlock(node.body, line);
+      default: return;
+    }
+  }
+
+  visitBlock(body, _line) {
+    if (!body) return;
+    this.pushScope();
+    for (const stmt of body) {
+      this.visitStatement(stmt);
+    }
+    this.popScope();
+  }
+
+  visitTypedVar(node, line) {
+    const declaredType = node.varType;
+    const inferredType = this.inferType(node.value);
+
+    if (declaredType && inferredType && inferredType !== 'any' && declaredType !== 'any') {
+      const compatible = this.typesCompatible(declaredType, inferredType);
+      if (!compatible) {
+        this.error(`Type mismatch: cannot assign ${inferredType} to ${declaredType}`, line);
+      }
+    }
+
+    this.setType(node.name, declaredType || inferredType || 'any');
+  }
+
+  visitFunction(node, line) {
+    const paramTypes = {};
+    for (const p of node.params) {
+      paramTypes[p.name] = p.varType || 'any';
+    }
+
+    this.functions.set(node.name, {
+      params: node.params.map(p => ({ name: p.name, type: p.varType || 'any' })),
+      returnType: node.returnType || 'any',
+      isAsync: node.isAsync || false,
+    });
+
+    this.setType(node.name, 'function');
+
+    this.pushScope();
+    for (const p of node.params) {
+      this.setType(p.name, p.varType || 'any');
+    }
+    for (const stmt of node.body) {
+      this.visitStatement(stmt);
+    }
+    this.popScope();
+  }
+
+  visitAssignment(node, line) {
+    if (node.target.type === 'Identifier') {
+      const existing = this.getType(node.target.name);
+      const newType = this.inferType(node.value);
+      if (existing && existing !== 'any' && newType && newType !== 'any') {
+        if (!this.typesCompatible(existing, newType)) {
+          this.warn(`Type warning: reassigning ${existing} variable '${node.target.name}' with ${newType}`, line);
+        }
+      }
+      if (!existing) {
+        this.setType(node.target.name, newType || 'any');
+      }
+    }
+  }
+
+  visitReturn(node, line) {}
+
+  visitIf(node, line) {
+    this.visitBlock(node.body, line);
+    for (const elif of (node.elifs || [])) {
+      this.visitBlock(elif.body, line);
+    }
+    if (node.elseBody) {
+      this.visitBlock(node.elseBody, line);
+    }
+  }
+
+  visitEach(node, line) {
+    this.pushScope();
+    this.setType(node.variable, 'any');
+    if (node.keyVar) this.setType(node.keyVar, 'any');
+    for (const stmt of node.body) {
+      this.visitStatement(stmt);
+    }
+    this.popScope();
+  }
+
+  visitFor(node, line) {
+    this.pushScope();
+    this.setType(node.variable, 'int');
+    for (const stmt of node.body) {
+      this.visitStatement(stmt);
+    }
+    this.popScope();
+  }
+
+  visitWhile(node, line) {
+    this.visitBlock(node.body, line);
+  }
+
+  visitTry(node, line) {
+    this.visitBlock(node.body, line);
+    if (node.catchBody) {
+      this.pushScope();
+      if (node.catchVar) this.setType(node.catchVar, 'any');
+      for (const stmt of node.catchBody) {
+        this.visitStatement(stmt);
+      }
+      this.popScope();
+    }
+    if (node.ensureBody) {
+      this.visitBlock(node.ensureBody, line);
+    }
+  }
+
+  inferType(node) {
+    if (!node) return 'any';
+    switch (node.type) {
+      case 'Number': {
+        const n = typeof node.value === 'string' ? Number(node.value) : node.value;
+        return Number.isInteger(n) && !String(node.value).includes('.') ? 'int' : 'num';
+      }
+      case 'String': return 'str';
+      case 'InterpolatedString': return 'str';
+      case 'Boolean': return 'bool';
+      case 'Null': return 'any';
+      case 'Array': return 'list';
+      case 'Object': return 'map';
+      case 'Identifier': return this.getType(node.name) || 'any';
+      case 'Binary': return this.inferBinaryType(node);
+      case 'Unary': {
+        if (node.op === 'not') return 'bool';
+        if (node.op === 'typeof') return 'str';
+        return this.inferType(node.operand);
+      }
+      case 'Call': return this.inferCallType(node);
+      case 'MemberAccess': return 'any';
+      case 'Ternary': {
+        const t = this.inferType(node.consequent);
+        const f = this.inferType(node.alternate);
+        return t === f ? t : 'any';
+      }
+      case 'Await': return this.inferType(node.expression);
+      case 'ArrowFunction': return 'function';
+      default: return 'any';
+    }
+  }
+
+  inferBinaryType(node) {
+    const op = node.op;
+    if (['==', '!=', '>', '<', '>=', '<=', 'and', 'or'].includes(op)) return 'bool';
+    if (['+', '-', '*', '/', '%'].includes(op)) {
+      const l = this.inferType(node.left);
+      const r = this.inferType(node.right);
+      if (l === 'str' || r === 'str') {
+        if (op === '+') return 'str';
+      }
+      if (l === 'num' || r === 'num') return 'num';
+      if (l === 'int' && r === 'int') return 'int';
+      return 'num';
+    }
+    return 'any';
+  }
+
+  inferCallType(node) {
+    if (node.callee.type === 'Identifier') {
+      const fn = this.functions.get(node.callee.name);
+      if (fn) return fn.returnType;
+
+      const builtins = {
+        'uuid': 'str', 'hash': 'str', 'verify': 'bool',
+        'sign': 'str', 'parseInt': 'int', 'parseFloat': 'num',
+        'String': 'str', 'Number': 'num', 'Boolean': 'bool',
+        'createMock': 'function', 'createSpy': 'function',
+      };
+      if (builtins[node.callee.name]) return builtins[node.callee.name];
+    }
+
+    if (node.callee.type === 'MemberAccess') {
+      const obj = node.callee.object;
+      const prop = node.callee.property;
+      if (obj.type === 'Identifier' && obj.name === 'ai') {
+        if (prop === 'ask' || prop === 'chat') return 'str';
+        if (prop === 'json') return 'map';
+        if (prop === 'embed') return 'list';
+        if (prop === 'similarity') return 'num';
+      }
+      if (obj.type === 'Identifier' && obj.name === 'api') return 'any';
+      if (prop === 'length') return 'int';
+      if (['map', 'filter', 'slice'].includes(prop)) return 'list';
+      if (['join', 'toString', 'trim', 'toLowerCase', 'toUpperCase'].includes(prop)) return 'str';
+      if (['includes', 'startsWith', 'endsWith', 'some', 'every'].includes(prop)) return 'bool';
+      if (['indexOf', 'findIndex'].includes(prop)) return 'int';
+    }
+
+    return 'any';
+  }
+
+  typesCompatible(declared, actual) {
+    if (declared === actual) return true;
+    if (declared === 'any' || actual === 'any') return true;
+    if (declared === 'num' && actual === 'int') return true;
+    if (declared === 'json' && ['str', 'int', 'num', 'bool', 'list', 'map'].includes(actual)) return true;
+    return false;
+  }
+}