arc-lang 0.5.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kai (@kai_builds_ai) and Arc Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,148 @@
+# Arc ⚡
+
+**A programming language designed by AI agents, for AI agents.**
+
+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.
+
+## 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}")
+```
+
+**~55 tokens in Arc vs ~120 in JavaScript.** See [examples/](examples/) for more.
+
+## Standard Library
+
+Arc ships with a growing standard library. Currently implemented:
+
+| 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, 11 stdlib modules, LSP, VS Code extension, package manager, build system, formatter, linter, security sandbox, rich error reporting, benchmarking framework, and migration tools. 504+ tests passing.
+
+Current phase: **Phase 6 — Community & Adoption**
+
+See [ROADMAP.md](./ROADMAP.md) for development timeline.
+
+## Project Structure
+
+```
+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
+```
+
+## Contributing
+
+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
+
+MIT License - See [LICENSE](./LICENSE) for details.
+
+## Credits
+
+Created by **Kai** (@kai_builds_ai) with collaboration from AI agents and human developers worldwide.
+
+---
+
+*"Code should be as simple as possible, but no simpler." - Arc Philosophy*

package/dist/ast.d.ts

@@ -0,0 +1,298 @@
+export interface Loc {
+    line: number;
+    col: number;
+}
+export type Expr = IntLiteral | FloatLiteral | BoolLiteral | NilLiteral | StringLiteral | StringInterp | Identifier | BinaryExpr | UnaryExpr | CallExpr | MemberExpr | IndexExpr | PipelineExpr | IfExpr | MatchExpr | LambdaExpr | ListLiteral | MapLiteral | ListComprehension | ToolCallExpr | RangeExpr | BlockExpr | AsyncExpr | AwaitExpr | FetchExpr;
+export interface IntLiteral {
+    kind: "IntLiteral";
+    value: number;
+    loc: Loc;
+}
+export interface FloatLiteral {
+    kind: "FloatLiteral";
+    value: number;
+    loc: Loc;
+}
+export interface BoolLiteral {
+    kind: "BoolLiteral";
+    value: boolean;
+    loc: Loc;
+}
+export interface NilLiteral {
+    kind: "NilLiteral";
+    loc: Loc;
+}
+export interface StringLiteral {
+    kind: "StringLiteral";
+    value: string;
+    loc: Loc;
+}
+export interface StringInterp {
+    kind: "StringInterp";
+    parts: (string | Expr)[];
+    loc: Loc;
+}
+export interface Identifier {
+    kind: "Identifier";
+    name: string;
+    loc: Loc;
+}
+export interface BinaryExpr {
+    kind: "BinaryExpr";
+    op: string;
+    left: Expr;
+    right: Expr;
+    loc: Loc;
+}
+export interface UnaryExpr {
+    kind: "UnaryExpr";
+    op: string;
+    operand: Expr;
+    loc: Loc;
+}
+export interface CallExpr {
+    kind: "CallExpr";
+    callee: Expr;
+    args: Expr[];
+    loc: Loc;
+}
+export interface MemberExpr {
+    kind: "MemberExpr";
+    object: Expr;
+    property: string;
+    loc: Loc;
+}
+export interface IndexExpr {
+    kind: "IndexExpr";
+    object: Expr;
+    index: Expr;
+    loc: Loc;
+}
+export interface PipelineExpr {
+    kind: "PipelineExpr";
+    left: Expr;
+    right: Expr;
+    loc: Loc;
+}
+export interface IfExpr {
+    kind: "IfExpr";
+    condition: Expr;
+    then: Expr;
+    else_?: Expr;
+    loc: Loc;
+}
+export interface MatchExpr {
+    kind: "MatchExpr";
+    subject: Expr;
+    arms: MatchArm[];
+    loc: Loc;
+}
+export interface MatchArm {
+    pattern: Pattern;
+    guard?: Expr;
+    body: Expr;
+}
+export interface LambdaExpr {
+    kind: "LambdaExpr";
+    params: string[];
+    body: Expr;
+    loc: Loc;
+}
+export interface ListLiteral {
+    kind: "ListLiteral";
+    elements: Expr[];
+    loc: Loc;
+}
+export interface MapLiteral {
+    kind: "MapLiteral";
+    entries: {
+        key: string | Expr;
+        value: Expr;
+    }[];
+    loc: Loc;
+}
+export interface ListComprehension {
+    kind: "ListComprehension";
+    expr: Expr;
+    variable: string;
+    iterable: Expr;
+    filter?: Expr;
+    loc: Loc;
+}
+export interface ToolCallExpr {
+    kind: "ToolCallExpr";
+    method: string;
+    arg: Expr;
+    body?: Expr;
+    loc: Loc;
+}
+export interface RangeExpr {
+    kind: "RangeExpr";
+    start: Expr;
+    end: Expr;
+    loc: Loc;
+}
+export interface BlockExpr {
+    kind: "BlockExpr";
+    stmts: Stmt[];
+    loc: Loc;
+}
+export interface AsyncExpr {
+    kind: "AsyncExpr";
+    body: Expr;
+    loc: Loc;
+}
+export interface AwaitExpr {
+    kind: "AwaitExpr";
+    expr: Expr;
+    loc: Loc;
+}
+export interface FetchExpr {
+    kind: "FetchExpr";
+    targets: Expr[];
+    loc: Loc;
+}
+export type Pattern = WildcardPattern | LiteralPattern | BindingPattern | ArrayPattern | OrPattern;
+export interface WildcardPattern {
+    kind: "WildcardPattern";
+    loc: Loc;
+}
+export interface LiteralPattern {
+    kind: "LiteralPattern";
+    value: number | string | boolean | null;
+    loc: Loc;
+}
+export interface BindingPattern {
+    kind: "BindingPattern";
+    name: string;
+    loc: Loc;
+}
+export interface ArrayPattern {
+    kind: "ArrayPattern";
+    elements: Pattern[];
+    loc: Loc;
+}
+export interface OrPattern {
+    kind: "OrPattern";
+    patterns: Pattern[];
+    loc: Loc;
+}
+export type Stmt = LetStmt | FnStmt | ForStmt | DoStmt | ExprStmt | UseStmt | TypeStmt | AssignStmt | MemberAssignStmt | IndexAssignStmt;
+export interface AssignStmt {
+    kind: "AssignStmt";
+    target: string;
+    value: Expr;
+    loc: Loc;
+}
+export interface MemberAssignStmt {
+    kind: "MemberAssignStmt";
+    object: Expr;
+    property: string;
+    value: Expr;
+    loc: Loc;
+}
+export interface IndexAssignStmt {
+    kind: "IndexAssignStmt";
+    object: Expr;
+    index: Expr;
+    value: Expr;
+    loc: Loc;
+}
+export interface LetStmt {
+    kind: "LetStmt";
+    name: string | DestructureTarget;
+    mutable: boolean;
+    pub: boolean;
+    value: Expr;
+    loc: Loc;
+}
+export interface DestructureTarget {
+    kind: "DestructureTarget";
+    type: "object" | "array";
+    names: string[];
+}
+export interface FnStmt {
+    kind: "FnStmt";
+    name: string;
+    params: string[];
+    body: Expr;
+    isAsync: boolean;
+    pub: boolean;
+    loc: Loc;
+}
+export interface ForStmt {
+    kind: "ForStmt";
+    variable: string;
+    iterable: Expr;
+    body: Expr;
+    loc: Loc;
+}
+export interface DoStmt {
+    kind: "DoStmt";
+    body: Expr;
+    condition: Expr;
+    isWhile: boolean;
+    loc: Loc;
+}
+export interface ExprStmt {
+    kind: "ExprStmt";
+    expr: Expr;
+    loc: Loc;
+}
+export interface UseStmt {
+    kind: "UseStmt";
+    path: string[];
+    imports?: string[];
+    wildcard?: boolean;
+    loc: Loc;
+}
+export interface TypeStmt {
+    kind: "TypeStmt";
+    name: string;
+    pub: boolean;
+    def: TypeExpr;
+    loc: Loc;
+}
+export type TypeExpr = NamedType | RecordType | UnionType | FunctionType | ConstrainedType | EnumType | GenericType;
+export interface NamedType {
+    kind: "NamedType";
+    name: string;
+}
+export interface RecordType {
+    kind: "RecordType";
+    fields: {
+        name: string;
+        type: TypeExpr;
+    }[];
+}
+export interface UnionType {
+    kind: "UnionType";
+    variants: TypeExpr[];
+}
+export interface FunctionType {
+    kind: "FunctionType";
+    params: TypeExpr[];
+    ret: TypeExpr;
+}
+export interface ConstrainedType {
+    kind: "ConstrainedType";
+    base: TypeExpr;
+    constraint: "where" | "matching";
+    predicate: Expr;
+}
+export interface EnumType {
+    kind: "EnumType";
+    variants: {
+        name: string;
+        params?: TypeExpr[];
+    }[];
+}
+export interface GenericType {
+    kind: "GenericType";
+    name: string;
+    params: TypeExpr[];
+}
+export interface Program {
+    kind: "Program";
+    stmts: Stmt[];
+}

package/dist/ast.js

@@ -0,0 +1,2 @@
+// AST Node Types for Arc Language
+export {};

package/dist/build.d.ts

@@ -0,0 +1,7 @@
+export declare function build(options?: {
+    target?: string;
+    dir?: string;
+}): void;
+export declare function run(file?: string, dir?: string): void;
+export declare function test(dir?: string): void;
+export declare function newProject(name: string, parentDir?: string): void;

package/dist/build.js

@@ -0,0 +1,138 @@
+// Arc Build System
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, statSync } from "fs";
+import { resolve, relative, join } from "path";
+import { lex } from "./lexer.js";
+import { parse } from "./parser.js";
+import { generateIR } from "./ir.js";
+import { generateJS } from "./codegen-js.js";
+import { generateWAT } from "./codegen.js";
+import { interpret } from "./interpreter.js";
+import { createUseHandler } from "./modules.js";
+import { readToml, serializeArcToml } from "./package-manager.js";
+export function build(options = {}) {
+    const dir = options.dir || process.cwd();
+    const target = options.target || "js";
+    let toml;
+    try {
+        toml = readToml(dir);
+    }
+    catch {
+        console.error("No arc.toml found. Run 'arc pkg init' first.");
+        process.exit(1);
+    }
+    // Find entry point
+    const entryPoint = resolve(dir, "src", "main.arc");
+    if (!existsSync(entryPoint)) {
+        console.error("Entry point not found: src/main.arc");
+        process.exit(1);
+    }
+    const source = readFileSync(entryPoint, "utf-8");
+    const tokens = lex(source);
+    const ast = parse(tokens);
+    const ir = generateIR(ast);
+    const distDir = resolve(dir, "dist");
+    if (!existsSync(distDir)) {
+        mkdirSync(distDir, { recursive: true });
+    }
+    if (target === "wat") {
+        const wat = generateWAT(ir);
+        const outPath = resolve(distDir, `${toml.package.name}.wat`);
+        writeFileSync(outPath, wat);
+        console.log(`Built ${relative(dir, outPath)}`);
+    }
+    else {
+        const js = generateJS(ir);
+        const outPath = resolve(distDir, `${toml.package.name}.js`);
+        writeFileSync(outPath, js);
+        console.log(`Built ${relative(dir, outPath)}`);
+    }
+}
+export function run(file, dir) {
+    const d = dir || process.cwd();
+    let filePath;
+    if (file) {
+        filePath = resolve(d, file);
+    }
+    else {
+        // Use project entry point
+        filePath = resolve(d, "src", "main.arc");
+    }
+    if (!existsSync(filePath)) {
+        console.error(`File not found: ${filePath}`);
+        process.exit(1);
+    }
+    const source = readFileSync(filePath, "utf-8");
+    const tokens = lex(source);
+    const ast = parse(tokens);
+    interpret(ast, createUseHandler(filePath));
+}
+function findArcFiles(dir, pattern) {
+    const results = [];
+    if (!existsSync(dir))
+        return results;
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+        const full = join(dir, entry);
+        const stat = statSync(full);
+        if (stat.isDirectory()) {
+            results.push(...findArcFiles(full, pattern));
+        }
+        else if (pattern.test(entry)) {
+            results.push(full);
+        }
+    }
+    return results;
+}
+export function test(dir) {
+    const d = dir || process.cwd();
+    const testsDir = resolve(d, "tests");
+    const testFiles = findArcFiles(testsDir, /\.arc$/);
+    if (testFiles.length === 0) {
+        console.log("No test files found in tests/");
+        return;
+    }
+    let passed = 0;
+    let failedCount = 0;
+    for (const file of testFiles) {
+        const rel = relative(d, file);
+        try {
+            const source = readFileSync(file, "utf-8");
+            const tokens = lex(source);
+            const ast = parse(tokens);
+            interpret(ast, createUseHandler(file));
+            console.log(`  ✓ ${rel}`);
+            passed++;
+        }
+        catch (e) {
+            console.log(`  ✗ ${rel}: ${e.message}`);
+            failedCount++;
+        }
+    }
+    console.log(`\nTests: ${passed} passed, ${failedCount} failed`);
+    if (failedCount > 0)
+        process.exit(1);
+}
+export function newProject(name, parentDir) {
+    const d = parentDir || process.cwd();
+    const projectDir = resolve(d, name);
+    if (existsSync(projectDir)) {
+        console.error(`Directory '${name}' already exists`);
+        process.exit(1);
+    }
+    mkdirSync(resolve(projectDir, "src"), { recursive: true });
+    mkdirSync(resolve(projectDir, "tests"), { recursive: true });
+    const toml = {
+        package: { name, version: "0.1.0", description: "", author: "", license: "MIT" },
+        dependencies: {},
+        "dev-dependencies": {},
+    };
+    writeFileSync(resolve(projectDir, "arc.toml"), serializeArcToml(toml));
+    writeFileSync(resolve(projectDir, "src", "main.arc"), `fn main() do\n  let msg = "Hello from ${name}!"\nend\n`);
+    writeFileSync(resolve(projectDir, "tests", "main.test.arc"), `fn test_main() do\n  let x = 1 + 1\nend\n`);
+    writeFileSync(resolve(projectDir, "README.md"), `# ${name}\n\nAn Arc project.\n\n## Getting Started\n\n\`\`\`bash\narc build\narc run\n\`\`\`\n`);
+    console.log(`Created project '${name}'`);
+    console.log(`  ${name}/arc.toml`);
+    console.log(`  ${name}/src/main.arc`);
+    console.log(`  ${name}/tests/main.test.arc`);
+    console.log(`  ${name}/README.md`);
+}

package/dist/codegen-js.d.ts

@@ -0,0 +1,2 @@
+import { IRModule } from "./ir.js";
+export declare function generateJS(module: IRModule): string;