arc-lang 0.6.2 → 0.6.4

package/stdlib/os.arc

@@ -0,0 +1,81 @@
+# Arc Standard Library: os module
+# Filesystem and system operations
+
+# Returns the current working directory
+pub fn cwd() => __native("os.cwd")
+
+# Get environment variable by name, returns nil if not set
+pub fn get_env(name) => __native("os.env", name)
+
+# Set environment variable
+pub fn set_env(name, value) => __native("os.set_env", name, value)
+
+# List files and directories in the given path, returns a list of strings
+pub fn list_dir(path) => __native("os.list_dir", path)
+
+# Check if path points to a file
+pub fn is_file(path) => __native("os.is_file", path)
+
+# Check if path points to a directory
+pub fn is_dir(path) => __native("os.is_dir", path)
+
+# Create a directory (and parent directories if needed)
+pub fn mkdir(path) => __native("os.mkdir", path)
+
+# Remove an empty directory
+pub fn rmdir(path) => __native("os.rmdir", path)
+
+# Remove a file
+pub fn remove(path) => __native("os.remove", path)
+
+# Rename or move a file/directory
+pub fn rename(old_path, new_path) => __native("os.rename", old_path, new_path)
+
+# Copy a file from src to dest
+pub fn copy(src, dest) => __native("os.copy", src, dest)
+
+# Get file size in bytes
+pub fn file_size(path) => __native("os.file_size", path)
+
+# Get file extension (e.g. ".txt"), returns "" if none
+pub fn file_ext(path) {
+  let parts = split(path, ".")
+  if len(parts) <= 1 { "" }
+  el { "." ++ last(parts) }
+}
+
+# Join path segments with the platform separator
+pub fn join_path(parts) {
+  let sep = if platform() == "windows" { "\\" } el { "/" }
+  join(parts, sep)
+}
+
+# Get the parent directory of a path
+pub fn parent_dir(path) {
+  let sep = if platform() == "windows" { "\\" } el { "/" }
+  let parts = split(path, sep)
+  if len(parts) <= 1 { "." }
+  el {
+    let parent_parts = slice(parts, 0, len(parts) - 1)
+    join(parent_parts, sep)
+  }
+}
+
+# Get the filename (basename) from a path
+pub fn basename(path) {
+  let sep = if platform() == "windows" { "\\" } el { "/" }
+  let parts = split(path, sep)
+  last(parts)
+}
+
+# Execute a shell command and return its output as a string
+pub fn exec(command) => __native("os.exec", command)
+
+# Returns the platform: "windows", "linux", or "macos"
+pub fn platform() => __native("os.platform")
+
+# Returns the user's home directory
+pub fn home_dir() => __native("os.home_dir")
+
+# Returns the system temp directory
+pub fn temp_dir() => __native("os.temp_dir")

package/stdlib/path.arc

@@ -0,0 +1,11 @@
+# Arc Standard Library: path module
+# Path manipulation utilities
+
+pub fn join(...parts) => __native("path.join_list", parts)
+pub fn dirname(p) => __native("path.dirname", p)
+pub fn basename(p) => __native("path.basename", p)
+pub fn extname(p) => __native("path.extname", p)
+pub fn resolve(p) => __native("path.resolve", p)
+pub fn normalize(p) => __native("path.normalize", p)
+pub fn is_absolute(p) => __native("path.is_absolute", p)
+pub fn sep() => __native("path.sep")

package/stdlib/prompt.arc

@@ -0,0 +1,49 @@
+# Arc Standard Library: prompt module
+# Template management, token counting, and context windowing for AI agents
+
+## Template filling — replace <<var>> placeholders with values from a map
+## Example: template("Hello <<name>>", {name: "World"}) => "Hello World"
+pub fn template(tmpl, vars) {
+  __native("prompt.template", tmpl, vars)
+}
+
+## Estimate token count (~4 chars per token)
+pub fn token_count(text) {
+  __native("prompt.token_count", text)
+}
+
+## Truncate text to fit within a token limit
+pub fn token_truncate(text, max_tokens) {
+  __native("prompt.token_truncate", text, max_tokens)
+}
+
+## Fit as many messages as possible within a token budget (keeps newest)
+## Each message should be a map with at least a "content" key
+pub fn context_window(messages, max_tokens) {
+  __native("prompt.context_window", messages, max_tokens)
+}
+
+## Split text into chunks that fit within token limits
+pub fn chunk(text, max_tokens) {
+  __native("prompt.chunk", text, max_tokens)
+}
+
+## Format a system prompt
+pub fn system_prompt(role, instructions) {
+  {role: "system", content: "You are " ++ role ++ ". " ++ instructions}
+}
+
+## Format a user message
+pub fn user_message(text) {
+  {role: "user", content: text}
+}
+
+## Format an assistant message
+pub fn assistant_message(text) {
+  {role: "assistant", content: text}
+}
+
+## Format a list of messages into a chat string
+pub fn format_chat(messages) {
+  messages |> map(m => "[" ++ m.role ++ "]: " ++ m.content) |> fold("", (acc, line) => if acc == "" { line } el { acc ++ "\n" ++ line })
+}

package/stdlib/regex.arc

@@ -0,0 +1,59 @@
+# Arc Standard Library: regex module
+# Provides regular expression matching, replacing, splitting, and validation.
+
+# Returns the first match of `pattern` in `text`, or nil if no match
+pub fn find(pattern, text) {
+  let re = regex_new(pattern)
+  regex_find(re, text)
+}
+
+# Returns a list of all matches of `pattern` in `text`
+pub fn find_all(pattern, text) {
+  let re = regex_new(pattern)
+  regex_find_all(re, text)
+}
+
+# Returns true if `pattern` matches anywhere in `text`, false otherwise
+pub fn test(pattern, text) {
+  let result = find(pattern, text)
+  result != nil
+}
+
+# Replaces the first occurrence of `pattern` with `replacement` in `text`
+pub fn replace(pattern, replacement, text) {
+  let re = regex_new(pattern)
+  regex_replace(re, replacement, text)
+}
+
+# Replaces all occurrences of `pattern` with `replacement` in `text`
+pub fn replace_all(pattern, replacement, text) {
+  let re = regex_new(pattern)
+  regex_replace_all(re, replacement, text)
+}
+
+# Splits `text` by occurrences of `pattern`
+pub fn split(pattern, text) {
+  let re = regex_new(pattern)
+  regex_split(re, text)
+}
+
+# Returns a list of capture groups from the first match of `pattern` in `text`
+pub fn capture(pattern, text) {
+  let re = regex_new(pattern)
+  regex_captures(re, text)
+}
+
+# Returns a list of all capture group sets from all matches of `pattern` in `text`
+pub fn capture_all(pattern, text) {
+  let re = regex_new(pattern)
+  regex_captures_all(re, text)
+}
+
+# Escapes all regex special characters in `text`
+pub fn escape(text) => __native("regex.escape", text)
+
+# Returns true if `pattern` is a valid regex, false otherwise
+pub fn is_valid(pattern) {
+  let result = regex_try_new(pattern)
+  result != nil
+}

package/stdlib/result.arc

@@ -0,0 +1,50 @@
+# Arc Standard Library: result module
+# Result type pattern for error handling using native builtins
+
+# Capture builtins before any shadowing
+let _builtin_is_ok = is_ok
+let _builtin_is_err = is_err
+let _builtin_unwrap = unwrap
+let _builtin_unwrap_or = unwrap_or
+let _builtin_unwrap_err = unwrap_err
+let _builtin_map_result = map_result
+
+# Ok(value) - wraps a success value in a Result
+pub fn ok(value) => Ok(value)
+
+# err(error) - wraps an error in a Result
+pub fn err(error) => Err(error)
+
+# --- Clean aliases (no prefix stutter: result.is_ok instead of result.result_is_ok) ---
+
+pub fn is_ok(result) => _builtin_is_ok(result)
+pub fn is_err(result) => _builtin_is_err(result)
+pub fn unwrap(result) => _builtin_unwrap(result)
+pub fn unwrap_or(result, default) => _builtin_unwrap_or(result, default)
+pub fn unwrap_err(result) => _builtin_unwrap_err(result)
+pub fn map(result, f) => _builtin_map_result(result, f)
+pub fn flat_map(result, f) {
+  if _builtin_is_ok(result) {
+    f(_builtin_unwrap(result))
+  } el {
+    result
+  }
+}
+
+# try_fn - wraps a function call in a Result (uses native error_try)
+pub fn try_fn(f) => error_try(f)
+
+# --- Legacy prefixed names (backward compat) ---
+
+pub fn result_is_ok(result) => _builtin_is_ok(result)
+pub fn result_is_err(result) => _builtin_is_err(result)
+pub fn result_unwrap(result) => _builtin_unwrap(result)
+pub fn result_unwrap_or(result, default) => _builtin_unwrap_or(result, default)
+pub fn result_map(result, f) => _builtin_map_result(result, f)
+pub fn flat_map_result(result, f) {
+  if _builtin_is_ok(result) {
+    f(_builtin_unwrap(result))
+  } el {
+    result
+  }
+}

package/stdlib/store.arc

@@ -0,0 +1,62 @@
+# Arc Standard Library: store module
+# Persistent key-value storage backed by JSON files
+#
+# Usage:
+#   use store
+#   let s = store.open("my_data.json")
+#   store.set(s, "key", "value")
+#   let v = store.get(s, "key")
+
+pub fn open(path) {
+  __native("store.open", path)
+}
+
+pub fn get(store, key) {
+  __native("store.get", store, key)
+}
+
+pub fn set(store, key, value) {
+  __native("store.set", store, key, value)
+}
+
+pub fn delete(store, key) {
+  __native("store.delete", store, key)
+}
+
+pub fn has(store, key) {
+  __native("store.has", store, key)
+}
+
+pub fn keys(store) {
+  __native("store.keys", store)
+}
+
+pub fn values(store) {
+  __native("store.values", store)
+}
+
+pub fn entries(store) {
+  __native("store.entries", store)
+}
+
+pub fn clear(store) {
+  __native("store.clear", store)
+}
+
+pub fn size(store) {
+  __native("store.size", store)
+}
+
+pub fn merge(store, map) {
+  __native("store.merge", store, map)
+}
+
+pub fn get_or_set(store, key, default_fn) {
+  let existing = get(store, key)
+  if existing != nil { existing }
+  el {
+    let val = default_fn()
+    set(store, key, val)
+    val
+  }
+}

package/stdlib/strings.arc

@@ -0,0 +1,44 @@
+# Arc Standard Library: strings module
+
+pub fn pad_left(s, width, ch) {
+  let mut result = str(s)
+  if len(str(ch)) == 0 { result }
+  el {
+    let pad_char = slice(str(ch), 0, 1)
+    if len(result) >= width { result }
+    el {
+      do {
+        result = pad_char ++ result
+      } until len(result) >= width
+      result
+    }
+  }
+}
+
+pub fn pad_right(s, width, ch) {
+  let mut result = str(s)
+  if len(str(ch)) == 0 { result }
+  el {
+    let pad_char = slice(str(ch), 0, 1)
+    if len(result) >= width { result }
+    el {
+      do {
+        result = result ++ pad_char
+      } until len(result) >= width
+      result
+    }
+  }
+}
+
+pub fn capitalize(s) {
+  if len(s) == 0 { "" }
+  el {
+    let first = upper(slice(s, 0, 1))
+    let rest = lower(slice(s, 1, len(s)))
+    first ++ rest
+  }
+}
+
+pub fn words(s) {
+  split(trim(s), " ") |> filter(w => len(w) > 0)
+}

package/stdlib/test.arc

@@ -0,0 +1,61 @@
+# Arc Standard Library: test module
+# A lightweight testing framework
+
+let mut _passed = 0
+let mut _failed = 0
+let mut _current_group = ""
+
+pub fn describe(name, f) {
+  _current_group = name
+  print("--- " ++ name ++ " ---")
+  f()
+  print("")
+}
+
+pub fn it(name, f) {
+  let label = if _current_group != "" { _current_group ++ " > " ++ name } el { name }
+  f()
+  _passed = _passed + 1
+  print("  ✓ " ++ name)
+}
+
+pub fn expect_eq(a, b, msg) {
+  let m = msg or ("Expected " ++ str(a) ++ " to equal " ++ str(b))
+  assert(a == b, m)
+}
+
+pub fn expect_neq(a, b, msg) {
+  let m = msg or ("Expected " ++ str(a) ++ " to not equal " ++ str(b))
+  assert(a != b, m)
+}
+
+pub fn expect_true(val, msg) {
+  let m = msg or ("Expected truthy, got " ++ str(val))
+  assert(val, m)
+}
+
+pub fn expect_false(val, msg) {
+  let m = msg or ("Expected falsy, got " ++ str(val))
+  assert(not val, m)
+}
+
+pub fn expect_nil(val, msg) {
+  let m = msg or ("Expected nil, got " ++ str(val))
+  assert(val == nil, m)
+}
+
+pub fn expect_gt(a, b, msg) {
+  let m = msg or ("Expected " ++ str(a) ++ " > " ++ str(b))
+  assert(a > b, m)
+}
+
+pub fn expect_lt(a, b, msg) {
+  let m = msg or ("Expected " ++ str(a) ++ " < " ++ str(b))
+  assert(a < b, m)
+}
+
+pub fn run_tests() {
+  print("========================")
+  print("Tests: " ++ str(_passed) ++ " passed, " ++ str(_failed) ++ " failed")
+  print("========================")
+}

package/stdlib/time.arc

@@ -0,0 +1,19 @@
+# Arc Standard Library: time module
+# Simulated time utilities
+
+pub fn now() => __native("time.now")
+
+pub fn format_duration(ms) {
+  let total_s = int(ms / 1000)
+  let h = int(total_s / 3600)
+  let m = int((total_s % 3600) / 60)
+  let s = total_s % 60
+  let parts = []
+  let mut result = ""
+  if h > 0 { result = str(h) ++ "h " }
+  if m > 0 { result = result ++ str(m) ++ "m " }
+  result = result ++ str(s) ++ "s"
+  result
+}
+
+pub fn sleep(ms) => __native("time.sleep", ms)

package/stdlib/toml.arc

@@ -0,0 +1,10 @@
+# Arc Standard Library: toml module
+# TOML parsing and stringifying
+
+pub fn parse(text) {
+  __native("toml.parse", text)
+}
+
+pub fn stringify(value) {
+  __native("toml.stringify", value)
+}

package/stdlib/yaml.arc

@@ -0,0 +1,10 @@
+# Arc Standard Library: yaml module
+# YAML parsing and stringifying
+
+pub fn parse(text) {
+  __native("yaml.parse", text)
+}
+
+pub fn stringify(value) {
+  __native("yaml.stringify", value)
+}