kimchilang 1.0.1

package/examples/secrets.static.js

@@ -0,0 +1,30 @@
+// Generated from .static file
+
+// Secret wrapper class
+class _Secret {
+  constructor(value) { this._value = value; }
+  toString() { return "********"; }
+  valueOf() { return this._value; }
+  get value() { return this._value; }
+  [Symbol.toPrimitive](hint) { return hint === "string" ? "********" : this._value; }
+}
+function _secret(value) { return new _Secret(value); }
+
+export const AppName = "MySecureApp";
+
+export const Version = "1.0.0";
+
+export const MaxConnections = 100;
+
+export const Timeout = 5000;
+
+export const DebugMode = false;
+
+export const ApiKey = _secret("sk-1234567890abcdef");
+
+export const InternalPort = _secret(8443);
+
+export const DatabaseConfig = { host: "localhost", port: 5432, database: "myapp", username: _secret("admin"), password: _secret("super-secret-password") };
+
+export const ServiceConfig = { name: "api-service", url: "https://api.example.com", token: _secret("bearer-token-12345"), retries: 3 };
+

package/examples/shell-example.mjs

@@ -0,0 +1,144 @@
+// KimchiLang stdlib extensions
+if (!Array.prototype._kmExtended) {
+  Array.prototype._kmExtended = true;
+  Array.prototype.first = function() { return this[0]; };
+  Array.prototype.last = function() { return this[this.length - 1]; };
+  Array.prototype.isEmpty = function() { return this.length === 0; };
+  Array.prototype.sum = function() { return this.reduce((a, b) => a + b, 0); };
+  Array.prototype.product = function() { return this.reduce((a, b) => a * b, 1); };
+  Array.prototype.average = function() { return this.reduce((a, b) => a + b, 0) / this.length; };
+  Array.prototype.max = function() { return Math.max(...this); };
+  Array.prototype.min = function() { return Math.min(...this); };
+  Array.prototype.take = function(n) { return this.slice(0, n); };
+  Array.prototype.drop = function(n) { return this.slice(n); };
+  Array.prototype.flatten = function() { return this.flat(Infinity); };
+  Array.prototype.unique = function() { return [...new Set(this)]; };
+}
+if (!String.prototype._kmExtended) {
+  String.prototype._kmExtended = true;
+  String.prototype.isEmpty = function() { return this.length === 0; };
+  String.prototype.isBlank = function() { return this.trim().length === 0; };
+  String.prototype.toChars = function() { return this.split(""); };
+  String.prototype.toLines = function() { return this.split("\n"); };
+  String.prototype.capitalize = function() { return this.length === 0 ? this : this[0].toUpperCase() + this.slice(1); };
+}
+const _obj = {
+  keys: (o) => Object.keys(o),
+  values: (o) => Object.values(o),
+  entries: (o) => Object.entries(o),
+  fromEntries: (arr) => Object.fromEntries(arr),
+  has: (o, k) => Object.hasOwn(o, k),
+  freeze: (o) => Object.freeze(o),
+  isEmpty: (o) => Object.keys(o).length === 0,
+  size: (o) => Object.keys(o).length,
+};
+
+function error(message, name = "Error") {
+  const e = new Error(message);
+  e.name = name;
+  return e;
+}
+error.create = (name) => {
+  const fn = (message) => error(message, name);
+  Object.defineProperty(fn, "name", { value: name, writable: false });
+  return fn;
+};
+
+class _Secret {
+  constructor(value) { this._value = value; }
+  toString() { return "********"; }
+  valueOf() { return this._value; }
+  get value() { return this._value; }
+  [Symbol.toPrimitive](hint) { return hint === "string" ? "********" : this._value; }
+}
+function _secret(value) { return new _Secret(value); }
+
+function _deepFreeze(obj) {
+  if (obj === null || typeof obj !== "object") return obj;
+  Object.keys(obj).forEach(key => _deepFreeze(obj[key]));
+  return Object.freeze(obj);
+}
+
+async function _shell(command, inputs = {}) {
+  const { exec } = await import("child_process");
+  const { promisify } = await import("util");
+  const execAsync = promisify(exec);
+  // Interpolate inputs into command
+  let cmd = command;
+  for (const [key, value] of Object.entries(inputs)) {
+    cmd = cmd.replace(new RegExp("\\$" + key + "\\b", "g"), String(value));
+  }
+  try {
+    const { stdout, stderr } = await execAsync(cmd);
+    return { stdout: stdout.trim(), stderr: stderr.trim(), exitCode: 0 };
+  } catch (error) {
+    return { stdout: error.stdout?.trim() || "", stderr: error.stderr?.trim() || error.message, exitCode: error.code || 1 };
+  }
+}
+
+// Testing framework
+const _tests = [];
+let _currentDescribe = null;
+function _describe(name, fn) {
+  const prev = _currentDescribe;
+  _currentDescribe = { name, tests: [], parent: prev };
+  fn();
+  if (prev) { prev.tests.push(_currentDescribe); }
+  else { _tests.push(_currentDescribe); }
+  _currentDescribe = prev;
+}
+function _test(name, fn) {
+  const test = { name, fn, describe: _currentDescribe };
+  if (_currentDescribe) { _currentDescribe.tests.push(test); }
+  else { _tests.push(test); }
+}
+function _expect(actual) {
+  return {
+    toBe(expected) { if (actual !== expected) throw new Error(`Expected ${JSON.stringify(expected)} but got ${JSON.stringify(actual)}`); },
+    toEqual(expected) { if (JSON.stringify(actual) !== JSON.stringify(expected)) throw new Error(`Expected ${JSON.stringify(expected)} to equal ${JSON.stringify(actual)}`); },
+    toContain(item) { if (!actual.includes(item)) throw new Error(`Expected ${JSON.stringify(actual)} to contain ${JSON.stringify(item)}`); },
+    toBeNull() { if (actual !== null) throw new Error(`Expected null but got ${JSON.stringify(actual)}`); },
+    toBeTruthy() { if (!actual) throw new Error(`Expected truthy but got ${JSON.stringify(actual)}`); },
+    toBeFalsy() { if (actual) throw new Error(`Expected falsy but got ${JSON.stringify(actual)}`); },
+    toBeGreaterThan(n) { if (actual <= n) throw new Error(`Expected ${actual} > ${n}`); },
+    toBeLessThan(n) { if (actual >= n) throw new Error(`Expected ${actual} < ${n}`); },
+    toHaveLength(n) { if (actual.length !== n) throw new Error(`Expected length ${n} but got ${actual.length}`); },
+    toMatch(pattern) { if (!pattern.test(actual)) throw new Error(`Expected ${JSON.stringify(actual)} to match ${pattern}`); },
+    toThrow(msg) { try { actual(); throw new Error("Expected to throw"); } catch(e) { if (msg && !e.message.includes(msg)) throw new Error(`Expected error containing "${msg}" but got "${e.message}"`); } },
+  };
+}
+function _assert(condition, message) { if (!condition) throw new Error(message); }
+async function _runTests() {
+  let passed = 0, failed = 0;
+  async function runItem(item, indent = "") {
+    if (item.fn) {
+      try { await item.fn(); console.log(indent + "✓ " + item.name); passed++; }
+      catch (e) { console.log(indent + "✗ " + item.name); console.log(indent + "  " + e.message); failed++; }
+    } else {
+      console.log(indent + item.name);
+      for (const t of item.tests) await runItem(t, indent + "  ");
+    }
+  }
+  for (const item of _tests) await runItem(item);
+  console.log(`\n${passed + failed} tests, ${passed} passed, ${failed} failed`);
+  return { passed, failed };
+}
+
+export default function(_opts = {}) {
+  async function listFiles() {
+    const result = _deepFreeze(await _shell("ls -la"));
+    console.log(result?.stdout);
+  }
+  
+  async function getDate() {
+    const result = _deepFreeze(await _shell("date"));
+    return result?.stdout;
+  }
+  
+  async function findFiles(pattern) {
+    const result = _deepFreeze(await _shell("find . -name \"$pattern\"", { pattern }));
+    return result?.stdout;
+  }
+  
+  listFiles();
+}

package/examples/shell_example.km

@@ -0,0 +1,19 @@
+// Example of shell interop in KimchiLang
+
+fn listFiles() {
+  dec result = shell { ls -la }
+  print result.stdout
+}
+
+fn getDate() {
+  dec result = shell { date }
+  return result.stdout
+}
+
+// Shell with inputs
+fn findFiles(pattern) {
+  dec result = shell(pattern) { find . -name "$pattern" }
+  return result.stdout
+}
+
+listFiles()

package/examples/stdlib_test.km

@@ -0,0 +1,22 @@
+// Test stdlib extensions on literals
+
+expose fn _describe() {
+  return "Test that literals have stdlib methods"
+}
+
+// Array extensions
+dec nums = [1, 2, 3, 4, 5]
+print "Array tests:"
+print "first: ${nums.first()}"
+print "last: ${nums.last()}"
+print "sum: ${nums.sum()}"
+print "average: ${nums.average()}"
+print "max: ${nums.max()}"
+print "min: ${nums.min()}"
+
+// String extensions
+dec text = "hello world"
+print "\nString tests:"
+print "capitalize: ${text.capitalize()}"
+print "isEmpty: ${text.isEmpty()}"
+print "isBlank: ${"   ".isBlank()}"

package/examples/test_example.km

@@ -0,0 +1,69 @@
+// Example test file demonstrating KimchiLang's built-in testing framework
+
+// Helper function to test
+fn add(a, b) {
+  return a + b
+}
+
+fn multiply(a, b) {
+  return a * b
+}
+
+fn greet(name) {
+  return "Hello, ${name}!"
+}
+
+// Simple tests
+test "addition works" {
+  expect(add(2, 3)).toBe(5)
+  expect(add(-1, 1)).toBe(0)
+}
+
+test "multiplication works" {
+  expect(multiply(3, 4)).toBe(12)
+  expect(multiply(0, 100)).toBe(0)
+}
+
+// Grouped tests with describe
+describe "String functions" {
+  test "greet returns correct message" {
+    expect(greet("World")).toBe("Hello, World!")
+  }
+  
+  test "string contains check" {
+    dec message = greet("Alice")
+    expect(message).toContain("Alice")
+  }
+}
+
+describe "Array operations" {
+  test "array length" {
+    dec arr = [1, 2, 3, 4, 5]
+    expect(arr).toHaveLength(5)
+  }
+  
+  test "array contains" {
+    dec fruits = ["apple", "banana", "cherry"]
+    expect(fruits).toContain("banana")
+  }
+}
+
+// Using assert
+test "assert examples" {
+  assert 1 + 1 == 2, "Basic math should work"
+  assert true, "True should be truthy"
+}
+
+// Testing comparisons
+test "comparison matchers" {
+  expect(10).toBeGreaterThan(5)
+  expect(3).toBeLessThan(7)
+}
+
+// Testing truthiness
+test "truthy and falsy" {
+  expect(true).toBeTruthy()
+  expect(false).toBeFalsy()
+  expect(null).toBeFalsy()
+  expect("hello").toBeTruthy()
+}

package/examples/testing/README.md

@@ -0,0 +1,88 @@
+# KimchiLang Testing Examples
+
+This directory demonstrates how to write unit tests in KimchiLang.
+
+## Running Tests
+
+```bash
+# Run math tests
+kimchi examples.testing.math.test
+
+# Run user service tests (with mocked dependencies)
+kimchi examples.testing.user_service.test
+```
+
+## Test Syntax
+
+### Basic Test
+
+```kimchi
+test "description of test" {
+  expect(actual).toBe(expected)
+}
+```
+
+### Grouped Tests with Describe
+
+```kimchi
+describe "Feature Name" {
+  test "specific behavior" {
+    expect(result).toBe(expected)
+  }
+  
+  test "another behavior" {
+    expect(other).toEqual(expected)
+  }
+}
+```
+
+### Available Matchers
+
+| Matcher | Description |
+|---------|-------------|
+| `toBe(value)` | Strict equality (`===`) |
+| `toEqual(value)` | Deep equality (JSON comparison) |
+| `toContain(item)` | Array/string contains item |
+| `toBeNull()` | Value is `null` |
+| `toBeTruthy()` | Value is truthy |
+| `toBeFalsy()` | Value is falsy |
+| `toBeGreaterThan(n)` | Value > n |
+| `toBeLessThan(n)` | Value < n |
+| `toHaveLength(n)` | Array/string length equals n |
+| `toMatch(regex)` | String matches regex |
+| `toThrow(message)` | Function throws error containing message |
+
+### Assert Statement
+
+```kimchi
+assert condition, "Error message if false"
+```
+
+## Testing with Mocks
+
+KimchiLang's dependency injection makes mocking easy:
+
+```kimchi
+// Create a mock
+dec mockDep = {
+  someMethod: (arg) => "mocked result"
+}
+
+// Inject mock when importing
+as myModule dep path.to.module({
+  "path.to.dependency": mockDep
+})
+
+// Now myModule uses the mock instead of real dependency
+test "uses mock" {
+  expect(myModule.doSomething()).toBe("mocked result")
+}
+```
+
+## Files in This Directory
+
+- `math.km` - Math utility functions
+- `math.test.km` - Tests for math module
+- `http_client.km` - Simple HTTP client stub
+- `user_service.km` - User service that depends on HTTP client
+- `user_service.test.km` - Tests with mocked HTTP client

package/examples/testing/http_client.km

@@ -0,0 +1,18 @@
+// HTTP client module - simple stub for demonstration
+// In real usage, this would make actual HTTP requests
+
+expose fn get(url) {
+  return { status: 200, data: null }
+}
+
+expose fn post(url, body) {
+  return { status: 201, data: body }
+}
+
+expose fn put(url, body) {
+  return { status: 200, data: body }
+}
+
+expose fn delete(url) {
+  return { status: 200 }
+}

package/examples/testing/math.km

@@ -0,0 +1,48 @@
+// Math utility module
+// Example module to demonstrate unit testing
+
+expose fn add(a, b) {
+  return a + b
+}
+
+expose fn subtract(a, b) {
+  return a - b
+}
+
+expose fn multiply(a, b) {
+  return a * b
+}
+
+expose fn divide(a, b) {
+  if b == 0 {
+    throw js { return new Error("Cannot divide by zero"); }
+  }
+  return a / b
+}
+
+expose fn factorial(n) {
+  |n < 0| => throw js { return new Error("Factorial not defined for negative numbers"); }
+  |n <= 1| => return 1
+  |true| => return n * factorial(n - 1)
+}
+
+expose fn fibonacci(n) {
+  |n <= 0| => return 0
+  |n == 1| => return 1
+  |true| => return fibonacci(n - 1) + fibonacci(n - 2)
+}
+
+expose fn isPrime(n) {
+  |n <= 1| => return false
+  |n <= 3| => return true
+  |n % 2 == 0| => return false
+  
+  dec i = 3
+  // Use JS for the loop since we need mutation
+  return js(n, i) {
+    for (let i = 3; i * i <= n; i += 2) {
+      if (n % i === 0) return false;
+    }
+    return true;
+  }
+}

package/examples/testing/math.test.km

@@ -0,0 +1,93 @@
+// Unit tests for math.km module
+// Run with: kimchi examples.testing.math.test
+
+as math dep examples.testing.math
+
+// Test basic arithmetic operations
+describe "Basic Arithmetic" {
+  test "add returns correct sum" {
+    expect(math.add(2, 3)).toBe(5)
+    expect(math.add(-1, 1)).toBe(0)
+    expect(math.add(0, 0)).toBe(0)
+  }
+  
+  test "subtract returns correct difference" {
+    expect(math.subtract(5, 3)).toBe(2)
+    expect(math.subtract(3, 5)).toBe(-2)
+    expect(math.subtract(0, 0)).toBe(0)
+  }
+  
+  test "multiply returns correct product" {
+    expect(math.multiply(3, 4)).toBe(12)
+    expect(math.multiply(-2, 3)).toBe(-6)
+    expect(math.multiply(0, 100)).toBe(0)
+  }
+  
+  test "divide returns correct quotient" {
+    expect(math.divide(10, 2)).toBe(5)
+    expect(math.divide(7, 2)).toBe(3.5)
+    expect(math.divide(-6, 2)).toBe(-3)
+  }
+  
+  test "divide by zero throws error" {
+    expect(() => math.divide(10, 0)).toThrow("Cannot divide by zero")
+  }
+}
+
+// Test factorial function
+describe "Factorial" {
+  test "factorial of 0 is 1" {
+    expect(math.factorial(0)).toBe(1)
+  }
+  
+  test "factorial of 1 is 1" {
+    expect(math.factorial(1)).toBe(1)
+  }
+  
+  test "factorial of positive numbers" {
+    expect(math.factorial(5)).toBe(120)
+    expect(math.factorial(6)).toBe(720)
+  }
+  
+  test "factorial of negative throws error" {
+    expect(() => math.factorial(-1)).toThrow("negative")
+  }
+}
+
+// Test fibonacci function
+describe "Fibonacci" {
+  test "fibonacci base cases" {
+    expect(math.fibonacci(0)).toBe(0)
+    expect(math.fibonacci(1)).toBe(1)
+  }
+  
+  test "fibonacci sequence" {
+    expect(math.fibonacci(2)).toBe(1)
+    expect(math.fibonacci(3)).toBe(2)
+    expect(math.fibonacci(4)).toBe(3)
+    expect(math.fibonacci(5)).toBe(5)
+    expect(math.fibonacci(10)).toBe(55)
+  }
+}
+
+// Test prime checking
+describe "Prime Numbers" {
+  test "small primes are identified" {
+    expect(math.isPrime(2)).toBe(true)
+    expect(math.isPrime(3)).toBe(true)
+    expect(math.isPrime(5)).toBe(true)
+    expect(math.isPrime(7)).toBe(true)
+  }
+  
+  test "non-primes are identified" {
+    expect(math.isPrime(0)).toBe(false)
+    expect(math.isPrime(1)).toBe(false)
+    expect(math.isPrime(4)).toBe(false)
+    expect(math.isPrime(9)).toBe(false)
+  }
+  
+  test "larger primes" {
+    expect(math.isPrime(97)).toBe(true)
+    expect(math.isPrime(100)).toBe(false)
+  }
+}

package/examples/testing/user_service.km

@@ -0,0 +1,29 @@
+// User service module - demonstrates testing with dependency injection
+// This module depends on an HTTP client that can be mocked in tests
+
+as http dep examples.testing.http_client
+
+expose fn getUser(id) {
+  dec response = http.get("/users/${id}")
+  return response.data
+}
+
+expose fn createUser(name, email) {
+  dec response = http.post("/users", { name: name, email: email })
+  return response.data
+}
+
+expose fn updateUser(id, updates) {
+  dec response = http.put("/users/${id}", updates)
+  return response.data
+}
+
+expose fn deleteUser(id) {
+  dec response = http.delete("/users/${id}")
+  return response.status == 200
+}
+
+expose fn getUsersByRole(role) {
+  dec response = http.get("/users?role=${role}")
+  return response.data
+}

package/examples/testing/user_service.test.km

@@ -0,0 +1,72 @@
+// Unit tests for user-service.km with mocked HTTP client
+// Demonstrates dependency injection for testing
+// Run with: kimchi examples.testing.user-service.test
+
+// Create a mock HTTP client
+dec mockHttp = {
+  get: (url) => {
+    |url == "/users/1"| => return { status: 200, data: { id: 1, name: "Alice", email: "alice@test.com" } }
+    |url == "/users?role=admin"| => return { status: 200, data: [{ id: 1, name: "Admin" }] }
+    |true| => return { status: 404, data: null }
+  },
+  post: (url, body) => {
+    return { status: 201, data: { id: 99, ...body } }
+  },
+  put: (url, body) => {
+    return { status: 200, data: { id: 1, ...body } }
+  },
+  delete: (url) => {
+    return { status: 200 }
+  }
+}
+
+// Import user service with mocked HTTP client
+as userService dep examples.testing.user_service({
+  "examples.testing.http_client": mockHttp
+})
+
+describe "User Service" {
+  describe "getUser" {
+    test "returns user data for valid id" {
+      dec user = userService.getUser(1)
+      expect(user.name).toBe("Alice")
+      expect(user.email).toBe("alice@test.com")
+    }
+    
+    test "returns null for invalid id" {
+      dec user = userService.getUser(999)
+      expect(user).toBeNull()
+    }
+  }
+  
+  describe "createUser" {
+    test "creates user with provided data" {
+      dec user = userService.createUser("Bob", "bob@test.com")
+      expect(user.name).toBe("Bob")
+      expect(user.email).toBe("bob@test.com")
+      expect(user.id).toBe(99)
+    }
+  }
+  
+  describe "updateUser" {
+    test "updates user data" {
+      dec user = userService.updateUser(1, { name: "Alice Updated" })
+      expect(user.name).toBe("Alice Updated")
+    }
+  }
+  
+  describe "deleteUser" {
+    test "returns true on successful delete" {
+      dec result = userService.deleteUser(1)
+      expect(result).toBe(true)
+    }
+  }
+  
+  describe "getUsersByRole" {
+    test "returns users filtered by role" {
+      dec admins = userService.getUsersByRole("admin")
+      expect(admins).toHaveLength(1)
+      expect(admins[0].name).toBe("Admin")
+    }
+  }
+}