naider 1.24.5 → 2.0.1

package/README.md

@@ -1,33 +1,36 @@
 # NAIDE
 
-**Node AI Development Environment** — A programming language simpler than Python, designed for AI-speed code generation, that transpiles to **15 languages**.
+**Node AI Development Environment** — One readable syntax for building, checking, and running applications, with compiler targets for **15 languages**.
 
-NAIDE is built on four principles: simpler than Python (built-in functions, syntax sugar, zero boilerplate), one way to write everything (zero ambiguity), keyword-driven intent (the first token decides meaning), and minimal token count (fewer tokens = faster AI generation). Write once, compile to any target. 40+ built-in functions, syntax sugar (`unless`, `until`, `repeat`, `swap`, `is`/`isnt`, one-line functions, `auto` type inference, destructuring, pipe operator), and 55+ built-in features including servers, databases, authentication, bots, GraphQL, gRPC, WebRTC, blockchain, and more.
+NAIDE is designed around one canonical syntax shared by people, AI tools, the compiler, editor support, and examples. It combines familiar control flow and types with concise inference, a built-in application toolkit, diagnostics, and a compiler that can emit multiple targets. The goal is not to hide how programs work, but to make common work direct and errors easier to find.
 
 ### Compilation Targets
 
-| Target | Flag | Language | Server Framework |
-|--------|------|----------|-----------------|
-| `node` | default | JavaScript (ES Modules) | Express |
-| `python` / `py` | `--target python` | Python | Flask |
-| `bun` | `--target bun` | JavaScript (Bun) | Bun.serve |
-| `typescript` / `ts` | `--target ts` | TypeScript | Express |
-| `go` | `--target go` | Go | net/http |
-| `java` | `--target java` | Java | HttpServer |
-| `rust` / `rs` | `--target rust` | Rust | actix-web |
-| `cpp` / `c++` | `--target cpp` | C++ | cpp-httplib |
-| `c` | `--target c` | C | libmicrohttpd |
-| `csharp` / `cs` | `--target csharp` | C# | ASP.NET |
-| `kotlin` / `kt` | `--target kotlin` | Kotlin | Ktor |
-| `swift` | `--target swift` | Swift | Vapor |
-| `dart` | `--target dart` | Dart | shelf |
-| `php` | `--target php` | PHP | Built-in / Laravel |
-| `ruby` / `rb` | `--target ruby` | Ruby | Sinatra |
-
-Two syntax modes:
-
-- **NAIDE** (`.naide`) — Human-readable, ~40% fewer tokens than JavaScript
-- **NAIDE-X** (`.nx`) — AI-only readability, ~80% fewer tokens than JavaScript
+| Target | Flag | Language | Server Framework | CI validation |
+|--------|------|----------|-----------------|---------------|
+| `node` | default | JavaScript (ES Modules) | Express | Code generation + basic runtime smoke |
+| `python` / `py` | `--target python` | Python | Flask | Code generation + basic runtime smoke |
+| `bun` | `--target bun` | JavaScript (Bun) | Bun.serve | Code generation + basic runtime smoke |
+| `typescript` / `ts` | `--target ts` | TypeScript | Express | Code generation smoke test |
+| `go` | `--target go` | Go | net/http | Code generation + basic runtime smoke |
+| `java` | `--target java` | Java | HttpServer | Code generation smoke test |
+| `rust` / `rs` | `--target rust` | Rust | actix-web | Code generation smoke test |
+| `cpp` / `c++` | `--target cpp` | C++ | cpp-httplib | Code generation + basic runtime smoke |
+| `c` | `--target c` | C | libmicrohttpd | Code generation + basic runtime smoke |
+| `csharp` / `cs` | `--target csharp` | C# | ASP.NET | Code generation smoke test |
+| `kotlin` / `kt` | `--target kotlin` | Kotlin | Ktor | Code generation smoke test |
+| `swift` | `--target swift` | Swift | Vapor | Code generation smoke test |
+| `dart` | `--target dart` | Dart | shelf | Code generation smoke test |
+| `php` | `--target php` | PHP | Built-in / Laravel | Code generation smoke test |
+| `ruby` / `rb` | `--target ruby` | Ruby | Sinatra | Code generation smoke test |
+
+NAIDE source files use the `.naide` extension. There is one language syntax; no separate compressed or AI-only dialect.
+
+#### What "supported target" means
+
+The table describes exactly what CI currently verifies: all 15 targets have automated code-generation smoke tests; Node.js, Python, Bun, Go, C, and C++ also run a minimal output program (C/C++ are compiled first). This does **not** guarantee that every generated program compiles or runs, or that every built-in feature has equivalent behavior. Backend feature coverage varies; review generated code and target-specific requirements before relying on it in production.
+
+The server-framework column identifies the backend's intended framework; it is not a promise that every NAIDE server feature is implemented for that target. Some backends emit TODO comments instead of working behavior—for example, the C backend's CRUD, authentication, and WebSocket paths, and the Rust backend's CRUD and WebSocket paths. Treat those generated sections as unsupported until the backend emits executable implementations and the corresponding integration tests pass.
 
 ## Install
 
@@ -42,6 +45,7 @@ npm install -g naider
 naide init my-app
 cd my-app
 npm install
+npm run check
 npm run dev
 ```
 
@@ -58,10 +62,31 @@ server app port 3000:
 naide app.naide
 ```
 
+### Japanese Learning Path
+
+1. **Values and variables** — `str` / `int` / `bool` declare values; add `mut` only when a value must change.
+2. **Decisions and repetition** — use `if` / `elif` / `else` and `each`.
+3. **Functions** — declare reusable behavior with `fn` and return with `ret`.
+4. **Applications** — start with a route, then add validation, authentication, and storage deliberately.
+
+```naide
+str name = "NAIDE"
+mut int visits = 0
+
+fn greet(str who) -> str:
+  ret "こんにちは、{who}さん"
+
+if visits == 0:
+  log greet(name)
+  visits += 1
+```
+
+Save as `lesson.naide`, then run `naide lesson.naide`. To inspect a project's local setup, use `naide doctor`; use `naide verify` to check its manifests without executing code. Each lesson should introduce one concept at a time—read the generated behavior and test your own small variation before adding features.
+
 ## CLI
 
 ```bash
-naide <file>                  # Run a .naide or .nx file
+naide <file.naide>             # Check and run a NAIDE file
 naide                         # Start interactive REPL
 naide repl                    # Start interactive REPL
 naide init [dir]              # Scaffold a new project
@@ -71,9 +96,13 @@ 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 doctor [dir]            # Diagnose local tools and project setup
+naide verify [dir]            # Validate manifests and type-check NAIDE sources
+naide test [dir]              # Run detected native test suites
 naide pkg init                # Create naide.pkg.json manifest
 naide pkg install <name>      # Install a NAIDE package
+naide pkg add <manager> <spec> # Install with a native package manager
+naide pkg managers            # List supported package ecosystems
 naide pkg publish             # Publish package to npm
 naide -w <file>               # Watch mode (auto-restart on changes)
 naide -d <file>               # Debug mode (Node.js inspector)
@@ -82,7 +111,6 @@ 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)
 naide --ast <file>            # Print AST
 naide --tokens <file>         # Print token stream
 ```
@@ -160,7 +188,7 @@ project.files.forEach(f => console.log(f.path));
 
 ```
 $ naide
-NAIDE REPL v1.21.0 — type NAIDE code, see JavaScript output
+NAIDE REPL v2.0.1 — type NAIDE code, see JavaScript output
 Type .exit to quit, .eval to toggle eval mode
 
 >>> str name = "hello"
@@ -178,7 +206,7 @@ Type `.eval` to switch to evaluation mode (runs the code instead of showing JS).
 
 ### Playground
 
-Open `playground/index.html` in a browser (via a local server) for a live in-browser transpiler with examples and token count comparison.
+Open `playground/index.html` in a browser (via a local server) for a live in-browser compiler with examples and source-size indicators.
 
 ### Benchmark
 
@@ -187,12 +215,13 @@ node benchmark/compare.js
 ```
 
 ```
-  Language     Tokens    Chars    Lines    Savings
-  JavaScript      330     2590     78    —
-  NAIDE            66      517     19    -80%
-  NAIDE-X          39      435     19    -88%
+  Source         Whitespace units   Chars   Lines
+  JavaScript                  330    2590      78
+  NAIDE                        66     517      19
 ```
 
+The benchmark's "whitespace units" are a rough source-size comparison, not model-token counts or evidence of faster generation.
+
 ## Language Reference
 
 ### Variables
@@ -1273,7 +1302,7 @@ db.sql "postgres" "postgresql://localhost/mydb"
 
 ## Language Server (LSP)
 
-Built-in LSP for editor integration — diagnostics, completions, and hover docs:
+Built-in LSP for editor integration — live syntax/type diagnostics, prefix-filtered completions, hover docs, document symbols, and definition/reference navigation across open `.naide` files:
 
 ```bash
 naide lsp
@@ -1285,7 +1314,7 @@ naide lsp
 naide vscode
 ```
 
-One command installs the extension — syntax highlighting, LSP diagnostics, autocomplete, and hover docs for `.naide` and `.nx` files. Restart VS Code after install.
+One command installs the extension — syntax highlighting, LSP diagnostics, autocomplete, hover docs, symbols, and definition/reference navigation for `.naide` files. Restart VS Code after install.
 
 ## Deploy
 
@@ -1321,7 +1350,7 @@ server app port 3000:
     ret {ok: true}
 ```
 
-Build all files with `naide build`, which compiles every `.naide`/`.nx` file to `.mjs`.
+Build all files with `naide build`, which compiles every `.naide` file to `.mjs`.
 
 ## Full Example
 
@@ -1412,65 +1441,23 @@ every "30m":
   log "cleanup"
 ```
 
-This generates a complete production API — SQLite database, AI/LLM integration, auth, password hashing, CORS, sessions, rate limiting, CRUD with pagination/search, WebSocket, SSE, file caching, request validation, background jobs, auto-generated API docs, route middleware, file downloads, redirects with status codes, type checking, error handling with ensure/finally, and event-driven hooks — from ~75 lines.
-
-## NAIDE-X Syntax (.nx)
-
-Every keyword is a single character. Line-start symbol = intent.
-
-```
-s:name="World"              -- str name = "World"
-i:count=42                  -- int count = 42
-~i:counter=0                -- mut int counter = 0
+This generates a broad API starter demonstrating SQLite, AI/LLM integration, auth, CORS, CRUD, WebSocket, SSE, file caching, request validation, background jobs, and more from ~75 lines. Treat it as a starting point: install the generated dependencies, inspect the emitted code, and perform your own security, load, and deployment reviews before production use.
 
-f greet(s:who)s             -- fn greet(str who) -> str:
-  >"Hello, {who}!"          --   ret "Hello, {who}!"
+## One syntax, end to end
 
-~f fetchData(s:url)a        -- fn.async fetchData(str url) -> any:
-  >~fetch(url)              --   ret await fetch(url)
+NAIDE has one source syntax for people and tools. Type inference and concise built-ins reduce ceremony; ordinary keywords keep control flow explicit:
 
-?count>5                    -- if count > 5:
-  log"many"                 --   log "many"
-|count>2                    -- elif count > 2:
-  log"some"                 --   log "some"
-:                           -- else:
-  log"few"                  --   log "few"
+```naide
+auto name = "World"
 
-@item<items                 -- each item in items:
-@i<0..10                    -- for i in 0..10:
-*active                     -- while active:
+fn greet(str who) -> str:
+  ret "Hello, {who}!"
 
-$app:3000                   -- server app port 3000:
-  G"/users"                 --   get "/users":
-    >users                  --     ret users
-  P"/users"(req,res)        --   post "/users" (req, res):
-    >req.body               --     ret req.body
+if name:
+  log greet(name)
 ```
 
-### NAIDE-X Cheat Sheet
-
-| Symbol | Meaning | Symbol | Meaning |
-|--------|---------|--------|---------|
-| `>` | return | `?` | if |
-| `\|` | elif | `:` | else |
-| `@` | loop | `*` | while |
-| `!` | try | `!!` | catch |
-| `!!!` | ensure/finally | `>.d` | ret.download |
-| `$` | server | `^` | model |
-| `<` | import | `%` | match |
-| `f` | function | `~f` | async function |
-| `+` | export | `~` | await |
-| `G` | GET | `P` | POST |
-| `U` | PUT | `D` | DELETE |
-| `X` | PATCH | `>.s` | ret.status |
-| `>.r` | ret.redirect | `>.h` | ret.html |
-| `>.t` | ret.text | `>.v` | ret.render |
-
-Types: `s`=str `i`=int `n`=num `b`=bool `l`=list `m`=map `a`=any
-
-High-level keywords work in both modes: `schema`, `crud`, `auth`, `cors`, `limit`, `env`, `every`, `watch`, `static`, `ws`, `db`, `db.sql`, `group`, `cookie`, `error`, `session`, `upload`, `view`, `sse`, `cache`, `patch`, `validate`, `test`, `assert`, `queue`, `openapi`, `typeof`, `instanceof`, `ensure`, `ai`, `prompt`, `bot`, `slash`.
-
-NAIDE-X log shorthands: `log.e` = error, `log.w` = warn, `log.i` = info, `log.d` = debug.
+New projects, generated examples, editor tooling, and compiler input all use `.naide`. There is no separate symbolic or AI-only form to learn.
 
 ## Plugin System
 
@@ -1489,15 +1476,6 @@ 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:
@@ -1509,7 +1487,7 @@ Error in app.naide:12
 >>12 |     throw "not found"
 ```
 
-The CLI tracks source-to-output line mappings and shows context from your `.naide`/`.nx` file, not the generated JavaScript.
+The CLI tracks source-to-output line mappings and shows context from your `.naide` file, not the generated JavaScript.
 
 ## Native Dependency Detection
 
@@ -1534,7 +1512,7 @@ Catches type mismatches at compile time:
   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.
+The type checker checks supported annotations (`str`, `int`, `num`, `bool`, `list`, `map`), known function argument counts and types, return expressions against explicit annotations, and straightforward assignments. `num` accepts `int` values. `any` and `json` accept all types. Expressions whose types cannot be determined (including many dynamic member accesses) are treated as `any`, so passing `naide check` is useful feedback, **not a proof of program correctness or runtime safety**.
 
 Also available as a flag: `naide --check app.naide` or programmatically via `compile(source, { typeCheck: true })`.
 
@@ -1563,18 +1541,61 @@ 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
+## Project Diagnostics
+
+```bash
+naide doctor                    # inspect Node.js and installed language tools
+naide doctor . --json           # machine-readable report
+naide verify                    # validate package manifests and find setup gaps
+```
 
-Manage NAIDE packages via npm:
+`doctor` checks the local Node.js requirement, available ecosystem tools, package manifests, and NAIDE source files. `verify` parses `package.json`, checks its dependency and script sections, and compiles and type-checks `.naide` files recursively, excluding `.git`, `dist`, `node_modules`, and the root `SPEC.naide` language reference. It is read-only and does not execute package scripts or source code; it is a setup/type-check aid, not a security audit or a guarantee that dependencies resolve or the application behaves correctly. Other ecosystem manifests are detected but are not fully validated. `test` is a separate, explicit command: it detects common native test setups (npm, Cargo, Go, .NET, Maven/Gradle, SwiftPM, Dart, Composer, Bundler, and pytest) and runs their configured test commands. Since project tests are executable code, run this only in a project you trust.
+
+## Native Package Ecosystems
+
+NAIDE can ask the native package manager to install dependencies from several registries:
 
 ```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
+naide pkg managers
+naide pkg add npm zod@3.24.0
+python -m venv .venv
+# Activate .venv before installing Python packages
+naide pkg add pip requests==2.32.0
+naide pkg add cargo serde@1.0.0
+naide pkg add go github.com/google/uuid@v1.6.0
+naide pkg add dotnet Newtonsoft.Json@13.0.1
+naide pkg add composer symfony/console:^7.0
+naide pkg add gem rails@7.1.0
+naide pkg add dart 'http:^1.2.0'
+naide pkg add maven org.slf4j:slf4j-api:2.0.16
+naide pkg add conan fmt/11.0.2
+```
+
+Supported adapters are npm, PyPI/pip, Cargo, Go modules, NuGet/.NET, Packagist/Composer, RubyGems via Bundler, pub.dev, Maven Central, and Conan. Arguments are passed separately; on Windows, script-based manager shims use a quoted `cmd.exe` wrapper, and arguments containing quotes, percent signs, or line breaks are rejected. npm, pip, Cargo, Go, .NET, Composer, Bundler, and Dart delegate dependency declaration and lockfile updates to their native tools (where that ecosystem supports lockfiles). pip installs into an active/project `.venv`, records its requirement in `requirements.txt`, and records the ecosystem dependency in `naide.pkg.json`; activate a virtual environment before installing. Metadata files are staged before replacement, and failed multi-file updates are rolled back where possible. Every successful `naide pkg add` creates or updates `naide.pkg.json` as NAIDE's cross-ecosystem index, while native project manifests remain authoritative.
+
+This is package-manager interoperability, **not** automatic cross-language linking. A Python, Rust, Java, or other native library cannot be called directly from NAIDE just because it is installed. To use one from a Node.js NAIDE program, expose a deliberate boundary such as a subprocess protocol, HTTP service, or a maintained FFI/WASM adapter. The Ruby adapter uses `bundle add`, so a Gemfile must already exist. Maven downloads to the local cache, and Conan resolves/generates dependency metadata; both still require their respective build-file/toolchain integration before the dependency is usable by an application. SwiftPM, Gradle, and other ecosystems without a tested adapter can still be used through their normal native tools.
+
+`naide.pkg.json` stores NAIDE package metadata and records non-npm additions under `languageDependencies`; the native manager's manifest and lockfile remain authoritative. `naide pkg install` remains the npm convenience command for NAIDE plugins.
+
+## MCP Server
+
+`naide-mcp` communicates over stdio and provides tools for compilation/generation, non-executing `naide_check` diagnostics, project verification and tests, package ecosystem guidance, and the language specification. The `verify_changes` prompt (also available in Japanese) guides agents to check changed source and the project without running code. It also exposes read-only resources (`naide://spec`, `naide://package-ecosystems`, `naide://project`).
+
+For VS Code, after installing `naider` in a location on `PATH`, add this to `.vscode/mcp.json`:
+
+```json
+{
+  "servers": {
+    "naide": {
+      "type": "stdio",
+      "command": "naide-mcp",
+      "args": []
+    }
+  }
+}
 ```
 
-The `naide.pkg.json` manifest tracks NAIDE-specific metadata (main entry, exports, dependencies) while using npm as the underlying registry.
+The MCP server's `naide_run` and `naide_test` tools execute code with the server process's operating-system permissions. Connect it only to clients and workspaces whose code you trust.
 
 ## NAIDE vs Python — Side by Side
 
@@ -1648,14 +1669,14 @@ server app port 3000:
 
 ## Why NAIDE?
 
-AI code generation speed depends on:
+An approachable language should reduce incidental complexity without obscuring program behavior:
 
-1. **Token count** — fewer output tokens = faster generation
-2. **Predictability** — one way to write everything = better next-token prediction
-3. **Context window** — shorter code = more room for complex projects
-4. **Simplicity** — built-in functions mean zero imports and less boilerplate
+1. **One syntax** — no human-only and machine-only dialects to keep in sync
+2. **Direct feedback** — type checks, tests, and source-mapped diagnostics help find mistakes
+3. **Useful defaults** — common application patterns need less setup
+4. **Escape hatches** — generated code and ordinary packages remain inspectable and usable
 
-NAIDE-X is designed as an **AI-internal representation** — the AI thinks in NAIDE-X, users receive standard JavaScript.
+NAIDE aims to make one readable source representation work well for both people and AI tools. Generated code and compiler diagnostics remain inspectable rather than treating the source as an opaque prompt format.
 
 ## License
 

package/SPEC.naide

@@ -2,14 +2,16 @@
 # NAIDE Language Specification
 # Node AI Development Environment
 # ============================================
-# AIが最速でコード生成できるように設計された言語
+# 人間とAIが同じ構文を読み書きできる、実用的なプログラミング言語
 #
 # 設計原則:
-#   1. 1つの書き方しかない (曖昧さゼロ)
-#   2. キーワード駆動 (行頭で意図が確定)
-#   3. 最小トークン数 (生成量削減 = 高速)
-#   4. よく使うパターンが組み込み
-#   5. インデントベース (波括弧不要)
+#   1. 構文はひとつ。人間・AI・ツールで異なる方言を持たない
+#   2. 短さは記号暗記ではなく、型推論と明快な標準機能で実現する
+#   3. 制御フロー・非同期・失敗の扱いはコードから読み取れる
+#   4. よく使う仕事を支援しつつ、暗黙の副作用を増やさない
+#   5. 型検査・診断・テストで、実行前に誤りを見つけやすくする
+#   6. コンパイラの出力と実行時の挙動を追跡できるようにする
+#   7. 新機能は構文の一貫性、保守性、ターゲット間の意味保存を満たしてから追加
 # ============================================