arc-lang 0.5.7 → 0.5.9

package/dist/interpreter.js

@@ -1,6 +1,8 @@
 // Arc Language Tree-Walking Interpreter
 import * as nodeCrypto from "crypto";
 import * as nodeOs from "os";
+import * as nodeFs from "fs";
+import { execSync } from "child_process";
 class Env {
     parent;
     vars = new Map();
@@ -71,6 +73,75 @@ function toStr(v) {
         return `<async>`;
     return String(v);
 }
+function syncFetch(method, url, body) {
+    // Build a small Node script that does fetch and prints JSON result
+    // Extract body string: if it's a map with a "data" field, use that; otherwise stringify
+    // Also extract optional "headers" map for custom HTTP headers
+    let bodyStr = null;
+    let customHeaders = {};
+    if (body != null) {
+        if (typeof body === "object" && "__map" in body) {
+            const m = body.entries;
+            const d = m.get("data");
+            const h = m.get("headers");
+            if (h != null && typeof h === "object" && "__map" in h) {
+                const hm = h.entries;
+                for (const [k, v] of hm)
+                    customHeaders[k] = toStr(v);
+            }
+            bodyStr = d != null ? toStr(d) : toStr(body);
+        }
+        else {
+            bodyStr = toStr(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}))}})()`;
+    try {
+        const raw = execSync(`node -e "${script.replace(/"/g, '\\"')}"`, {
+            timeout: 30000,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+            env: { ...process.env, ARC_FETCH: fetchConfig },
+        }).trim();
+        const parsed = JSON.parse(raw);
+        const entries = new Map();
+        entries.set("ok", parsed.ok);
+        entries.set("status", parsed.status);
+        // Convert nested objects/arrays to Arc values
+        entries.set("data", jsToArc(parsed.data));
+        entries.set("method", method);
+        entries.set("url", url);
+        return { __map: true, entries };
+    }
+    catch (e) {
+        const entries = new Map();
+        entries.set("ok", false);
+        entries.set("status", 0);
+        entries.set("data", e.message || "fetch error");
+        entries.set("method", method);
+        entries.set("url", url);
+        return { __map: true, entries };
+    }
+}
+function jsToArc(v) {
+    if (v === null || v === undefined)
+        return null;
+    if (typeof v === "number" || typeof v === "string" || typeof v === "boolean")
+        return v;
+    if (Array.isArray(v))
+        return v.map(jsToArc);
+    if (typeof v === "object") {
+        const entries = new Map();
+        for (const [k, val] of Object.entries(v)) {
+            entries.set(k, jsToArc(val));
+        }
+        return { __map: true, entries };
+    }
+    return String(v);
+}
 function resolveAsync(v) {
     if (v && typeof v === "object" && "__async" in v) {
         return v.thunk();
@@ -644,7 +715,7 @@ function makePrelude(env) {
                 case "os.list_dir": {
                     try {
                         const fs = require("fs");
-                        return fs.readdirSync(args[0]);
+                        return nodeFs.readdirSync(args[0]);
                     }
                     catch {
                         return [];
@@ -653,7 +724,7 @@ function makePrelude(env) {
                 case "os.is_file": {
                     try {
                         const fs = require("fs");
-                        return fs.statSync(args[0]).isFile();
+                        return nodeFs.statSync(args[0]).isFile();
                     }
                     catch {
                         return false;
@@ -662,7 +733,7 @@ function makePrelude(env) {
                 case "os.is_dir": {
                     try {
                         const fs = require("fs");
-                        return fs.statSync(args[0]).isDirectory();
+                        return nodeFs.statSync(args[0]).isDirectory();
                     }
                     catch {
                         return false;
@@ -671,7 +742,7 @@ function makePrelude(env) {
                 case "os.mkdir": {
                     try {
                         const fs = require("fs");
-                        fs.mkdirSync(args[0], { recursive: true });
+                        nodeFs.mkdirSync(args[0], { recursive: true });
                         return true;
                     }
                     catch {
@@ -681,7 +752,7 @@ function makePrelude(env) {
                 case "os.rmdir": {
                     try {
                         const fs = require("fs");
-                        fs.rmdirSync(args[0]);
+                        nodeFs.rmdirSync(args[0]);
                         return true;
                     }
                     catch {
@@ -691,7 +762,7 @@ function makePrelude(env) {
                 case "os.remove": {
                     try {
                         const fs = require("fs");
-                        fs.unlinkSync(args[0]);
+                        nodeFs.unlinkSync(args[0]);
                         return true;
                     }
                     catch {
@@ -701,7 +772,7 @@ function makePrelude(env) {
                 case "os.rename": {
                     try {
                         const fs = require("fs");
-                        fs.renameSync(args[0], args[1]);
+                        nodeFs.renameSync(args[0], args[1]);
                         return true;
                     }
                     catch {
@@ -711,7 +782,7 @@ function makePrelude(env) {
                 case "os.copy": {
                     try {
                         const fs = require("fs");
-                        fs.copyFileSync(args[0], args[1]);
+                        nodeFs.copyFileSync(args[0], args[1]);
                         return true;
                     }
                     catch {
@@ -721,7 +792,7 @@ function makePrelude(env) {
                 case "os.file_size": {
                     try {
                         const fs = require("fs");
-                        return fs.statSync(args[0]).size;
+                        return nodeFs.statSync(args[0]).size;
                     }
                     catch {
                         return null;
@@ -736,7 +807,7 @@ function makePrelude(env) {
                             throw new Error(`Potentially unsafe command (injection risk): ${cmd}`);
                         }
                         const cp = require("child_process");
-                        return cp.execSync(cmd, { encoding: "utf-8", timeout: 10000 }).trim();
+                        return execSync(cmd, { encoding: "utf-8", timeout: 10000 }).trim();
                     }
                     catch (e) {
                         if (e.message?.includes("injection risk"))
@@ -744,16 +815,263 @@ function makePrelude(env) {
                         return null;
                     }
                 }
+                // --- prompt natives ---
+                case "prompt.token_count": {
+                    const text = String(args[0] ?? "");
+                    return Math.ceil(text.length / 4);
+                }
+                case "prompt.token_truncate": {
+                    const text = String(args[0] ?? "");
+                    const maxTokens = args[1];
+                    const maxChars = maxTokens * 4;
+                    if (text.length <= maxChars)
+                        return text;
+                    return text.slice(0, maxChars);
+                }
+                case "prompt.chunk": {
+                    const text = String(args[0] ?? "");
+                    const maxTokens = args[1];
+                    const chunkSize = maxTokens * 4;
+                    const chunks = [];
+                    for (let i = 0; i < text.length; i += chunkSize) {
+                        chunks.push(text.slice(i, i + chunkSize));
+                    }
+                    return chunks.length > 0 ? chunks : [""];
+                }
+                case "prompt.context_window": {
+                    const messages = args[0];
+                    const maxTokens = args[1];
+                    if (!Array.isArray(messages))
+                        return [];
+                    let budget = maxTokens;
+                    const result = [];
+                    for (let i = messages.length - 1; i >= 0; i--) {
+                        const msg = messages[i];
+                        const content = msg?.entries?.get("content") ?? "";
+                        const tokens = Math.ceil(String(content).length / 4);
+                        if (tokens > budget)
+                            break;
+                        budget -= tokens;
+                        result.unshift(msg);
+                    }
+                    return result;
+                }
+                case "prompt.template": {
+                    let text = String(args[0] ?? "");
+                    const vars = args[1];
+                    if (vars && typeof vars === "object" && "__map" in vars) {
+                        for (const [k, v] of vars.entries) {
+                            text = text.replaceAll(`<<${k}>>`, String(v ?? ""));
+                        }
+                    }
+                    return text;
+                }
+                // --- store natives ---
+                case "store.open": {
+                    const p = args[0];
+                    let data = {};
+                    try {
+                        const raw = nodeFs.readFileSync(p, "utf-8");
+                        data = JSON.parse(raw);
+                    }
+                    catch { /* file doesn't exist or invalid JSON — start empty */ }
+                    return { __store: true, path: p, data };
+                }
+                case "store.get": {
+                    const s = args[0];
+                    const k = args[1];
+                    return s.data[k] ?? null;
+                }
+                case "store.set": {
+                    const s = args[0];
+                    s.data[args[1]] = args[2];
+                    nodeFs.writeFileSync(s.path, JSON.stringify(s.data, null, 2), "utf-8");
+                    return args[2];
+                }
+                case "store.delete": {
+                    const s = args[0];
+                    const k = args[1];
+                    const had = k in s.data;
+                    delete s.data[k];
+                    nodeFs.writeFileSync(s.path, JSON.stringify(s.data, null, 2), "utf-8");
+                    return had;
+                }
+                case "store.has": {
+                    const s = args[0];
+                    return args[1] in s.data;
+                }
+                case "store.keys": {
+                    const s = args[0];
+                    return Object.keys(s.data);
+                }
+                case "store.values": {
+                    const s = args[0];
+                    return Object.values(s.data);
+                }
+                case "store.entries": {
+                    const s = args[0];
+                    return Object.entries(s.data).map(([k, v]) => ({ key: k, value: v }));
+                }
+                case "store.clear": {
+                    const s = args[0];
+                    s.data = {};
+                    nodeFs.writeFileSync(s.path, JSON.stringify(s.data, null, 2), "utf-8");
+                    return true;
+                }
+                case "store.size": {
+                    const s = args[0];
+                    return Object.keys(s.data).length;
+                }
+                case "store.merge": {
+                    const s = args[0];
+                    const m = args[1];
+                    if (m && typeof m === "object" && "__map" in m && m.entries instanceof Map) {
+                        for (const [k, v] of m.entries) {
+                            s.data[k] = v;
+                        }
+                    }
+                    else if (m && typeof m === "object" && !Array.isArray(m)) {
+                        for (const [k, v] of Object.entries(m)) {
+                            if (k !== "__type" && k !== "__proto__" && k !== "__map" && k !== "entries")
+                                s.data[k] = v;
+                        }
+                    }
+                    nodeFs.writeFileSync(s.path, JSON.stringify(s.data, null, 2), "utf-8");
+                    return true;
+                }
                 default: return null;
             }
         },
+        // --- embed/vector natives ---
+        embed_dot_product: (a, b) => {
+            if (!Array.isArray(a) || !Array.isArray(b))
+                return 0;
+            let sum = 0;
+            for (let i = 0; i < a.length; i++)
+                sum += a[i] * b[i];
+            return sum;
+        },
+        embed_magnitude: (v) => {
+            if (!Array.isArray(v))
+                return 0;
+            let sum = 0;
+            for (let i = 0; i < v.length; i++)
+                sum += v[i] * v[i];
+            return Math.sqrt(sum);
+        },
+        embed_cosine_similarity: (a, b) => {
+            if (!Array.isArray(a) || !Array.isArray(b))
+                return 0;
+            let dot = 0, magA = 0, magB = 0;
+            for (let i = 0; i < a.length; i++) {
+                const ai = a[i], bi = b[i];
+                dot += ai * bi;
+                magA += ai * ai;
+                magB += bi * bi;
+            }
+            const denom = Math.sqrt(magA) * Math.sqrt(magB);
+            return denom === 0 ? 0 : dot / denom;
+        },
+        embed_normalize: (v) => {
+            if (!Array.isArray(v))
+                return [];
+            let sum = 0;
+            for (let i = 0; i < v.length; i++)
+                sum += v[i] * v[i];
+            const mag = Math.sqrt(sum);
+            if (mag === 0)
+                return v;
+            return v.map(x => x / mag);
+        },
+        embed_euclidean_distance: (a, b) => {
+            if (!Array.isArray(a) || !Array.isArray(b))
+                return 0;
+            let sum = 0;
+            for (let i = 0; i < a.length; i++) {
+                const d = a[i] - b[i];
+                sum += d * d;
+            }
+            return Math.sqrt(sum);
+        },
+        embed_centroid: (vectors) => {
+            if (!Array.isArray(vectors) || vectors.length === 0)
+                return [];
+            const first = vectors[0];
+            const dim = first.length;
+            const sums = new Float64Array(dim);
+            for (let i = 0; i < vectors.length; i++) {
+                const v = vectors[i];
+                for (let j = 0; j < dim; j++)
+                    sums[j] += v[j];
+            }
+            const n = vectors.length;
+            const result = new Array(dim);
+            for (let j = 0; j < dim; j++)
+                result[j] = sums[j] / n;
+            return result;
+        },
+        embed_most_similar: (query, candidates, topK) => {
+            if (!Array.isArray(query) || !Array.isArray(candidates))
+                return [];
+            const k = topK;
+            const scored = [];
+            for (let i = 0; i < candidates.length; i++) {
+                const c = candidates[i];
+                const vec = c.entries.get("vector");
+                let dot = 0, magA = 0, magB = 0;
+                for (let j = 0; j < query.length; j++) {
+                    const qj = query[j], vj = vec[j];
+                    dot += qj * vj;
+                    magA += qj * qj;
+                    magB += vj * vj;
+                }
+                const denom = Math.sqrt(magA) * Math.sqrt(magB);
+                scored.push({ score: denom === 0 ? 0 : dot / denom, idx: i });
+            }
+            scored.sort((a, b) => b.score - a.score);
+            const results = [];
+            for (let i = 0; i < Math.min(k, scored.length); i++) {
+                const s = scored[i];
+                const c = candidates[s.idx];
+                const m = new Map();
+                m.set("id", c.entries.get("id") ?? null);
+                m.set("score", s.score);
+                results.push({ __map: true, entries: m });
+            }
+            return results;
+        },
+        // --- file I/O (used by stdlib/io.arc) ---
+        read: (path) => {
+            try {
+                return nodeFs.readFileSync(path, "utf-8");
+            }
+            catch {
+                return null;
+            }
+        },
+        write: (path, content) => {
+            try {
+                nodeFs.writeFileSync(path, content, "utf-8");
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
     };
     function callFn(fn, args) {
         if (fn && typeof fn === "object" && "__fn" in fn) {
             const f = fn;
             const fnEnv = new Env(f.closure);
             bindParams(f, args, fnEnv, evalExpr);
-            return evalExpr(f.body, fnEnv);
+            try {
+                return evalExpr(f.body, fnEnv);
+            }
+            catch (e) {
+                if (e instanceof ReturnSignal)
+                    return e.value;
+                throw e;
+            }
         }
         // It might be a native function stored as a special wrapper
         if (typeof fn === "function")
@@ -1127,18 +1445,17 @@ function evalExpr(expr, env) {
             const method = expr.method.toUpperCase();
             const arg = evalExpr(expr.arg, env);
             const url = toStr(arg);
-            // Mock HTTP tool calls
+            // Real HTTP tool calls via synchronous fetch
             if (["GET", "POST", "PUT", "DELETE", "PATCH"].includes(method)) {
-                console.log(`[mock ${method} ${url}]`);
+                let bodyArg = null;
                 if (expr.body) {
-                    const body = evalExpr(expr.body, env);
-                    return { __map: true, entries: new Map([["status", 200], ["method", method], ["url", url], ["body", body]]) };
+                    bodyArg = evalExpr(expr.body, env);
                 }
-                return { __map: true, entries: new Map([["status", 200], ["method", method], ["url", url], ["data", `mock-data-from-${url}`]]) };
+                return syncFetch(method, url, bodyArg);
             }
             // Custom tool call
-            console.log(`[mock tool @${expr.method}(${url})]`);
-            return `mock-result-from-${expr.method}`;
+            console.log(`[tool @${expr.method}(${url})]`);
+            return `result-from-${expr.method}`;
         }
         case "AsyncExpr": {
             const capturedEnv = env;

package/dist/lexer.js

@@ -138,8 +138,9 @@ export function lex(source) {
             let hasInterp = false;
             while (i < source.length && peek() !== '"') {
                 if (peek() === "\n") {
-                    // Unterminated string - newline before closing quote
-                    throw new Error(`Unterminated string literal at line ${sl}, col ${sc}`);
+                    // Allow multiline strings
+                    str += advance();
+                    continue;
                 }
                 if (peek() === "{") {
                     hasInterp = true;

package/dist/modules.js

@@ -109,11 +109,18 @@ export function handleUse(stmt, env, currentFile) {
         }
     }
     else {
-        // No selective imports: bind all exports
+        // No selective imports: bind all exports flat
         for (const [name, value] of Object.entries(exports)) {
             env.set(name, value);
         }
     }
+    // Also create a namespace object so `module.fn()` style access works
+    const nsName = stmt.path[stmt.path.length - 1];
+    const entries = new Map();
+    for (const [name, value] of Object.entries(exports)) {
+        entries.set(name, value);
+    }
+    env.set(nsName, { __map: true, entries });
 }
 /**
  * Create a UseHandler bound to a specific file path.

package/dist/parser.js

@@ -518,7 +518,7 @@ export class Parser {
             case TokenType.Slash:
             case TokenType.Percent: return 6;
             case TokenType.Power: return 7;
-            case TokenType.Range: return 8;
+            case TokenType.Range: return 4;
             case TokenType.Dot:
             case TokenType.LBracket:
             case TokenType.LParen:

package/dist/version.d.ts

@@ -1,4 +1,4 @@
-export declare const ARC_VERSION = "0.5.7";
+export declare const ARC_VERSION = "0.5.9";
 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.5.7";
+export const ARC_VERSION = "0.5.9";
 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.5.7",
+  "version": "0.5.9",
   "description": "Arc ⚡ — A programming language designed by AI agents, for AI agents. 27-63% fewer tokens than JavaScript.",
   "type": "module",
   "bin": {