arc-lang 0.6.2 → 0.6.4

package/stdlib/json.arc

@@ -0,0 +1,204 @@
+# Arc Standard Library: json module
+# JSON utilities (pure string manipulation)
+#
+# Note: Arc's lexer treats { inside strings as interpolation.
+# We construct brace characters at runtime from str({}).
+
+# Module-level brace chars
+let _LB = slice(str({}), 0, 1)
+let _RB = slice(str({}), 1, 2)
+let _Q = chars("\"")[0]
+
+pub fn to_json(value) {
+  let t = type_of(value)
+  if t == "nil" { "null" }
+  el if t == "bool" { if value { "true" } el { "false" } }
+  el if t == "int" { str(value) }
+  el if t == "float" {
+    let s = str(value)
+    if s == "Infinity" or s == "-Infinity" or s == "NaN" { "null" }
+    el { s }
+  }
+  el if t == "string" { _quote(value) }
+  el if t == "list" {
+    "[" ++ join(map(value, v => to_json(v)), ",") ++ "]"
+  }
+  el if t == "map" {
+    let ks = keys(value)
+    let pairs = map(ks, k => _quote(k) ++ ":" ++ to_json(value[k]))
+    _LB ++ join(pairs, ",") ++ _RB
+  }
+  el { str(value) }
+}
+
+fn _quote(s) {
+  let escaped = replace(replace(s, "\\", "\\\\"), "\n", "\\n")
+  let escaped = replace(escaped, "\t", "\\t")
+  let escaped = replace(escaped, "\r", "\\r")
+  let escaped = replace(escaped, "\"", "\\\"")
+  _Q ++ escaped ++ _Q
+}
+
+pub fn from_json(s) {
+  let trimmed = trim(s)
+  if len(trimmed) == 0 { nil }
+  el {
+    let parsed = _parse_value(trimmed)
+    parsed.value
+  }
+}
+
+fn _parse_value(s) {
+  let c = slice(s, 0, 1)
+  if c == _Q { _parse_string(s) }
+  el if c == "[" { _parse_array(s) }
+  el if c == _LB { _parse_object(s) }
+  el if c == "t" { _mk(true, slice(s, 4, len(s))) }
+  el if c == "f" { _mk(false, slice(s, 5, len(s))) }
+  el if c == "n" { _mk(nil, slice(s, 4, len(s))) }
+  el { _parse_number(s) }
+}
+
+fn _mk(v, r) {
+  let result = {}
+  result["value"] = v
+  result["rest"] = r
+  result
+}
+
+fn _parse_string(s) {
+  let mut i = 1
+  let mut result = ""
+  let mut done = false
+  let mut escaped = false
+  do {
+    let ch = slice(s, i, i + 1)
+    if escaped {
+      if ch == "n" { result = result ++ "\n" }
+      el if ch == "t" { result = result ++ "\t" }
+      el if ch == "u" {
+        let hex = slice(s, i + 1, i + 5)
+        i = i + 4
+        result = result ++ __native("json.from_codepoint", hex)
+      }
+      el { result = result ++ ch }
+      escaped = false
+    } el if ch == "\\" {
+      escaped = true
+    } el if ch == _Q {
+      done = true
+    } el {
+      result = result ++ ch
+    }
+    i = i + 1
+  } until done
+  _mk(result, trim(slice(s, i, len(s))))
+}
+
+fn _parse_number(s) {
+  let mut i = 0
+  let mut is_float = false
+  if slice(s, 0, 1) == "-" { i = 1 }
+  do {
+    let ch = slice(s, i, i + 1)
+    if ch == "." or ch == "e" or ch == "E" { is_float = true }
+    i = i + 1
+  } until i >= len(s) or not _is_num_char(slice(s, i, i + 1))
+  let num_str = slice(s, 0, i)
+  let value = if is_float { float(num_str) } el { int(num_str) }
+  _mk(value, trim(slice(s, i, len(s))))
+}
+
+fn _is_num_char(c) {
+  c == "0" or c == "1" or c == "2" or c == "3" or c == "4" or
+  c == "5" or c == "6" or c == "7" or c == "8" or c == "9" or
+  c == "." or c == "-" or c == "e" or c == "E" or c == "+"
+}
+
+fn _parse_array(s) {
+  let mut rest = trim(slice(s, 1, len(s)))
+  let mut items = []
+  if slice(rest, 0, 1) == "]" {
+    _mk(items, trim(slice(rest, 1, len(rest))))
+  } el {
+    let mut done = false
+    do {
+      let parsed = _parse_value(rest)
+      items = push(items, parsed.value)
+      rest = trim(parsed.rest)
+      let next = slice(rest, 0, 1)
+      if next == "," {
+        rest = trim(slice(rest, 1, len(rest)))
+      } el {
+        done = true
+      }
+    } until done
+    rest = trim(slice(rest, 1, len(rest)))
+    _mk(items, rest)
+  }
+}
+
+fn _parse_object(s) {
+  let mut rest = trim(slice(s, 1, len(s)))
+  let mut obj = {}
+  if slice(rest, 0, 1) == _RB {
+    _mk(obj, trim(slice(rest, 1, len(rest))))
+  } el {
+    let mut done = false
+    do {
+      let key_parsed = _parse_string(rest)
+      rest = trim(key_parsed.rest)
+      rest = trim(slice(rest, 1, len(rest)))
+      let val_parsed = _parse_value(rest)
+      obj[key_parsed.value] = val_parsed.value
+      rest = trim(val_parsed.rest)
+      let next = slice(rest, 0, 1)
+      if next == "," {
+        rest = trim(slice(rest, 1, len(rest)))
+      } el {
+        done = true
+      }
+    } until done
+    rest = trim(slice(rest, 1, len(rest)))
+    _mk(obj, rest)
+  }
+}
+
+pub fn pretty(value) {
+  _pretty_indent(value, 0)
+}
+
+fn _pretty_indent(value, depth) {
+  let indent = repeat("  ", depth)
+  let inner = repeat("  ", depth + 1)
+  let t = type_of(value)
+  if t == "map" {
+    let ks = keys(value)
+    if len(ks) == 0 { _LB ++ _RB }
+    el {
+      let pairs = map(ks, k => inner ++ _Q ++ k ++ _Q ++ ": " ++ _pretty_indent(value[k], depth + 1))
+      _LB ++ "\n" ++ join(pairs, ",\n") ++ "\n" ++ indent ++ _RB
+    }
+  }
+  el if t == "list" {
+    if len(value) == 0 { "[]" }
+    el {
+      let items = map(value, v => inner ++ _pretty_indent(v, depth + 1))
+      "[\n" ++ join(items, ",\n") ++ "\n" ++ indent ++ "]"
+    }
+  }
+  el { to_json(value) }
+}
+
+pub fn get_path(obj, path) {
+  let parts = split(path, ".")
+  let mut current = obj
+  for part in parts {
+    if type_of(current) == "map" {
+      current = current[part]
+    } el {
+      current = nil
+    }
+  }
+  current
+}

package/stdlib/llm.arc

@@ -0,0 +1,193 @@
+# Arc Standard Library: llm module
+# Multi-provider LLM API integration
+# Makes it natural for AI agents to call other AI agents.
+
+use json
+use os
+
+# --- Provider registry ---
+
+pub fn providers() {
+  [
+    {name: "openai", base_url: "https://api.openai.com/v1", env_key: "OPENAI_API_KEY"},
+    {name: "anthropic", base_url: "https://api.anthropic.com/v1", env_key: "ANTHROPIC_API_KEY"}
+  ]
+}
+
+fn _provider_config(provider) {
+  let all = providers()
+  let mut found = nil
+  for p in all {
+    if p.name == provider { found = p }
+  }
+  if found == nil { error_new("llm", "Unknown LLM provider: " ++ provider) }
+  found
+}
+
+fn _api_key(provider) {
+  let config = _provider_config(provider)
+  let key = os.get_env(config.env_key)
+  if key == nil { error_new("llm", "Missing API key: set " ++ config.env_key ++ " environment variable") }
+  key
+}
+
+# --- OpenAI payload construction ---
+
+fn _openai_chat_payload(model, messages, options) {
+  let mut payload = {}
+  payload["model"] = model
+  payload["messages"] = messages
+  if options != nil {
+    let ks = keys(options)
+    for k in ks {
+      payload[k] = options[k]
+    }
+  }
+  payload
+}
+
+fn _openai_headers(api_key) {
+  let mut h = {}
+  h["Authorization"] = "Bearer " ++ api_key
+  h["Content-Type"] = "application/json"
+  h
+}
+
+# --- Anthropic payload construction ---
+
+fn _anthropic_chat_payload(model, messages, options) {
+  # Anthropic expects system message separate from messages
+  let mut system_msg = nil
+  let mut user_msgs = []
+  for m in messages {
+    if m.role == "system" {
+      system_msg = m.content
+    } el {
+      user_msgs = push(user_msgs, m)
+    }
+  }
+  let mut payload = {}
+  payload["model"] = model
+  payload["messages"] = user_msgs
+  if system_msg != nil { payload["system"] = system_msg }
+  payload["max_tokens"] = if options != nil and options["max_tokens"] != nil { options["max_tokens"] } el { 1024 }
+  if options != nil {
+    let ks = keys(options)
+    for k in ks {
+      if k != "max_tokens" { payload[k] = options[k] }
+    }
+  }
+  payload
+}
+
+fn _anthropic_headers(api_key) {
+  let mut h = {}
+  h["x-api-key"] = api_key
+  h["anthropic-version"] = "2023-06-01"
+  h["Content-Type"] = "application/json"
+  h
+}
+
+# --- Core API ---
+
+# Send a chat completion request
+# provider: "openai" | "anthropic"
+# model: e.g. "gpt-4o", "claude-sonnet-4-20250514"
+# messages: [{role: "user", content: "Hello"}]
+# options: {temperature: 0.7, max_tokens: 1024} (optional)
+pub fn chat(provider, model, messages, options) {
+  let key = _api_key(provider)
+
+  if provider == "openai" {
+    let payload = _openai_chat_payload(model, messages, options)
+    let body = json.to_json(payload)
+    let headers = _openai_headers(key)
+    let resp = @POST "https://api.openai.com/v1/chat/completions" {data: body, headers: headers}
+    if resp.ok and resp.status == 200 {
+      let data = resp.data
+      {ok: true, content: data.choices[0].message.content, usage: data.usage, raw: data}
+    } el {
+      {ok: false, error: resp.data, status: resp.status}
+    }
+  } el if provider == "anthropic" {
+    let payload = _anthropic_chat_payload(model, messages, options)
+    let body = json.to_json(payload)
+    let headers = _anthropic_headers(key)
+    let resp = @POST "https://api.anthropic.com/v1/messages" {data: body, headers: headers}
+    if resp.ok and resp.status == 200 {
+      let data = resp.data
+      let content = if type_of(data.content) == "list" and len(data.content) > 0 {
+        data.content[0].text
+      } el { nil }
+      {ok: true, content: content, usage: data.usage, raw: data}
+    } el {
+      {ok: false, error: resp.data, status: resp.status}
+    }
+  } el {
+    error_new("llm", "Unsupported provider: " ++ provider)
+  }
+}
+
+# Simple text completion (wraps chat with a single user message)
+pub fn complete(provider, model, prompt, options) {
+  let messages = [{role: "user", content: prompt}]
+  chat(provider, model, messages, options)
+}
+
+# Streaming chat — calls callback with each chunk
+# Note: true streaming requires SSE parsing; this simulates via full response
+pub fn stream(provider, model, messages, callback) {
+  # For now, do a regular call and invoke callback with the full response
+  # True SSE streaming would require async I/O support in the runtime
+  let result = chat(provider, model, messages, nil)
+  if result.ok {
+    callback(result.content)
+  }
+  result
+}
+
+# List available models for a provider
+pub fn models(provider) {
+  let key = _api_key(provider)
+
+  if provider == "openai" {
+    let headers = _openai_headers(key)
+    let resp = @GET "https://api.openai.com/v1/models" {headers: headers}
+    if resp.ok and resp.status == 200 {
+      map(resp.data.data, m => m.id)
+    } el {
+      []
+    }
+  } el if provider == "anthropic" {
+    # Anthropic doesn't have a public models endpoint; return known models
+    [
+      "claude-sonnet-4-20250514",
+      "claude-opus-4-20250514",
+      "claude-haiku-35-20241022",
+      "claude-sonnet-3-5-20241022"
+    ]
+  } el {
+    []
+  }
+}
+
+# Estimate API cost in USD
+# Pricing approximate as of 2025
+pub fn estimate_cost(model, input_tokens, output_tokens) {
+  let pricing = _model_pricing(model)
+  let input_cost = (input_tokens / 1000000.0) * pricing.input
+  let output_cost = (output_tokens / 1000000.0) * pricing.output
+  {input_cost: input_cost, output_cost: output_cost, total: input_cost + output_cost, currency: "USD"}
+}
+
+fn _model_pricing(model) {
+  # Prices per million tokens (input, output)
+  if starts(model, "gpt-4o-mini") { {input: 0.15, output: 0.60} }
+  el if starts(model, "gpt-4o") { {input: 2.50, output: 10.00} }
+  el if starts(model, "gpt-4-turbo") { {input: 10.00, output: 30.00} }
+  el if starts(model, "gpt-3.5") { {input: 0.50, output: 1.50} }
+  el if contains(model, "opus") { {input: 15.00, output: 75.00} }
+  el if contains(model, "sonnet") { {input: 3.00, output: 15.00} }
+  el if contains(model, "haiku") { {input: 0.80, output: 4.00} }
+  el { {input: 1.00, output: 3.00} }  # fallback estimate
+}

package/stdlib/log.arc

@@ -0,0 +1,20 @@
+# Arc Standard Library: log module
+# Structured logging with levels and colors
+
+pub fn debug(msg) => __native("log.emit", "debug", msg, nil)
+pub fn info(msg) => __native("log.emit", "info", msg, nil)
+pub fn warn(msg) => __native("log.emit", "warn", msg, nil)
+pub fn error(msg) => __native("log.emit", "error", msg, nil)
+pub fn fatal(msg) => __native("log.fatal", msg)
+
+pub fn set_level(level) => __native("log.set_level", level)
+
+pub fn with(fields) => __native("log.with", fields)
+
+pub fn json(level, msg, fields) => __native("log.json", level, msg, fields)
+
+# Child logger helpers — call these on the map returned by with()
+pub fn child_debug(logger, msg) => __native("log.emit", "debug", msg, logger)
+pub fn child_info(logger, msg) => __native("log.emit", "info", msg, logger)
+pub fn child_warn(logger, msg) => __native("log.emit", "warn", msg, logger)
+pub fn child_error(logger, msg) => __native("log.emit", "error", msg, logger)

package/stdlib/map.arc

@@ -0,0 +1,72 @@
+# Arc Standard Library: map module
+# Map utilities
+
+pub fn merge(a, b) {
+  let mut result = {}
+  for k in keys(a) {
+    result[k] = a[k]
+  }
+  for k in keys(b) {
+    result[k] = b[k]
+  }
+  result
+}
+
+pub fn map_values(m, f) {
+  let mut result = {}
+  for k in keys(m) {
+    result[k] = f(m[k])
+  }
+  result
+}
+
+pub fn map_keys(m, f) {
+  let mut result = {}
+  for k in keys(m) {
+    let new_key = str(f(k))
+    result[new_key] = m[k]
+  }
+  result
+}
+
+pub fn filter_map(m, f) {
+  let mut result = {}
+  for k in keys(m) {
+    if f(m[k]) {
+      result[k] = m[k]
+    }
+  }
+  result
+}
+
+pub fn from_pairs(list) {
+  let mut result = {}
+  for pair in list {
+    result[pair[0]] = pair[1]
+  }
+  result
+}
+
+pub fn to_pairs(m) {
+  map(keys(m), k => [k, m[k]])
+}
+
+pub fn pick(m, ks) {
+  let mut result = {}
+  for k in ks {
+    if contains(keys(m), k) {
+      result[k] = m[k]
+    }
+  }
+  result
+}
+
+pub fn omit(m, ks) {
+  let mut result = {}
+  for k in keys(m) {
+    if not contains(ks, k) {
+      result[k] = m[k]
+    }
+  }
+  result
+}

package/stdlib/math.arc

@@ -0,0 +1,133 @@
+# Arc Standard Library: math module
+
+# === Constants ===
+pub let PI = 3.141592653589793
+pub let E = 2.718281828459045
+pub let TAU = 6.283185307179586
+# INF and NAN available via native runtime
+
+# === Basic ===
+pub fn abs(x) => if x < 0 { 0 - x } el { x }
+
+pub fn sign(x) {
+  if x > 0 { 1 }
+  el if x < 0 { -1 }
+  el { 0 }
+}
+
+pub fn clamp(x, lo, hi) {
+  if x < lo { lo }
+  el if x > hi { hi }
+  el { x }
+}
+
+# === Rounding ===
+pub fn ceil(x) => __native("math.ceil", x)
+
+pub fn floor(x) => int(x)
+
+pub fn round(x) => int(x + 0.5)
+
+# === Powers & Roots ===
+pub fn pow(base, exp) {
+  if exp == 0 { 1 }
+  el if exp < 0 and base == 0 { nil }
+  el if type_of(exp) == "float" { __native("math.pow", base, exp) }
+  el if exp < 0 { 1.0 / pow(base, 0 - exp) }
+  el {
+    let mut result = 1
+    let mut b = base
+    let mut e = exp
+    do {
+      if e % 2 == 1 { result = result * b }
+      e = int(e / 2)
+      b = b * b
+    } until e == 0
+    result
+  }
+}
+
+pub fn sqrt(x) {
+  if x == 0 { 0.0 }
+  el if x < 0 { nil }
+  el {
+    let mut guess = x / 2.0
+    for i in 0..25 {
+      guess = (guess + x / guess) / 2.0
+    }
+    guess
+  }
+}
+
+pub fn cbrt(x) => __native("math.cbrt", x)
+
+pub fn hypot(x, y) => __native("math.hypot", x, y)
+
+# === Trigonometry ===
+pub fn sin(x) => __native("math.sin", x)
+pub fn cos(x) => __native("math.cos", x)
+pub fn tan(x) => __native("math.tan", x)
+pub fn asin(x) => __native("math.asin", x)
+pub fn acos(x) => __native("math.acos", x)
+pub fn atan(x) => __native("math.atan", x)
+pub fn atan2(y, x) => __native("math.atan2", y, x)
+
+pub fn degrees(rad) => rad * 180.0 / PI
+pub fn radians(deg) => deg * PI / 180.0
+
+# === Logarithmic & Exponential ===
+pub fn log(x) => __native("math.log", x)
+pub fn log2(x) => __native("math.log2", x)
+pub fn log10(x) => __native("math.log10", x)
+pub fn exp(x) => __native("math.exp", x)
+
+# === Combinatorics ===
+pub fn factorial(n) {
+  if n < 0 { nil }
+  el if n <= 1 { 1 }
+  el {
+    let mut result = 1
+    for i in 2..n + 1 {
+      result = result * i
+    }
+    if str(result) == "Infinity" { nil }
+    el { result }
+  }
+}
+
+pub fn gcd(a, b) {
+  let mut x = abs(a)
+  let mut y = abs(b)
+  if x == 0 and y == 0 { 0 }
+  el {
+    do {
+      let t = y
+      y = x % y
+      x = t
+    } until y == 0
+    x
+  }
+}
+
+pub fn lcm(a, b) {
+  let d = gcd(a, b)
+  if d == 0 { 0 }
+  el { abs(a / d) * b }
+}
+
+# === Aggregation ===
+pub fn sum(lst) {
+  let mut total = 0
+  for x in lst {
+    if type_of(x) == "int" or type_of(x) == "float" {
+      total = total + x
+    }
+  }
+  total
+}
+
+pub fn product(lst) {
+  let mut total = 1
+  for x in lst { total = total * x }
+  total
+}

package/stdlib/net.arc

@@ -0,0 +1,17 @@
+# Arc Standard Library: net module
+# Networking utilities
+
+# --- URL ---
+
+pub fn url_parse(url) => net_url_parse(url)
+pub fn url_encode(text) => net_url_encode(text)
+pub fn url_decode(text) => net_url_decode(text)
+
+# --- Query String ---
+
+pub fn parse_query(query_string) => net_query_parse(query_string)
+pub fn build_query(params_map) => net_query_stringify(params_map)
+
+# --- IP ---
+
+pub fn ip_is_valid(addr) => net_ip_is_valid(addr)