arc-lang 0.6.3 → 0.6.4

package/README.md

@@ -1,148 +1,83 @@
-# Arc ⚡
+# Arc Compiler ⚡
 
-**A programming language designed by AI agents, for AI agents.**
+The compiler/interpreter implementation for the [Arc programming language](https://github.com/kai-builds-ai/arc-lang).
 
-Arc is a modern programming language optimized for AI-driven development, achieving **50%+ cost and efficiency savings** through intelligent syntax design, implicit context handling, and token-optimized semantics.
+## Architecture
 
-## Quick Start
-
-```bash
-# Clone and install
-git clone https://github.com/kai-builds-ai/arc-lang.git
-cd arc-lang/compiler && npm install && cd ..
-
-# Run an example
-npx tsx compiler/src/index.ts run examples/hello-world.arc
-
-# Start the REPL
-npx tsx compiler/src/index.ts repl
 ```
-
-**See the [Getting Started Guide](docs/getting-started.md) for a full tutorial.**
-
-## Why Arc?
-
-Traditional programming languages were designed for humans. Arc is designed for the way AI agents think and work:
-
-- **Token-efficient syntax** - Every character counts when you're paying per token
-- **Implicit context** - Agents understand intent, reduce boilerplate
-- **Pattern-first semantics** - Match patterns instead of verbose conditionals
-- **Native async** - Concurrency is built-in, not an afterthought
-- **First-class tool calls** - APIs and tools are native primitives
-- **Semantic types** - Types based on meaning, not structure
-
-## Philosophy
-
-**Less is more.** Arc eliminates ceremony, boilerplate, and redundancy while maintaining clarity and expressiveness.
-
-See [PHILOSOPHY.md](./PHILOSOPHY.md) for detailed design principles.
-
-## What It Looks Like
-
-```arc
-# AI agent that fetches data, analyzes it, and acts
-let [weather, news] = fetch [
-  @GET "api/weather?city=NYC",
-  @GET "api/news/top?limit=3"
-]
-
-let headlines = news.articles
-  |> take(3)
-  |> map(a => "• {a.title}")
-  |> join("\n")
-
-let advice = match weather.condition {
-  "rain" | "storm" => "Bring an umbrella!",
-  "snow" => "Bundle up!",
-  _ => "Enjoy the weather!"
-}
-
-print("{advice}\n\nTop News:\n{headlines}")
+src/
+├── index.ts           # CLI entry point
+├── lexer.ts           # Tokenizer
+├── parser.ts          # Parser → AST
+├── ast.ts             # AST node types
+├── interpreter.ts     # Tree-walking interpreter
+├── modules.ts         # Module resolver & loader
+├── ir.ts              # Intermediate representation
+├── optimizer.ts       # IR optimizer
+├── codegen.ts         # WAT code generation
+├── codegen-js.ts      # JavaScript code generation
+├── semantic.ts        # Semantic analysis
+├── typechecker.ts     # Type checker
+├── formatter.ts       # Code formatter
+├── linter.ts          # Linter
+├── errors.ts          # Error types & pretty printing
+├── security.ts        # Security sandbox
+├── repl.ts            # Interactive REPL
+├── build.ts           # Build system & project scaffolding
+├── package-manager.ts # Package manager
+├── lsp.ts             # Language Server Protocol
+└── version.ts         # Version info
 ```
 
-**~55 tokens in Arc vs ~120 in JavaScript.** See [examples/](examples/) for more.
-
-## Standard Library
-
-Arc ships with a growing standard library. Currently implemented:
+## Development
 
-| Module | Description |
-|--------|-------------|
-| [`math`](stdlib/math.arc) | Constants (PI, E), abs, pow, sqrt, ceil, floor, clamp |
-| [`strings`](stdlib/strings.arc) | pad_left, pad_right, capitalize, words |
-| [`collections`](stdlib/collections.arc) | set, unique, group_by, chunk, flatten, zip_with, partition, sort_by |
-| [`map`](stdlib/map.arc) | merge, map_values, filter_map, from_pairs, pick, omit |
-| [`io`](stdlib/io.arc) | read_lines, write_lines, exists, append |
-| [`http`](stdlib/http.arc) | get, post, put, delete, fetch_all, parse_url |
-| [`json`](stdlib/json.arc) | to_json, from_json, pretty, get_path |
-| [`csv`](stdlib/csv.arc) | parse_csv, to_csv, parse_csv_headers |
-| [`test`](stdlib/test.arc) | describe, it, expect_eq, expect_true, run_tests |
-| [`result`](stdlib/result.arc) | ok, err, is_ok, unwrap, map_result, try_fn |
-| [`time`](stdlib/time.arc) | now, format_duration, sleep |
-
-Plus many built-in functions available without imports: `map`, `filter`, `reduce`, `print`, `len`, `split`, `join`, `trim`, and more.
-
-📖 **[Standard Library Reference](docs/stdlib-reference.md)** | **[Standard Library Tutorial](docs/stdlib-tutorial.md)**
-
-## Documentation
-
-- **[Getting Started](docs/getting-started.md)** — Installation, first program, REPL, basics
-- **[Language Tour](docs/language-tour.md)** — Complete feature walkthrough
-- **[Standard Library Reference](docs/stdlib-reference.md)** — Full stdlib API reference
-- **[Standard Library Tutorial](docs/stdlib-tutorial.md)** — Hands-on stdlib guide
-- **[Examples](examples/)** — Real-world programs with token comparisons
-- **[FAQ](docs/FAQ.md)** — Common questions answered
-- **[Grammar Spec](spec/grammar.md)** — Formal language specification
-
-## Status
-
-🚀 **In Active Development** — Arc has a working compiler (lexer, parser, IR, optimizer, JS/WAT codegen), interpreter, REPL, 17 stdlib modules, LSP, VS Code extension, package manager, build system, formatter, linter, security sandbox, rich error reporting, benchmarking framework, and migration tools. 508+ tests passing.
-
-Current phase: **Phase 6 — Community & Adoption**
+```bash
+# Install dependencies
+npm install
 
-See [ROADMAP.md](./ROADMAP.md) for development timeline.
+# Build (TypeScript → JavaScript)
+npm run build
 
-## Project Structure
+# Run directly from source
+npx tsx src/index.ts run ../examples/hello-world.arc
 
-```
-arc-lang/
-├── README.md          # You are here
-├── PHILOSOPHY.md      # Design principles & rationale
-├── ROADMAP.md         # Development phases & milestones
-├── LICENSE            # MIT License
-├── docs/              # Comprehensive documentation
-├── spec/              # Formal language specification
-├── examples/          # Code samples & tutorials
-├── compiler/          # Compiler/interpreter implementation
-├── stdlib/            # Standard library
-└── CONTRIBUTING.md    # Contribution guidelines
+# Run with compiled output
+node dist/index.js run ../examples/hello-world.arc
 ```
 
-## Contributing
+## CLI Commands
 
-Arc is a collaborative project open to all AI agents and human developers. We welcome contributions from:
-
-- AI agents on Moltbook
-- Developers interested in language design
-- Anyone passionate about efficient, elegant code
-
-See [CONTRIBUTING.md](./CONTRIBUTING.md) for guidelines.
-
-## Community
-
-- **Website:** [arclang.dev](https://arclang.dev)
-- **Moltbook:** Follow [@kai_builds_ai](https://moltbook.com/u/kai_builds_ai) for updates every 6 hours
-- **GitHub:** Star, watch, and contribute to this repository
-- **Issues:** Use GitHub Issues for bugs, features, and discussions
-
-## License
+```bash
+arc run <file>           # Execute an Arc file
+arc repl                 # Interactive REPL
+arc parse <file>         # Print AST
+arc ir <file>            # Print IR
+arc compile <file>       # Compile to JS (or --target=wat)
+arc check <file>         # Semantic analysis
+arc fmt <file>           # Format code (--write to overwrite)
+arc lint <file>          # Lint code
+arc builtins             # List all built-in functions
+arc builtins --modules   # List stdlib modules
+arc build                # Build project
+arc test                 # Run project tests
+arc new <name>           # Scaffold new project
+arc version              # Print version
+```
 
-MIT License - See [LICENSE](./LICENSE) for details.
+## Publishing
 
-## Credits
+```bash
+npm run copy-stdlib   # Copy stdlib into compiler package
+npm run build         # Compile TypeScript
+npm publish           # Publish to npm
+```
 
-Created by **Kai** (@kai_builds_ai) with collaboration from AI agents and human developers worldwide.
+The `prepublishOnly` script handles `copy-stdlib` and `build` automatically.
 
----
+## See Also
 
-*"Code should be as simple as possible, but no simpler." - Arc Philosophy*
+- [Language documentation](../docs/)
+- [Standard library](../stdlib/)
+- [Examples](../examples/)
+- [Architecture details](ARCHITECTURE.md)
+- [Design decisions](DESIGN_DECISIONS.md)

package/dist/formatter.js

@@ -150,7 +150,7 @@ export function format(source, options) {
                     else {
                         elInline = formatBlockExpr(expr.else_, depth);
                     }
-                    const single = `if ${cond} ${thenInline} el ${elInline}`;
+                    const single = `if ${cond} ${thenInline} else ${elInline}`;
                     if (single.length + depth * opts.indentSize <= opts.maxLineLength) {
                         return single;
                     }
@@ -159,12 +159,12 @@ export function format(source, options) {
                         ? formatBlockMultiline(expr.then, depth)
                         : thenInline;
                     if (expr.else_.kind === "IfExpr") {
-                        return `if ${cond} ${thenMulti} el ${formatExpr(expr.else_, depth)}`;
+                        return `if ${cond} ${thenMulti} else ${formatExpr(expr.else_, depth)}`;
                     }
                     const elMulti = expr.else_.kind === "BlockExpr"
                         ? formatBlockMultiline(expr.else_, depth)
                         : elInline;
-                    return `if ${cond} ${thenMulti} el ${elMulti}`;
+                    return `if ${cond} ${thenMulti} else ${elMulti}`;
                 }
                 const single = `if ${cond} ${thenInline}`;
                 if (single.length + depth * opts.indentSize <= opts.maxLineLength) {
@@ -240,6 +240,8 @@ export function format(source, options) {
             case "SpreadExpr": return `...${formatExpr(expr.expr, depth)}`;
             case "OptionalMemberExpr": return `${formatExpr(expr.object, depth)}?.${expr.property}`;
             case "TryExpr": return `${formatExpr(expr.expr, depth)}?`;
+            case "TryCatchExpr":
+                return `try ${formatBlockExpr(expr.body, depth)} catch ${expr.catchVar} ${formatBlockExpr(expr.catchBody, depth)}`;
             default: return `/* unknown */`;
         }
     }
@@ -347,6 +349,16 @@ export function format(source, options) {
                 const pub = stmt.pub ? "pub " : "";
                 return `${pub}type ${stmt.name} = ${formatTypeExpr(stmt.def)}`;
             }
+            case "RetStmt":
+                return stmt.value ? `return ${formatExpr(stmt.value, depth)}` : "return";
+            case "WhileStmt":
+                return `while ${formatExpr(stmt.condition, depth)} ${formatBlockExpr(stmt.body, depth)}`;
+            case "BreakStmt":
+                return "break";
+            case "ContinueStmt":
+                return "continue";
+            case "TryCatchStmt":
+                return `try ${formatBlockExpr(stmt.body, depth)} catch ${stmt.catchVar} ${formatBlockExpr(stmt.catchBody, depth)}`;
             case "AssignStmt":
                 return `${stmt.target} = ${formatExpr(stmt.value, depth)}`;
             case "MemberAssignStmt":

package/dist/interpreter.js

@@ -126,7 +126,7 @@ function syncFetch(method, url, body) {
     const bodyJson = bodyStr != null ? JSON.stringify(bodyStr) : "null";
     // Pass config via env to avoid shell escaping issues
     const fetchConfig = JSON.stringify({ method, url, body: bodyStr, headers: customHeaders });
-    const script = `const c=JSON.parse(process.env.ARC_FETCH);(async()=>{const o={method:c.method,headers:{...c.headers}};if(c.body!==null){o.body=c.body;if(!o.headers["Content-Type"])o.headers["Content-Type"]="application/json";}try{const r=await fetch(c.url,o);const t=await r.text();let d;try{d=JSON.parse(t)}catch{d=t}console.log(JSON.stringify({ok:true,status:r.status,data:d}))}catch(e){console.log(JSON.stringify({ok:false,status:0,data:e.message}))}})()`;
+    const script = `const c=JSON.parse(process.env.ARC_FETCH);(async()=>{const o={method:c.method,headers:{...c.headers}};if(c.body!==null){o.body=c.body;if(!o.headers["Content-Type"])o.headers["Content-Type"]="application/json";}try{const r=await fetch(c.url,o);const t=await r.text();let d;try{d=JSON.parse(t)}catch{d=t}console.log(JSON.stringify({ok:r.status>=200&&r.status<300,status:r.status,data:d}))}catch(e){console.log(JSON.stringify({ok:false,status:0,data:e.message}))}})()`;
     try {
         const raw = execSync(`node -e "${script.replace(/"/g, '\\"')}"`, {
             timeout: 30000,

package/dist/linter.js

@@ -343,6 +343,24 @@ export function lint(source, options) {
                 }
                 break;
             }
+            case "WhileStmt":
+                analyzeExpr(stmt.condition, scope);
+                analyzeExpr(stmt.body, scope);
+                if (stmt.body.kind === "BlockExpr" && stmt.body.stmts.length === 0) {
+                    warn("empty-block", "While loop has an empty body", stmt.loc);
+                }
+                break;
+            case "BreakStmt":
+            case "ContinueStmt":
+                break;
+            case "TryCatchStmt":
+                analyzeExpr(stmt.body, scope);
+                analyzeExpr(stmt.catchBody, scope);
+                break;
+            case "RetStmt":
+                if (stmt.value)
+                    analyzeExpr(stmt.value, scope);
+                break;
             case "DoStmt":
                 analyzeExpr(stmt.body, scope);
                 analyzeExpr(stmt.condition, scope);

package/dist/parser.js

@@ -703,6 +703,25 @@ export class Parser {
             const body = this.parseBlock();
             return { kind: "AsyncExpr", body, loc };
         }
+        // Anonymous function expression: fn(params) { body } or fn(params) => expr
+        if (t.type === TokenType.Fn) {
+            this.advance();
+            this.expect(TokenType.LParen);
+            const params = [];
+            while (!this.at(TokenType.RParen)) {
+                params.push(this.expect(TokenType.Ident).value);
+                if (this.at(TokenType.Comma))
+                    this.advance();
+            }
+            this.expect(TokenType.RParen);
+            if (this.at(TokenType.FatArrow)) {
+                this.advance();
+                const body = this.parseExpr();
+                return { kind: "LambdaExpr", params, body, loc };
+            }
+            const body = this.parseBlock();
+            return { kind: "LambdaExpr", params, body, loc };
+        }
         // Try/catch expression: try { body } catch e { handler }
         if (t.type === TokenType.Try) {
             this.advance();

package/dist/repl.js

@@ -90,6 +90,9 @@ function execute(source) {
     }
     catch (e) {
         console.log(`${RED}Error: ${e.message}${RESET}`);
+        if (e.suggestion) {
+            console.log(`${YELLOW}hint${RESET}: ${e.suggestion}`);
+        }
     }
 }
 function main() {
@@ -98,7 +101,7 @@ function main() {
         output: process.stdout,
         prompt: "arc> ",
     });
-    console.log(`${CYAN}Arc REPL v0.6.3${RESET} — Type ${YELLOW}:help${RESET} for commands, ${YELLOW}:builtins${RESET} for functions`);
+    console.log(`${CYAN}Arc REPL v0.6.4${RESET} — Type ${YELLOW}:help${RESET} for commands, ${YELLOW}:builtins${RESET} for functions`);
     rl.prompt();
     let buffer = "";
     let braceDepth = 0;

package/dist/version.d.ts

@@ -1,4 +1,4 @@
-export declare const ARC_VERSION = "0.6.3";
+export declare const ARC_VERSION = "0.6.4";
 export declare const ARC_BUILD_DATE: string;
 export declare const ARC_PLATFORM: string;
 /** Print version info */

package/dist/version.js

@@ -1,5 +1,5 @@
 // Arc Version System
-export const ARC_VERSION = "0.6.3";
+export const ARC_VERSION = "0.6.4";
 export const ARC_BUILD_DATE = new Date().toISOString().split("T")[0];
 export const ARC_PLATFORM = `${process.platform}-${process.arch}`;
 /** Print version info */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arc-lang",
-  "version": "0.6.3",
+  "version": "0.6.4",
   "description": "Arc ⚡ — A programming language designed by AI agents, for AI agents. 27-63% fewer tokens than JavaScript.",
   "type": "module",
   "bin": {