kimchilang 1.0.1

package/stdlib/bitwise.km

@@ -0,0 +1,38 @@
+// KimchiLang Bitwise Operations
+// Usage: as bit dep stdlib.bitwise
+// Provides wrapper functions for JavaScript bitwise operators
+
+// Bitwise AND: a & b
+expose fn band(a, b) {
+  return js(a, b) { return a & b; }
+}
+
+// Bitwise OR: a | b
+expose fn bor(a, b) {
+  return js(a, b) { return a | b; }
+}
+
+// Bitwise XOR: a ^ b
+expose fn bxor(a, b) {
+  return js(a, b) { return a ^ b; }
+}
+
+// Bitwise NOT: ~a
+expose fn bnot(a) {
+  return js(a) { return ~a; }
+}
+
+// Left shift: a << b
+expose fn lshift(a, b) {
+  return js(a, b) { return a << b; }
+}
+
+// Right shift (sign-propagating): a >> b
+expose fn rshift(a, b) {
+  return js(a, b) { return a >> b; }
+}
+
+// Unsigned right shift: a >>> b
+expose fn urshift(a, b) {
+  return js(a, b) { return a >>> b; }
+}

package/stdlib/console.km

@@ -0,0 +1,49 @@
+// KimchiLang Standard Library - Console Functions
+
+expose fn _describe() {
+  return "Console/IO utilities: log, error, warn, table, etc."
+}
+
+expose fn log(message) {
+  console.log(message)
+}
+
+expose fn error(message) {
+  console.error(message)
+}
+
+expose fn warn(message) {
+  console.warn(message)
+}
+
+expose fn info(message) {
+  console.info(message)
+}
+
+expose fn debug(message) {
+  console.debug(message)
+}
+
+expose fn table(data) {
+  console.table(data)
+}
+
+expose fn clear() {
+  console.clear()
+}
+
+expose fn time(label) {
+  console.time(label)
+}
+
+expose fn timeEnd(label) {
+  console.timeEnd(label)
+}
+
+expose fn trace(message) {
+  console.trace(message)
+}
+
+expose fn dir(obj) {
+  console.dir(obj)
+}

package/stdlib/date.km

@@ -0,0 +1,97 @@
+// KimchiLang Standard Library - Date Functions
+
+expose fn _describe() {
+  return "Date/time utilities: now, format, parse, diff, etc."
+}
+
+expose fn now() {
+  return Date.now()
+}
+
+expose fn create(value) {
+  return new Date(value)
+}
+
+expose fn getYear(date) {
+  return date.getFullYear()
+}
+
+expose fn getMonth(date) {
+  return date.getMonth()
+}
+
+expose fn getDay(date) {
+  return date.getDate()
+}
+
+expose fn getDayOfWeek(date) {
+  return date.getDay()
+}
+
+expose fn getHours(date) {
+  return date.getHours()
+}
+
+expose fn getMinutes(date) {
+  return date.getMinutes()
+}
+
+expose fn getSeconds(date) {
+  return date.getSeconds()
+}
+
+expose fn getTime(date) {
+  return date.getTime()
+}
+
+expose fn toISO(date) {
+  return date.toISOString()
+}
+
+expose fn toLocaleDateString(date) {
+  return date.toDateString()
+}
+
+expose fn parse(str) {
+  return new Date(str)
+}
+
+expose fn addMs(date, ms) {
+  return new Date(date.getTime() + ms)
+}
+
+expose fn addSeconds(date, seconds) {
+  return new Date(date.getTime() + seconds * 1000)
+}
+
+expose fn addMinutes(date, minutes) {
+  return new Date(date.getTime() + minutes * 60 * 1000)
+}
+
+expose fn addHours(date, hours) {
+  return new Date(date.getTime() + hours * 60 * 60 * 1000)
+}
+
+expose fn addDays(date, days) {
+  return new Date(date.getTime() + days * 24 * 60 * 60 * 1000)
+}
+
+expose fn diffMs(date1, date2) {
+  return date1.getTime() - date2.getTime()
+}
+
+expose fn diffDays(date1, date2) {
+  return (date1.getTime() - date2.getTime()) / (24 * 60 * 60 * 1000)
+}
+
+expose fn isBefore(date1, date2) {
+  return date1.getTime() < date2.getTime()
+}
+
+expose fn isAfter(date1, date2) {
+  return date1.getTime() > date2.getTime()
+}
+
+expose fn isSameDay(date1, date2) {
+  return date1.toDateString() == date2.toDateString()
+}

package/stdlib/function.km

@@ -0,0 +1,44 @@
+// KimchiLang Standard Library - Function Utilities
+
+expose fn _describe() {
+  return "Function utilities: compose, pipe, identity, constant, etc."
+}
+
+expose fn identity(x) {
+  return x
+}
+
+expose fn constant(x) {
+  return () => x
+}
+
+expose fn negate(predicate) {
+  return (x) => !predicate(x)
+}
+
+expose fn flip(f) {
+  return (a, b) => f(b, a)
+}
+
+expose fn compose(f, g) {
+  return (x) => f(g(x))
+}
+
+expose fn pipe(f, g) {
+  return (x) => g(f(x))
+}
+
+expose fn tap(f) {
+  return (x) => {
+    f(x)
+    return x
+  }
+}
+
+expose fn unary(f) {
+  return (x) => f(x)
+}
+
+expose fn binary(f) {
+  return (a, b) => f(a, b)
+}

package/stdlib/http.km

@@ -0,0 +1,197 @@
+// KimchiLang Standard Library - HTTP Client
+// Wrapper for Node.js http/https modules with a simple, promise-based API
+
+expose fn _describe() {
+  return "HTTP client: get, post, put, patch, delete, request"
+}
+
+// Make an HTTP GET request
+expose async fn get(url, options) {
+  return await request(url, { ...options, method: "GET" })
+}
+
+// Make an HTTP POST request
+expose async fn post(url, body, options) {
+  return await request(url, { ...options, method: "POST", body: body })
+}
+
+// Make an HTTP PUT request
+expose async fn put(url, body, options) {
+  return await request(url, { ...options, method: "PUT", body: body })
+}
+
+// Make an HTTP PATCH request
+expose async fn patch(url, body, options) {
+  return await request(url, { ...options, method: "PATCH", body: body })
+}
+
+// Make an HTTP DELETE request
+expose async fn del(url, options) {
+  return await request(url, { ...options, method: "DELETE" })
+}
+
+// Generic HTTP request function
+expose async fn request(url, options) {
+  dec opts = options ? options : {}
+  dec method = opts.method ? opts.method : "GET"
+  dec headers = opts.headers ? opts.headers : {}
+  dec body = opts.body
+  dec timeout = opts.timeout ? opts.timeout : 30000
+  
+  // Auto-set content-type for JSON bodies
+  dec finalHeaders = body and not headers["Content-Type"] 
+    ? { ...headers, "Content-Type": "application/json" }
+    : headers
+  
+  dec result = js(url, method, finalHeaders, body, timeout) {
+    return new Promise((resolve, reject) => {
+      const urlObj = new URL(url);
+      const isHttps = urlObj.protocol === 'https:';
+      const lib = isHttps ? require('https') : require('http');
+      
+      const reqOptions = {
+        hostname: urlObj.hostname,
+        port: urlObj.port || (isHttps ? 443 : 80),
+        path: urlObj.pathname + urlObj.search,
+        method: method,
+        headers: finalHeaders,
+        timeout: timeout,
+      };
+      
+      const req = lib.request(reqOptions, (res) => {
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => {
+          let parsedBody = data;
+          const contentType = res.headers['content-type'] || '';
+          if (contentType.includes('application/json')) {
+            try {
+              parsedBody = JSON.parse(data);
+            } catch (e) {
+              // Keep as string if JSON parse fails
+            }
+          }
+          resolve({
+            status: res.statusCode,
+            statusText: res.statusMessage,
+            headers: res.headers,
+            body: parsedBody,
+            ok: res.statusCode >= 200 && res.statusCode < 300,
+          });
+        });
+      });
+      
+      req.on('error', (e) => reject(e));
+      req.on('timeout', () => {
+        req.destroy();
+        reject(new Error('Request timeout'));
+      });
+      
+      if (body) {
+        const bodyStr = typeof body === 'string' ? body : JSON.stringify(body);
+        req.write(bodyStr);
+      }
+      
+      req.end();
+    });
+  }
+  
+  return result
+}
+
+// Helper to build query strings
+expose fn queryString(params) {
+  dec result = js(params) {
+    return Object.entries(params)
+      .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
+      .join('&');
+  }
+  return result
+}
+
+// Helper to build URL with query params
+expose fn buildUrl(baseUrl, params) {
+  dec qs = queryString(params)
+  if qs {
+    return "${baseUrl}?${qs}"
+  }
+  return baseUrl
+}
+
+// Create a client with default options (base URL, headers, etc.)
+expose fn createClient(baseOptions) {
+  dec baseUrl = baseOptions.baseUrl ? baseOptions.baseUrl : ""
+  dec defaultHeaders = baseOptions.headers ? baseOptions.headers : {}
+  dec defaultTimeout = baseOptions.timeout ? baseOptions.timeout : 30000
+  
+  dec clientGet = (path, options) => {
+    dec url = "${baseUrl}${path}"
+    dec opts = options ? options : {}
+    dec mergedHeaders = { ...defaultHeaders, ...(opts.headers ? opts.headers : {}) }
+    return request(url, { 
+      ...opts, 
+      method: "GET", 
+      headers: mergedHeaders,
+      timeout: opts.timeout ? opts.timeout : defaultTimeout
+    })
+  }
+  
+  dec clientPost = (path, body, options) => {
+    dec url = "${baseUrl}${path}"
+    dec opts = options ? options : {}
+    dec mergedHeaders = { ...defaultHeaders, ...(opts.headers ? opts.headers : {}) }
+    return request(url, { 
+      ...opts, 
+      method: "POST", 
+      body: body,
+      headers: mergedHeaders,
+      timeout: opts.timeout ? opts.timeout : defaultTimeout
+    })
+  }
+  
+  dec clientPut = (path, body, options) => {
+    dec url = "${baseUrl}${path}"
+    dec opts = options ? options : {}
+    dec mergedHeaders = { ...defaultHeaders, ...(opts.headers ? opts.headers : {}) }
+    return request(url, { 
+      ...opts, 
+      method: "PUT", 
+      body: body,
+      headers: mergedHeaders,
+      timeout: opts.timeout ? opts.timeout : defaultTimeout
+    })
+  }
+  
+  dec clientPatch = (path, body, options) => {
+    dec url = "${baseUrl}${path}"
+    dec opts = options ? options : {}
+    dec mergedHeaders = { ...defaultHeaders, ...(opts.headers ? opts.headers : {}) }
+    return request(url, { 
+      ...opts, 
+      method: "PATCH", 
+      body: body,
+      headers: mergedHeaders,
+      timeout: opts.timeout ? opts.timeout : defaultTimeout
+    })
+  }
+  
+  dec clientDel = (path, options) => {
+    dec url = "${baseUrl}${path}"
+    dec opts = options ? options : {}
+    dec mergedHeaders = { ...defaultHeaders, ...(opts.headers ? opts.headers : {}) }
+    return request(url, { 
+      ...opts, 
+      method: "DELETE", 
+      headers: mergedHeaders,
+      timeout: opts.timeout ? opts.timeout : defaultTimeout
+    })
+  }
+  
+  return {
+    get: clientGet,
+    post: clientPost,
+    put: clientPut,
+    patch: clientPatch,
+    del: clientDel
+  }
+}