naider 1.24.5 → 2.0.1

package/src/typechecker.js

@@ -1,9 +1,19 @@
+const EXPRESSION_TYPES = new Set([
+  'Number', 'String', 'InterpolatedString', 'Bool', 'Null', 'Array', 'Object',
+  'Identifier', 'Binary', 'Unary', 'Call', 'MemberAccess', 'Ternary', 'Await',
+  'ArrowFunction', 'Spread', 'New', 'IndexAccess',
+]);
+
 export class TypeChecker {
   constructor() {
     this.scopes = [new Map()];
     this.errors = [];
     this.warnings = [];
+    this.errorKeys = new Set();
+    this.warningKeys = new Set();
+    this.visitedStatements = new WeakSet();
     this.functions = new Map();
+    this.returnTypes = [];
   }
 
   pushScope() { this.scopes.push(new Map()); }
@@ -21,18 +31,37 @@ export class TypeChecker {
   }
 
   error(msg, line) {
-    this.errors.push({ message: msg, line: line || 0, severity: 'error' });
+    const diagnostic = { message: msg, line: line || 0, severity: 'error' };
+    const key = `${diagnostic.line}:${diagnostic.message}`;
+    if (this.errorKeys.has(key)) return;
+    this.errorKeys.add(key);
+    this.errors.push(diagnostic);
   }
 
   warn(msg, line) {
-    this.warnings.push({ message: msg, line: line || 0, severity: 'warning' });
+    const diagnostic = { message: msg, line: line || 0, severity: 'warning' };
+    const key = `${diagnostic.line}:${diagnostic.message}`;
+    if (this.warningKeys.has(key)) return;
+    this.warningKeys.add(key);
+    this.warnings.push(diagnostic);
   }
 
   check(ast) {
+    for (const stmt of ast.body) {
+      if (stmt.type === 'Function') this.registerFunction(stmt);
+    }
     this.visitProgram(ast);
     return { errors: this.errors, warnings: this.warnings };
   }
 
+  registerFunction(node) {
+    this.functions.set(node.name, {
+      params: node.params.map(p => ({ name: p.name, type: p.type || 'any', hasDefault: p.defaultValue !== null, spread: p.spread })),
+      returnType: node.returnType || 'any',
+      isAsync: node.isAsync || false,
+    });
+  }
+
   visitProgram(node) {
     for (const stmt of node.body) {
       this.visitStatement(stmt);
@@ -40,7 +69,10 @@ export class TypeChecker {
   }
 
   visitStatement(node) {
+    if (this.visitedStatements.has(node)) return;
+    this.visitedStatements.add(node);
     const line = node._line || 0;
+    this.checkExpressions(node);
     switch (node.type) {
       case 'TypedVar': return this.visitTypedVar(node, line);
       case 'Function': return this.visitFunction(node, line);
@@ -51,11 +83,59 @@ export class TypeChecker {
       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;
+      case 'Server': return this.visitServer(node, line);
+      default: return this.visitNestedStatements(node);
     }
   }
 
+  checkExpressions(node) {
+    const seen = new WeakSet();
+    const visit = value => {
+      if (Array.isArray(value)) {
+        if (seen.has(value)) return;
+        seen.add(value);
+        for (const item of value) visit(item);
+        return;
+      }
+      if (!value || typeof value !== 'object') return;
+      if (seen.has(value)) return;
+      seen.add(value);
+
+      if (typeof value.type === 'string') {
+        if (!EXPRESSION_TYPES.has(value.type)) return;
+        this.inferType(value);
+        for (const [key, child] of Object.entries(value)) {
+          if (key !== 'type' && key !== '_line') visit(child);
+        }
+        return;
+      }
+
+      for (const child of Object.values(value)) visit(child);
+    };
+
+    for (const [key, value] of Object.entries(node)) {
+      if (key !== 'type' && key !== '_line') visit(value);
+    }
+  }
+
+  visitNestedStatements(value, seen = new WeakSet()) {
+    if (Array.isArray(value)) {
+      if (seen.has(value)) return;
+      seen.add(value);
+      for (const item of value) this.visitNestedStatements(item, seen);
+      return;
+    }
+    if (!value || typeof value !== 'object') return;
+    if (seen.has(value)) return;
+    seen.add(value);
+    if (typeof value.type === 'string') {
+      if (EXPRESSION_TYPES.has(value.type)) return;
+      this.visitStatement(value);
+      return;
+    }
+    for (const child of Object.values(value)) this.visitNestedStatements(child, seen);
+  }
+
   visitBlock(body, _line) {
     if (!body) return;
     this.pushScope();
@@ -80,26 +160,20 @@ export class TypeChecker {
   }
 
   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.registerFunction(node);
 
     this.setType(node.name, 'function');
 
     this.pushScope();
     for (const p of node.params) {
-      this.setType(p.name, p.varType || 'any');
+      this.setType(p.name, p.type || 'any');
+      if (p.defaultValue) this.inferType(p.defaultValue);
     }
+    this.returnTypes.push(node.returnType || 'any');
     for (const stmt of node.body) {
       this.visitStatement(stmt);
     }
+    this.returnTypes.pop();
     this.popScope();
   }
 
@@ -118,7 +192,22 @@ export class TypeChecker {
     }
   }
 
-  visitReturn(node, line) {}
+  visitReturn(node, line) {
+    const expectedType = this.returnTypes[this.returnTypes.length - 1];
+    if (!expectedType || expectedType === 'any') return;
+
+    if (!node.value) {
+      if (expectedType !== 'void') {
+        this.error(`Return type mismatch: expected ${expectedType} but got void`, line);
+      }
+      return;
+    }
+
+    const actualType = this.inferType(node.value);
+    if (actualType !== 'any' && !this.typesCompatible(expectedType, actualType)) {
+      this.error(`Return type mismatch: expected ${expectedType} but got ${actualType}`, line);
+    }
+  }
 
   visitIf(node, line) {
     this.visitBlock(node.body, line);
@@ -168,6 +257,19 @@ export class TypeChecker {
     }
   }
 
+  visitServer(node, line) {
+    for (const route of node.routes || []) {
+      this.pushScope();
+      for (const param of route.params || []) {
+        this.setType(typeof param === 'string' ? param : param.name, 'any');
+      }
+      this.visitBlock(route.body, line);
+      this.popScope();
+    }
+    this.visitNestedStatements(node.middleware || []);
+    this.visitNestedStatements(node.body || []);
+  }
+
   inferType(node) {
     if (!node) return 'any';
     switch (node.type) {
@@ -177,7 +279,7 @@ export class TypeChecker {
       }
       case 'String': return 'str';
       case 'InterpolatedString': return 'str';
-      case 'Boolean': return 'bool';
+      case 'Bool': return 'bool';
       case 'Null': return 'any';
       case 'Array': return 'list';
       case 'Object': return 'map';
@@ -220,7 +322,10 @@ export class TypeChecker {
   inferCallType(node) {
     if (node.callee.type === 'Identifier') {
       const fn = this.functions.get(node.callee.name);
-      if (fn) return fn.returnType;
+      if (fn) {
+        this.checkCallArguments(node, fn);
+        return fn.returnType;
+      }
 
       const builtins = {
         'uuid': 'str', 'hash': 'str', 'verify': 'bool',
@@ -251,6 +356,30 @@ export class TypeChecker {
     return 'any';
   }
 
+  checkCallArguments(node, fn) {
+    const params = fn.params;
+    const line = node._line || 0;
+    const requiredCount = params.filter(p => !p.hasDefault && !p.spread).length;
+    const hasSpread = params.some(p => p.spread);
+
+    if (node.args.length < requiredCount || (!hasSpread && node.args.length > params.length)) {
+      const expected = hasSpread ? `at least ${requiredCount}` : `${requiredCount}${params.length === requiredCount ? '' : ` to ${params.length}`}`;
+      this.error(`Argument count mismatch for '${node.callee.name}': expected ${expected}, got ${node.args.length}`, line);
+    }
+
+    const spreadIndex = params.findIndex(param => param.spread);
+    for (let i = 0; i < node.args.length; i++) {
+      const paramIndex = spreadIndex >= 0 && i >= spreadIndex ? spreadIndex : i;
+      const param = params[paramIndex];
+      if (!param) continue;
+      const expectedType = param.type;
+      const actualType = this.inferType(node.args[i]);
+      if (expectedType !== 'any' && actualType !== 'any' && !this.typesCompatible(expectedType, actualType)) {
+        this.error(`Argument '${param.name}' of '${node.callee.name}' expects ${expectedType} but got ${actualType}`, line);
+      }
+    }
+  }
+
   typesCompatible(declared, actual) {
     if (declared === actual) return true;
     if (declared === 'any' || actual === 'any') return true;

package/vscode-naide/README.md

@@ -1,22 +1,20 @@
 # NAIDE Language Support for VS Code
 
-Syntax highlighting and language support for **NAIDE** (`.naide`) and **NAIDE-X** (`.nx`) files.
+Syntax highlighting and language support for **NAIDE** (`.naide`) files.
 
 ## Features
 
 - Syntax highlighting for all NAIDE keywords, types, and operators
-- Syntax highlighting for NAIDE-X shorthand prefixes (`>`, `?`, `!`, `$`, `^`, `@`, etc.)
 - String interpolation highlighting (`"Hello {name}"`)
 - Auto-indentation for block structures
 - Bracket matching and auto-closing
-- Comment toggling (`#` for .naide, `--` for .nx)
+- Comment toggling (`#`)
 
 ## File Associations
 
 | Extension | Language |
 |-----------|----------|
 | `.naide`  | NAIDE    |
-| `.nx`     | NAIDE-X  |
 
 ## Install
 
@@ -26,7 +24,7 @@ Syntax highlighting and language support for **NAIDE** (`.naide`) and **NAIDE-X*
 cd vscode-naide
 npm install -g @vscode/vsce
 vsce package
-code --install-extension naide-lang-1.0.0.vsix
+code --install-extension naide-lang-2.0.1.vsix
 ```
 
 ### Manual
@@ -35,4 +33,4 @@ Copy `vscode-naide/` to `~/.vscode/extensions/naide-lang/` and restart VS Code.
 
 ## About NAIDE
 
-NAIDE is an AI-optimized programming language that transpiles to Node.js. See [github.com/irxk/naide](https://github.com/irxk/naide).
+NAIDE is a programming language with one readable syntax, built-in diagnostics, and compiler targets. See [github.com/irxk/naide](https://github.com/irxk/naide).

package/vscode-naide/extension.js

@@ -18,10 +18,9 @@ function activate(context) {
   const clientOptions = {
     documentSelector: [
       { scheme: 'file', language: 'naide' },
-      { scheme: 'file', language: 'naidex' },
     ],
     synchronize: {
-      fileEvents: vscode.workspace.createFileSystemWatcher('**/*.{naide,nx}'),
+      fileEvents: vscode.workspace.createFileSystemWatcher('**/*.naide'),
     },
   };
 

package/vscode-naide/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "naide-lang",
-  "version": "1.1.0",
+  "version": "2.0.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "naide-lang",
-      "version": "1.1.0",
+      "version": "2.0.1",
       "dependencies": {
         "vscode-languageclient": "^9.0.0"
       },

package/vscode-naide/package.json

@@ -1,15 +1,14 @@
 {
   "name": "naide-lang",
   "displayName": "NAIDE Language",
-  "description": "Syntax highlighting, diagnostics, and autocomplete for NAIDE (.naide) and NAIDE-X (.nx)",
-  "version": "1.1.0",
+  "description": "Syntax highlighting, diagnostics, and autocomplete for NAIDE (.naide)",
+  "version": "2.0.1",
   "publisher": "irxk",
   "engines": { "vscode": "^1.75.0" },
   "categories": ["Programming Languages"],
   "main": "./extension.js",
   "activationEvents": [
-    "onLanguage:naide",
-    "onLanguage:naidex"
+    "onLanguage:naide"
   ],
   "repository": {
     "type": "git",
@@ -22,12 +21,6 @@
         "aliases": ["NAIDE", "naide"],
         "extensions": [".naide"],
         "configuration": "./language-configuration-naide.json"
-      },
-      {
-        "id": "naidex",
-        "aliases": ["NAIDE-X", "naidex", "nx"],
-        "extensions": [".nx"],
-        "configuration": "./language-configuration-nx.json"
       }
     ],
     "grammars": [
@@ -35,11 +28,6 @@
         "language": "naide",
         "scopeName": "source.naide",
         "path": "./syntaxes/naide.tmLanguage.json"
-      },
-      {
-        "language": "naidex",
-        "scopeName": "source.naidex",
-        "path": "./syntaxes/naidex.tmLanguage.json"
       }
     ],
     "configuration": {

package/SPEC-X.nx

@@ -1,276 +0,0 @@
--- ============================================
--- NAIDE-X Language Specification
--- ~80% fewer tokens than JavaScript
--- AI-only readability. Maximum generation speed.
--- ============================================
--- Rule: first char of line = intent
---   > return    ? if       | elif     : else
---   @ loop      * while    ! try      !! catch   !!! ensure
---   $ server    ^ model    < import   % match   X patch
---   f func      ~f async   + export
---   s:i:n:b:l:m:a: typed vars
---   ~ await     ~~ await.all
--- ============================================
-
--- Types: s=str i=int n=num b=bool l=list m=map a=any
-s:name="hello"
-i:count=42
-n:price=9.99
-b:active=true
-l:items=[1,2,3]
-m:cfg={host:"localhost",port:3000}
-a:data=null
-
--- Mutable: ~ prefix
-~i:counter=0
-~s:label="init"
-
--- String interpolation: "{expr}" (double quotes)
-s:greet="Hello {name}, count is {count}"
-
--- Functions: f name(TYPE:param,...)RETTYPE
-f add(i:a,i:b)i
-  >a+b
-
-f sayHi(s:who)
-  log"Hi {who}"
-
-f greet2(s:name,s:prefix="Hello")
-  log"{prefix}, {name}!"
-
--- Async: ~f
-~f fetchUser(s:id)m
-  a:res=~fetch("/api/users/{id}")
-  a:data=~res.json()
-  >data
-
--- Return: >
--- Return with status: >.s CODE BODY
-
--- If/elif/else: ? | :
-?count>10
-  log"many"
-|count>5
-  log"some"
-:
-  log"few"
-
--- Inline ternary (same as NAIDE v1)
--- s:size=if count>10 then "big" else "small"
-
--- Each: @var<collection
-@item<items
-  log item
-
--- Each with key: @key,val<collection
-@k,v<cfg
-  log"{k}: {v}"
-
--- For range: @var<start..end
-@i<0..10
-  log i
-
--- While: *condition
-*active
-  log"running"
-  active=false
-
--- Match: %value
-s:status="ok"
-%status
-  "ok": log "success"
-  "error": log "failed"
-  _: log "unknown"
-
--- Try/catch/ensure: ! / !!var / !!!
-~f safe(s:url)m
-  !
-    a:data=~fetch(url)
-    >{ok:true,data:data}
-  !!e
-    log.e"fail: {e.message}"
-    >{ok:false,error:e.message}
-  !!!
-    log"request done"
-
--- typeof / instanceof
-?typeof x=="string"
-  log"is string"
-?err instanceof TypeError
-  log"type error"
-
--- Pipe: |> (same)
-l:result=[1,2,3,4,5]
-  |>filter((x)=>x>2)
-  |>map((x)=>x*10)
-
--- Model: ^Name
-^User
-  s:name
-  s:email
-  i:age=0
-  f greet()s
-    >"Hi, I'm {self.name}"
-  ~f save()
-    log"Saving {self.name}..."
-
--- Inheritance: ^Child<Parent
-^Admin<User
-  s:role="admin"
-  f perms()l
-    >["read","write","delete"]
-
--- DB persistence: db "path/"
-db "data/"
-
--- SQL database: db.sql "driver" "connection"
--- db.sql "sqlite" "app.db"
--- db.sql "postgres" "postgresql://localhost/mydb"
-
--- Environment variables
-env:
-  PORT int default(3000)
-  JWT_SECRET str required
-
--- Schema: types + modifiers
-schema User:
-  id auto
-  name str required min(2) max(50)
-  email str required email unique
-  role enum("admin","user") default("user")
-  joined timestamp auto
-
--- Server with high-level features
-$app:PORT
-  cors "*"
-  auth JWT_SECRET:
-    protect "/api/*"
-    public "/api/auth/*"
-  limit "/api/*" 100 "1m"
-  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}
-  -- Route middleware: [mid1, mid2]
-  G"/admin"[authCheck](req,res)
-    >{admin:true}
-  P"/api/secure"[auth,logger](req,res)
-    >req.body
-  group "/api/v1":
-    G"/status"
-      >{version:"1.0"}
-  G"/"
-    >.h "<h1>Welcome</h1>"
-  P"/api/auth/register"(req,res)
-    s:hashed=hash(req.body.password)
-    user=UserStore.create({...req.body,password:hashed})
-    token=auth.sign({id:user.id})
-    >{token,user}
-  P"/api/auth/login"(req,res)
-    user=UserStore.where({email:req.body.email})[0]
-    ?not user
-      >.s 401 {error:"Invalid credentials"}
-    ?not verify(req.body.password,user.password)
-      >.s 401 {error:"Invalid credentials"}
-    token=sign({id:user.id})
-    >{token}
-  ws "/chat":
-    on "connect":
-      send({type:"welcome"})
-    on "message" (data):
-      broadcast(data)
-
--- Error handler
-  error (err, req, res):
-    log.e err.message
-    >.s 500 {error:"Internal error"}
-
--- HTTP client (auto-imported)
--- api.get(url) api.post(url,body) api.put(url,body) api.del(url) api.raw(url,opts)
-
--- Return helpers
--- >expr         → JSON
--- >.s CODE expr → status code
--- >.r "/path"   → redirect
--- >.h "<html>"  → HTML
--- >.t "text"    → plain text
--- >.f "/file"   → send file
--- >.d "/file"   → download
--- >.v "tmpl" {} → render template
-
--- Built-in functions (auto-imported)
--- uuid()                → UUID
--- hash("password")      → scrypt hash
--- verify("pw",hashed)   → verify
--- 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"
-
--- AI / LLM integration (auto-imported, zero-dep)
--- s:answer=~ai.ask("Explain NAIDE")
--- m:result=~ai.json("List 3 colors",{colors:["string"]})
--- s:reply=~ai.chat(msgs)
--- s:a=~ai.ask("hi",{model:"gpt-4o",maxTokens:100})
--- Streaming: ~f main(): @chunk<~ai.stream("poem") ...
--- Embed: l:vec=~ai.embed("hello")
--- Similarity: n:score=ai.similarity(a,b)
-
--- Prompt template
--- prompt summarize {lang:"en"}:
---   "Summarize in {lang}: {text}"
-
--- Inter-file import (.naide/.nx → .mjs auto-rewrite)
--- <{handler}"./routes.naide"
-
--- Scheduled tasks
-every "5m":
-  log"cleanup"
-
--- Event watch
-watch User.create (event):
-  log"new: {event.data.name}"
-
--- Import: <module or <{names}"module"
--- <express
--- <{readFile,writeFile}"fs/promises"
-
--- Export: + prefix
-+f helper()s
-  >"exported"
-+s:VER="1.0.0"
-
--- Log: log, log.e, log.w, log.i, log.d
-log"info"
-log.e"error"
-log.w"warning"
-log.i"info level"
-log.d"debug level"
-
--- Null safe: ?. and ?? (same)
-a:val=data?.nested?.value??"default"
-
--- Await all: ~~[expr1,expr2]
-
--- Spread: ...
-l:combined=[...items,4,5,6]
-m:merged={...cfg,debug:true}

package/examples/ai-app.nx

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