kimchilang 1.0.1

package/stdlib/http.md

@@ -0,0 +1,333 @@
+# HTTP Module
+
+A promise-based HTTP client wrapper for Node.js http/https modules.
+
+## Import
+
+```kimchi
+as http dep stdlib.http
+```
+
+## Functions
+
+### `get(url, options)`
+
+Make an HTTP GET request.
+
+```kimchi
+dec response = await http.get("https://api.example.com/users")
+print response.body
+```
+
+**Parameters:**
+- `url` - The URL to request
+- `options` - Optional request options (headers, timeout)
+
+**Returns:** Response object
+
+---
+
+### `post(url, body, options)`
+
+Make an HTTP POST request.
+
+```kimchi
+dec response = await http.post("https://api.example.com/users", {
+  name: "Alice",
+  email: "alice@example.com"
+})
+print response.body
+```
+
+**Parameters:**
+- `url` - The URL to request
+- `body` - Request body (automatically JSON stringified if object)
+- `options` - Optional request options
+
+**Returns:** Response object
+
+---
+
+### `put(url, body, options)`
+
+Make an HTTP PUT request.
+
+```kimchi
+dec response = await http.put("https://api.example.com/users/123", {
+  name: "Alice Updated"
+})
+```
+
+**Parameters:**
+- `url` - The URL to request
+- `body` - Request body
+- `options` - Optional request options
+
+**Returns:** Response object
+
+---
+
+### `patch(url, body, options)`
+
+Make an HTTP PATCH request.
+
+```kimchi
+dec response = await http.patch("https://api.example.com/users/123", {
+  email: "newemail@example.com"
+})
+```
+
+**Parameters:**
+- `url` - The URL to request
+- `body` - Request body
+- `options` - Optional request options
+
+**Returns:** Response object
+
+---
+
+### `del(url, options)`
+
+Make an HTTP DELETE request.
+
+```kimchi
+dec response = await http.del("https://api.example.com/users/123")
+if response.ok {
+  print "User deleted"
+}
+```
+
+**Parameters:**
+- `url` - The URL to request
+- `options` - Optional request options
+
+**Returns:** Response object
+
+---
+
+### `request(url, options)`
+
+Generic HTTP request function. All other methods use this internally.
+
+```kimchi
+dec response = await http.request("https://api.example.com/data", {
+  method: "POST",
+  headers: {
+    "Content-Type": "application/json",
+    "Authorization": "Bearer token123"
+  },
+  body: { key: "value" },
+  timeout: 5000
+})
+```
+
+**Parameters:**
+- `url` - The URL to request
+- `options` - Request options:
+  - `method` - HTTP method (GET, POST, PUT, PATCH, DELETE)
+  - `headers` - Request headers object
+  - `body` - Request body
+  - `timeout` - Request timeout in milliseconds (default: 30000)
+
+**Returns:** Response object
+
+---
+
+### `queryString(params)`
+
+Build a URL query string from an object.
+
+```kimchi
+dec qs = http.queryString({ page: 1, limit: 10, search: "hello world" })
+// Returns: "page=1&limit=10&search=hello%20world"
+```
+
+**Parameters:**
+- `params` - Object with key-value pairs
+
+**Returns:** URL-encoded query string
+
+---
+
+### `buildUrl(baseUrl, params)`
+
+Build a complete URL with query parameters.
+
+```kimchi
+dec url = http.buildUrl("https://api.example.com/search", {
+  q: "kimchi",
+  page: 1
+})
+// Returns: "https://api.example.com/search?q=kimchi&page=1"
+```
+
+**Parameters:**
+- `baseUrl` - Base URL
+- `params` - Query parameters object
+
+**Returns:** Complete URL with query string
+
+---
+
+### `createClient(baseOptions)`
+
+Create a reusable HTTP client with default options.
+
+```kimchi
+dec api = http.createClient({
+  baseUrl: "https://api.example.com",
+  headers: {
+    "Authorization": "Bearer token123",
+    "Accept": "application/json"
+  },
+  timeout: 10000
+})
+
+// Now use the client - paths are relative to baseUrl
+dec users = await api.get("/users")
+dec user = await api.post("/users", { name: "Bob" })
+dec updated = await api.put("/users/123", { name: "Bob Updated" })
+dec patched = await api.patch("/users/123", { email: "bob@new.com" })
+dec deleted = await api.del("/users/123")
+```
+
+**Parameters:**
+- `baseOptions` - Client configuration:
+  - `baseUrl` - Base URL prepended to all requests
+  - `headers` - Default headers for all requests
+  - `timeout` - Default timeout for all requests
+
+**Returns:** Client object with `get`, `post`, `put`, `patch`, `del` methods
+
+---
+
+## Response Object
+
+All request functions return a response object with the following properties:
+
+```kimchi
+{
+  status: 200,           // HTTP status code
+  statusText: "OK",      // HTTP status message
+  headers: {...},        // Response headers
+  body: {...},           // Response body (auto-parsed if JSON)
+  ok: true               // true if status is 200-299
+}
+```
+
+### Checking Response Status
+
+```kimchi
+dec response = await http.get("https://api.example.com/users")
+
+if response.ok {
+  print "Success: ${response.body}"
+} else {
+  print "Error ${response.status}: ${response.statusText}"
+}
+```
+
+---
+
+## Examples
+
+### Simple GET Request
+
+```kimchi
+as http dep stdlib.http
+
+dec response = await http.get("https://jsonplaceholder.typicode.com/posts/1")
+print "Title: ${response.body.title}"
+```
+
+### POST with JSON Body
+
+```kimchi
+as http dep stdlib.http
+
+dec response = await http.post("https://jsonplaceholder.typicode.com/posts", {
+  title: "My Post",
+  body: "This is the content",
+  userId: 1
+})
+
+print "Created post with ID: ${response.body.id}"
+```
+
+### Using Custom Headers
+
+```kimchi
+as http dep stdlib.http
+
+dec response = await http.get("https://api.example.com/protected", {
+  headers: {
+    "Authorization": "Bearer my-token",
+    "X-Custom-Header": "custom-value"
+  }
+})
+```
+
+### Creating an API Client
+
+```kimchi
+as http dep stdlib.http
+
+// Create a client for a specific API
+dec github = http.createClient({
+  baseUrl: "https://api.github.com",
+  headers: {
+    "Accept": "application/vnd.github.v3+json",
+    "Authorization": "token ghp_xxxxxxxxxxxx"
+  }
+})
+
+// Fetch user info
+dec user = await github.get("/user")
+print "Logged in as: ${user.body.login}"
+
+// List repositories
+dec repos = await github.get("/user/repos")
+for repo in repos.body {
+  print "- ${repo.name}"
+}
+```
+
+### Error Handling
+
+```kimchi
+as http dep stdlib.http
+
+try {
+  dec response = await http.get("https://api.example.com/users/999")
+  
+  |response.status == 404| => {
+    print "User not found"
+  }
+  |response.status == 401| => {
+    print "Unauthorized - please log in"
+  }
+  |response.ok| => {
+    print "User: ${response.body.name}"
+  }
+  |true| => {
+    print "Unexpected error: ${response.status}"
+  }
+} catch(e) {
+  print "Network error: ${e.message}"
+}
+```
+
+### Building URLs with Query Parameters
+
+```kimchi
+as http dep stdlib.http
+
+dec url = http.buildUrl("https://api.example.com/search", {
+  q: "kimchi lang",
+  page: 1,
+  limit: 20
+})
+
+dec results = await http.get(url)
+print "Found ${results.body.total} results"
+```

package/stdlib/index.km

@@ -0,0 +1,26 @@
+// KimchiLang Standard Library
+// Main entry point
+
+expose fn _describe() {
+  return "KimchiLang Standard Library - functional utilities for arrays, strings, objects, math, and more"
+}
+
+expose fn _help() {
+  return "
+Available modules:
+  stdlib.array     - Array utilities (map, filter, reduce, etc.)
+  stdlib.string    - String utilities (split, trim, replace, etc.)
+  stdlib.object    - Object utilities (keys, values, entries, etc.)
+  stdlib.math      - Math utilities (abs, round, trig, etc.)
+  stdlib.json      - JSON utilities (parse, stringify, pretty)
+  stdlib.console   - Console/IO utilities (log, error, table, etc.)
+  stdlib.promise   - Promise utilities (all, race, delay, etc.)
+  stdlib.date      - Date/time utilities (now, format, diff, etc.)
+  stdlib.function  - Function utilities (compose, pipe, etc.)
+
+Usage:
+  as arr dep stdlib.array
+  as str dep stdlib.string
+  as math dep stdlib.math
+"
+}

package/stdlib/json.km

@@ -0,0 +1,17 @@
+// KimchiLang Standard Library - JSON Functions
+
+expose fn _describe() {
+  return "JSON utilities: parse, stringify, pretty print"
+}
+
+expose fn parse(str) {
+  return JSON.parse(str)
+}
+
+expose fn stringify(obj) {
+  return JSON.stringify(obj)
+}
+
+expose fn pretty(obj, indent) {
+  return JSON.stringify(obj, null, indent || 2)
+}

package/stdlib/logger.js

@@ -0,0 +1,114 @@
+// KimchiLang Logger Module
+// Provides structured JSON logging with log levels
+
+const LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+};
+
+function getLogLevel() {
+  const level = (process.env.LOG_LEVEL || 'info').toLowerCase();
+  return LOG_LEVELS[level] ?? LOG_LEVELS.info;
+}
+
+function getCallerInfo() {
+  const err = new Error();
+  const stack = err.stack.split('\n');
+  
+  // Find the first stack frame outside of logger.js
+  for (let i = 2; i < stack.length; i++) {
+    const line = stack[i];
+    if (!line.includes('logger.js') && !line.includes('node:internal')) {
+      // Parse stack frame: "    at functionName (file:line:col)" or "    at file:line:col"
+      const match = line.match(/at\s+(?:(.+?)\s+\()?(.+?):(\d+):(\d+)\)?/);
+      if (match) {
+        const functionName = match[1] || '<anonymous>';
+        const filePath = match[2];
+        const lineNumber = parseInt(match[3], 10);
+        
+        // Extract module path from file path
+        const modulePath = filePath
+          .replace(/^file:\/\//, '')
+          .replace(/.*\//, '')
+          .replace(/\.(js|km)$/, '');
+        
+        return {
+          function: functionName,
+          module: modulePath,
+          line: lineNumber,
+          file: filePath,
+        };
+      }
+    }
+  }
+  
+  return {
+    function: '<unknown>',
+    module: '<unknown>',
+    line: 0,
+    file: '<unknown>',
+  };
+}
+
+function formatLog(level, message, data = {}) {
+  const caller = getCallerInfo();
+  const timestamp = new Date().toISOString();
+  
+  const logEntry = {
+    timestamp,
+    level,
+    module: caller.module,
+    function: caller.function,
+    line: caller.line,
+    message,
+    ...data,
+  };
+  
+  return JSON.stringify(logEntry);
+}
+
+function shouldLog(level) {
+  const currentLevel = getLogLevel();
+  return LOG_LEVELS[level] >= currentLevel;
+}
+
+export const logger = {
+  debug(message, data) {
+    if (shouldLog('debug')) {
+      console.log(formatLog('debug', message, data));
+    }
+  },
+  
+  info(message, data) {
+    if (shouldLog('info')) {
+      console.log(formatLog('info', message, data));
+    }
+  },
+  
+  warn(message, data) {
+    if (shouldLog('warn')) {
+      console.warn(formatLog('warn', message, data));
+    }
+  },
+  
+  error(message, data) {
+    if (shouldLog('error')) {
+      console.error(formatLog('error', message, data));
+    }
+  },
+  
+  // Create a child logger with additional context
+  child(context) {
+    return {
+      debug: (message, data) => logger.debug(message, { ...context, ...data }),
+      info: (message, data) => logger.info(message, { ...context, ...data }),
+      warn: (message, data) => logger.warn(message, { ...context, ...data }),
+      error: (message, data) => logger.error(message, { ...context, ...data }),
+      child: (moreContext) => logger.child({ ...context, ...moreContext }),
+    };
+  },
+};
+
+export default logger;

package/stdlib/logger.km

@@ -0,0 +1,104 @@
+// KimchiLang Logger
+// Usage: as log dep stdlib.logger
+// Then: log.info("message"), log.debug("message"), etc.
+// Set LOG_LEVEL environment variable to control output (debug, info, warn, error)
+
+env LOG_LEVEL = "info"
+
+dec LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+}
+
+fn getLogLevel() {
+  dec level = LOG_LEVEL.toLowerCase()
+  dec numLevel = LOG_LEVELS[level]
+  |numLevel == null| => return 1
+  return numLevel
+}
+
+fn shouldLog(level) {
+  return LOG_LEVELS[level] >= getLogLevel()
+}
+
+fn getCallerInfo() {
+  return js {
+    const err = new Error();
+    const stack = err.stack.split('\n');
+    for (let i = 3; i < stack.length; i++) {
+      const line = stack[i];
+      if (!line.includes('logger') && !line.includes('node:internal')) {
+        const match = line.match(/at\s+(?:(.+?)\s+\()?(.+?):(\d+):(\d+)\)?/);
+        if (match) {
+          return {
+            fn: match[1] || '<anonymous>',
+            module: match[2].replace(/^file:\/\//, '').replace(/.*\//, '').replace(/\.(js|km)$/, ''),
+            line: parseInt(match[3], 10),
+          };
+        }
+      }
+    }
+    return { fn: '<unknown>', module: '<unknown>', line: 0 };
+  }
+}
+
+fn formatLog(level, message, data) {
+  dec caller = getCallerInfo()
+  dec timestamp = js { return new Date().toISOString(); }
+  
+  dec entry = {
+    timestamp: timestamp,
+    level: level,
+    module: caller.module,
+    function: caller.fn,
+    line: caller.line,
+    message: message
+  }
+  
+  |data != null| => {
+    js(entry, data) {
+      Object.assign(entry, data);
+    }
+  }
+  
+  return js(entry) { return JSON.stringify(entry); }
+}
+
+expose fn debug(message, data) {
+  |shouldLog("debug")| => {
+    dec output = formatLog("debug", message, data)
+    js(output) { console.log(output); }
+  }
+}
+
+expose fn info(message, data) {
+  |shouldLog("info")| => {
+    dec output = formatLog("info", message, data)
+    js(output) { console.log(output); }
+  }
+}
+
+expose fn warn(message, data) {
+  |shouldLog("warn")| => {
+    dec output = formatLog("warn", message, data)
+    js(output) { console.warn(output); }
+  }
+}
+
+expose fn error(message, data) {
+  |shouldLog("error")| => {
+    dec output = formatLog("error", message, data)
+    js(output) { console.error(output); }
+  }
+}
+
+expose fn child(context) {
+  return {
+    debug: (msg, data) => debug(msg, { ...context, ...data }),
+    info: (msg, data) => info(msg, { ...context, ...data }),
+    warn: (msg, data) => warn(msg, { ...context, ...data }),
+    error: (msg, data) => error(msg, { ...context, ...data })
+  }
+}

package/stdlib/math.km

@@ -0,0 +1,120 @@
+// KimchiLang Standard Library - Math Functions
+
+expose fn _describe() {
+  return "Math utilities: abs, round, floor, ceil, trigonometry, etc."
+}
+
+expose dec PI = Math.PI
+expose dec E = Math.E
+
+expose fn abs(x) {
+  return Math.abs(x)
+}
+
+expose fn sign(x) {
+  return Math.sign(x)
+}
+
+expose fn round(x) {
+  return Math.round(x)
+}
+
+expose fn floor(x) {
+  return Math.floor(x)
+}
+
+expose fn ceil(x) {
+  return Math.ceil(x)
+}
+
+expose fn trunc(x) {
+  return Math.trunc(x)
+}
+
+expose fn pow(base, exponent) {
+  return Math.pow(base, exponent)
+}
+
+expose fn sqrt(x) {
+  return Math.sqrt(x)
+}
+
+expose fn cbrt(x) {
+  return Math.cbrt(x)
+}
+
+expose fn exp(x) {
+  return Math.exp(x)
+}
+
+expose fn log(x) {
+  return Math.log(x)
+}
+
+expose fn log10(x) {
+  return Math.log10(x)
+}
+
+expose fn log2(x) {
+  return Math.log2(x)
+}
+
+expose fn sin(x) {
+  return Math.sin(x)
+}
+
+expose fn cos(x) {
+  return Math.cos(x)
+}
+
+expose fn tan(x) {
+  return Math.tan(x)
+}
+
+expose fn asin(x) {
+  return Math.asin(x)
+}
+
+expose fn acos(x) {
+  return Math.acos(x)
+}
+
+expose fn atan(x) {
+  return Math.atan(x)
+}
+
+expose fn atan2(y, x) {
+  return Math.atan2(y, x)
+}
+
+expose fn random() {
+  return Math.random()
+}
+
+expose fn randomInt(minVal, maxVal) {
+  return Math.floor(Math.random() * (maxVal - minVal + 1)) + minVal
+}
+
+expose fn clamp(value, minVal, maxVal) {
+  return Math.min(Math.max(value, minVal), maxVal)
+}
+
+expose fn lerp(start, end, t) {
+  return start + (end - start) * t
+}
+
+expose fn degrees(radians) {
+  return radians * 180 / Math.PI
+}
+
+expose fn radians(deg) {
+  return deg * Math.PI / 180
+}
+
+expose fn isEven(n) {
+  return n % 2 == 0
+}
+
+expose fn isOdd(n) {
+  return n % 2 != 0
+}