@koi-language/koi 1.0.0

package/examples/test-await.koi

@@ -0,0 +1,22 @@
+package "test"
+
+role Worker { can execute }
+
+Agent A : Worker {
+on test(args: Json) {
+const x = 5
+return { x: x }
+}
+}
+
+Team T {
+a = A
+}
+
+Agent B : Worker {
+uses Team T
+on start(args: Json) {
+const result = await send peers.event("test").role(Worker).any()({}) timeout 2s
+return result
+}
+}

package/examples/test-crypto-sha256.koi

@@ -0,0 +1,196 @@
+package "test.crypto.sha256"
+
+// Import crypto-js from npm for SHA256 hashing
+import "crypto-js"
+
+role SecurityAgent { can hash, can verify }
+
+Agent HashAgent : SecurityAgent {
+  on hashPassword(args: Json) {
+    console.log("=".repeat(60))
+    console.log("Crypto SHA256 Test - Password Hashing")
+    console.log("=".repeat(60))
+
+    const password = args.password
+    console.log("\nOriginal password:", password)
+
+    // Hash with SHA256 (using chained method syntax)
+    const hash = crypto_js.SHA256(password).toString()
+    console.log("SHA256 hash:", hash)
+
+    // Hash with SHA512 for comparison
+    const hash512 = crypto_js.SHA512(password).toString()
+    console.log("SHA512 hash:", hash512)
+
+    // Hash with MD5 (less secure, for demonstration)
+    const hashMD5 = crypto_js.MD5(password).toString()
+    console.log("MD5 hash:", hashMD5)
+
+    return {
+      password: password,
+      sha256: hash,
+      sha512: hash512,
+      md5: hashMD5
+    }
+  }
+
+  on verifyHash(args: Json) {
+    console.log("\n" + "=".repeat(60))
+    console.log("Hash Verification Test")
+    console.log("=".repeat(60))
+
+    const input = args.input
+    const expectedHash = args.expectedHash
+
+    console.log("\nInput:", input)
+    console.log("Expected hash:", expectedHash)
+
+    // Calculate hash (using chained method syntax)
+    const calculatedHash = crypto_js.SHA256(input).toString()
+    console.log("Calculated hash:", calculatedHash)
+
+    // Verify
+    const isValid = calculatedHash == expectedHash
+    console.log("Hash matches:", isValid)
+
+    return {
+      input: input,
+      expectedHash: expectedHash,
+      calculatedHash: calculatedHash,
+      isValid: isValid
+    }
+  }
+
+  on hashData(args: Json) {
+    console.log("\n" + "=".repeat(60))
+    console.log("Data Integrity Test - JSON Hashing")
+    console.log("=".repeat(60))
+
+    const data = args.data
+    console.log("\nOriginal data:", JSON.stringify(data))
+
+    // Convert to JSON string and hash (using chained method syntax)
+    const dataString = JSON.stringify(data)
+    const hash = crypto_js.SHA256(dataString).toString()
+    console.log("SHA256 hash:", hash)
+
+    // Simulate data tampering
+    const tamperedData = { name: data.name, age: 99, email: data.email }
+    const tamperedString = JSON.stringify(tamperedData)
+    const tamperedHash = crypto_js.SHA256(tamperedString).toString()
+    console.log("\nTampered data:", JSON.stringify(tamperedData))
+    console.log("Tampered hash:", tamperedHash)
+    console.log("Hashes match:", hash == tamperedHash)
+
+    return {
+      original: {
+        data: data,
+        hash: hash
+      },
+      tampered: {
+        data: tamperedData,
+        hash: tamperedHash
+      },
+      isCompromised: hash != tamperedHash
+    }
+  }
+
+  on compareAlgorithms(args: Json) {
+    console.log("\n" + "=".repeat(60))
+    console.log("Algorithm Comparison Test")
+    console.log("=".repeat(60))
+
+    const text = args.text
+    console.log("\nText to hash:", text)
+
+    // Hash with different algorithms (using chained method syntax)
+    const md5 = crypto_js.MD5(text).toString()
+    const sha1 = crypto_js.SHA1(text).toString()
+    const sha256 = crypto_js.SHA256(text).toString()
+    const sha512 = crypto_js.SHA512(text).toString()
+    const sha3 = crypto_js.SHA3(text).toString()
+
+    console.log("\nMD5 (32 chars):", md5)
+    console.log("SHA1 (40 chars):", sha1)
+    console.log("SHA256 (64 chars):", sha256)
+    console.log("SHA512 (128 chars):", sha512)
+    console.log("SHA3 (64 chars):", sha3)
+
+    console.log("\nHash lengths:")
+    console.log("  MD5:", md5.length, "characters")
+    console.log("  SHA1:", sha1.length, "characters")
+    console.log("  SHA256:", sha256.length, "characters")
+    console.log("  SHA512:", sha512.length, "characters")
+    console.log("  SHA3:", sha3.length, "characters")
+
+    return {
+      text: text,
+      hashes: {
+        md5: md5,
+        sha1: sha1,
+        sha256: sha256,
+        sha512: sha512,
+        sha3: sha3
+      }
+    }
+  }
+}
+
+Team HashTeam {
+  hasher = HashAgent
+}
+
+Agent Coordinator : SecurityAgent {
+  uses Team HashTeam
+
+  on runTests(args: Json) {
+    console.log("\n" + "█".repeat(60))
+    console.log("█" + " ".repeat(58) + "█")
+    console.log("█" + "  Crypto-JS SHA256 Integration Test Suite".padEnd(58) + "█")
+    console.log("█" + " ".repeat(58) + "█")
+    console.log("█".repeat(60))
+
+    // Test 1: Hash password
+    const result1 = await send peers.event("hashPassword").role(SecurityAgent).any()({
+      password: "MySecurePassword123!"
+    }) timeout 10s
+
+    // Test 2: Verify hash
+    const result2 = await send peers.event("verifyHash").role(SecurityAgent).any()({
+      input: "MySecurePassword123!",
+      expectedHash: result1.sha256
+    }) timeout 10s
+
+    // Test 3: Hash structured data
+    const result3 = await send peers.event("hashData").role(SecurityAgent).any()({
+      data: {
+        name: "Alice",
+        age: 30,
+        email: "alice@example.com"
+      }
+    }) timeout 10s
+
+    // Test 4: Compare algorithms
+    const result4 = await send peers.event("compareAlgorithms").role(SecurityAgent).any()({
+      text: "The quick brown fox jumps over the lazy dog"
+    }) timeout 10s
+
+    console.log("\n" + "█".repeat(60))
+    console.log("█" + " ".repeat(58) + "█")
+    console.log("█" + "  All Crypto Tests Completed Successfully!".padEnd(58) + "█")
+    console.log("█" + " ".repeat(58) + "█")
+    console.log("█".repeat(60))
+
+    return {
+      success: true,
+      tests: {
+        passwordHashing: result1,
+        hashVerification: result2,
+        dataIntegrity: result3,
+        algorithmComparison: result4
+      }
+    }
+  }
+}
+
+run Coordinator.runTests({})

package/examples/test-delegation.koi

@@ -0,0 +1,41 @@
+// Test delegation with explicit data passing
+package "test.delegation"
+
+role Worker { can execute }
+
+// Specialist that saves users
+Agent Saver : Worker {
+  llm default = { provider: "openai", model: "gpt-4o-mini" }
+
+  on saveUser(args: Json) {
+    playbook """
+    Save a user to registry with key "user:${args.id}".
+    User data: name="${args.name}", age=${args.age}
+
+    Return: { "saved": true, "id": "${args.id}", "name": "${args.name}" }
+    """
+  }
+}
+
+// Team containing the saver
+Team SaverTeam {
+  saver = Saver
+}
+
+// Orchestrator that delegates
+Agent Orchestrator : Worker {
+  llm default = { provider: "openai", model: "gpt-4o-mini" }
+  uses Team SaverTeam
+
+  on start(args: Json) {
+    playbook """
+    Delegate the task of saving a user named "TestUser" with ID "123" and age 25.
+
+    CRITICAL: Pass data: { "id": "123", "name": "TestUser", "age": 25 }
+
+    Return the result from the delegation.
+    """
+  }
+}
+
+run Orchestrator.start({})

package/examples/test-multi-team-routing.koi

@@ -0,0 +1,258 @@
+package "test.multi.team.routing"
+
+// Test: Multi-team routing with peers() and peers(TeamName)
+// This test validates that:
+// 1. peers.event() broadcasts to all teams
+// 2. peers(TeamName).event() sends only to specific team
+// 3. Multiple teams can coexist and be addressed independently
+
+role Worker { can work, can process }
+
+// Team A workers
+Agent WorkerA1 : Worker {
+  on work(args: Json) {
+    return {
+      from: "WorkerA1",
+      team: "TeamA",
+      data: args
+    }
+  }
+
+  on process(args: Json) {
+    return {
+      from: "WorkerA1",
+      team: "TeamA",
+      operation: "process",
+      data: args
+    }
+  }
+}
+
+Agent WorkerA2 : Worker {
+  on work(args: Json) {
+    return {
+      from: "WorkerA2",
+      team: "TeamA",
+      data: args
+    }
+  }
+
+  on process(args: Json) {
+    return {
+      from: "WorkerA2",
+      team: "TeamA",
+      operation: "process",
+      data: args
+    }
+  }
+}
+
+// Team B workers
+Agent WorkerB1 : Worker {
+  on work(args: Json) {
+    return {
+      from: "WorkerB1",
+      team: "TeamB",
+      data: args
+    }
+  }
+
+  on process(args: Json) {
+    return {
+      from: "WorkerB1",
+      team: "TeamB",
+      operation: "process",
+      data: args
+    }
+  }
+}
+
+Agent WorkerB2 : Worker {
+  on work(args: Json) {
+    return {
+      from: "WorkerB2",
+      team: "TeamB",
+      data: args
+    }
+  }
+
+  on process(args: Json) {
+    return {
+      from: "WorkerB2",
+      team: "TeamB",
+      operation: "process",
+      data: args
+    }
+  }
+}
+
+// Team C workers
+Agent WorkerC1 : Worker {
+  on work(args: Json) {
+    return {
+      from: "WorkerC1",
+      team: "TeamC",
+      data: args
+    }
+  }
+
+  on process(args: Json) {
+    return {
+      from: "WorkerC1",
+      team: "TeamC",
+      operation: "process",
+      data: args
+    }
+  }
+}
+
+// Define three teams
+Team TeamA {
+  worker1 = WorkerA1
+  worker2 = WorkerA2
+}
+
+Team TeamB {
+  worker1 = WorkerB1
+  worker2 = WorkerB2
+}
+
+Team TeamC {
+  worker1 = WorkerC1
+}
+
+// Coordinator that uses all three teams
+Agent TestCoordinator : Worker {
+  uses Team TeamA, TeamB, TeamC
+
+  on runTests(args: Json) {
+    console.log("=".repeat(60))
+    console.log("Multi-Team Routing Test Suite")
+    console.log("=".repeat(60))
+
+    // Test 1: Broadcast to all teams (peers.event)
+    console.log("\n[TEST 1] Broadcast to all teams with peers.event()")
+    console.log("-".repeat(60))
+    const result1 = await send peers.event("work").role(Worker).any()({
+      test: "broadcast",
+      message: "Should reach any team"
+    }) timeout 10s
+
+    console.log("Result:", JSON.stringify(result1, null, 2))
+    const test1Pass = result1 && result1.team
+    if (test1Pass) {
+      console.log("✓ TEST 1 PASSED: Received response from", result1.team)
+    } else {
+      console.log("✗ TEST 1 FAILED: No response received")
+    }
+
+    // Test 2: Send only to TeamA
+    console.log("\n[TEST 2] Send to TeamA only with peers(TeamA).event()")
+    console.log("-".repeat(60))
+    const result2 = await send peers(TeamA).event("work").role(Worker).any()({
+      test: "teamA",
+      message: "Should only reach TeamA"
+    }) timeout 10s
+
+    console.log("Result:", JSON.stringify(result2, null, 2))
+    const test2Pass = result2 && result2.team == "TeamA"
+    if (test2Pass) {
+      console.log("✓ TEST 2 PASSED: Correctly routed to TeamA")
+    } else {
+      console.log("✗ TEST 2 FAILED: Expected team=TeamA, got", result2.team)
+    }
+
+    // Test 3: Send only to TeamB
+    console.log("\n[TEST 3] Send to TeamB only with peers(TeamB).event()")
+    console.log("-".repeat(60))
+    const result3 = await send peers(TeamB).event("work").role(Worker).any()({
+      test: "teamB",
+      message: "Should only reach TeamB"
+    }) timeout 10s
+
+    console.log("Result:", JSON.stringify(result3, null, 2))
+    const test3Pass = result3 && result3.team == "TeamB"
+    if (test3Pass) {
+      console.log("✓ TEST 3 PASSED: Correctly routed to TeamB")
+    } else {
+      console.log("✗ TEST 3 FAILED: Expected team=TeamB, got", result3.team)
+    }
+
+    // Test 4: Send only to TeamC
+    console.log("\n[TEST 4] Send to TeamC only with peers(TeamC).event()")
+    console.log("-".repeat(60))
+    const result4 = await send peers(TeamC).event("work").role(Worker).any()({
+      test: "teamC",
+      message: "Should only reach TeamC"
+    }) timeout 10s
+
+    console.log("Result:", JSON.stringify(result4, null, 2))
+    const test4Pass = result4 && result4.team == "TeamC"
+    if (test4Pass) {
+      console.log("✓ TEST 4 PASSED: Correctly routed to TeamC")
+    } else {
+      console.log("✗ TEST 4 FAILED: Expected team=TeamC, got", result4.team)
+    }
+
+    // Test 5: Different event to specific team
+    console.log("\n[TEST 5] Send 'process' event to TeamA only")
+    console.log("-".repeat(60))
+    const result5 = await send peers(TeamA).event("process").role(Worker).any()({
+      test: "process",
+      value: 42
+    }) timeout 10s
+
+    console.log("Result:", JSON.stringify(result5, null, 2))
+    const test5Pass = result5 && result5.team == "TeamA" && result5.operation == "process"
+    if (test5Pass) {
+      console.log("✓ TEST 5 PASSED: Process event routed to TeamA")
+    } else {
+      console.log("✗ TEST 5 FAILED: Expected TeamA process event")
+    }
+
+    // Test 6: Verify isolation - TeamB should not receive TeamA messages
+    console.log("\n[TEST 6] Verify team isolation")
+    console.log("-".repeat(60))
+    const resultA = await send peers(TeamA).event("work").role(Worker).any()({
+      target: "TeamA"
+    }) timeout 10s
+    const resultB = await send peers(TeamB).event("work").role(Worker).any()({
+      target: "TeamB"
+    }) timeout 10s
+
+    console.log("TeamA result:", JSON.stringify(resultA, null, 2))
+    console.log("TeamB result:", JSON.stringify(resultB, null, 2))
+    const test6Pass = resultA.team == "TeamA" && resultB.team == "TeamB"
+    if (test6Pass) {
+      console.log("✓ TEST 6 PASSED: Teams are properly isolated")
+    } else {
+      console.log("✗ TEST 6 FAILED: Team isolation failed")
+    }
+
+    // Summary
+    console.log("\n" + "=".repeat(60))
+    console.log("Test Summary")
+    console.log("=".repeat(60))
+    const allPassed = test1Pass && test2Pass && test3Pass && test4Pass && test5Pass && test6Pass
+
+    if (allPassed) {
+      console.log("\n✓ ALL 6 TESTS PASSED!")
+    } else {
+      console.log("\n✗ SOME TESTS FAILED - See results above")
+    }
+
+    return {
+      success: allPassed,
+      results: {
+        test1: test1Pass,
+        test2: test2Pass,
+        test3: test3Pass,
+        test4: test4Pass,
+        test5: test5Pass,
+        test6: test6Pass
+      }
+    }
+  }
+}
+
+run TestCoordinator.runTests({})

package/examples/test-no-handler.koi

@@ -0,0 +1,35 @@
+// Test: Error when no agent can handle an event
+
+package "test.no.handler"
+
+role Worker { can execute }
+
+Agent SimpleWorker : Worker {
+  on doWork(args: Json) {
+    playbook """
+    Do some work
+    Return JSON: { "result": "done" }
+    """
+  }
+}
+
+Team SimpleTeam {
+  worker = SimpleWorker
+}
+
+Agent Requester : Worker {
+  uses Team SimpleTeam
+
+  on testNoHandler(args: Json) {
+    console.log("Testing error when no agent can handle event...")
+
+    // Try to send an event that no agent in the team can handle
+    const result = await send peers.event("nonExistentEvent").any()({
+      data: "test"
+    }) timeout 5s
+
+    return result
+  }
+}
+
+run Requester.testNoHandler({})

package/examples/test-npm-import.koi

@@ -0,0 +1,67 @@
+package "test.npm.import"
+
+// Import lodash from node_modules
+import "lodash"
+
+role Worker { can work }
+
+Agent DataProcessor : Worker {
+  on process(args: Json) {
+    console.log("=".repeat(60))
+    console.log("Testing NPM Package Import (lodash)")
+    console.log("=".repeat(60))
+
+    // Test chunk
+    const chunked = lodash.chunk([1, 2, 3, 4, 5, 6, 7, 8], 3)
+    console.log("\nTest 1: chunk([1-8], 3) =", JSON.stringify(chunked))
+
+    // Test uniq
+    const unique = lodash.uniq([1, 2, 2, 3, 3, 3, 4, 5, 5])
+    console.log("Test 2: uniq([1,2,2,3,3,3,4,5,5]) =", JSON.stringify(unique))
+
+    // Test pick
+    const obj = { a: 1, b: 2, c: 3, d: 4 }
+    const picked = lodash.pick(obj, ["a", "c"])
+    console.log("Test 3: pick({a:1,b:2,c:3,d:4}, ['a','c']) =", JSON.stringify(picked))
+
+    // Test sum
+    const total = lodash.sum([1, 2, 3, 4, 5])
+    console.log("Test 4: sum([1,2,3,4,5]) =", total)
+
+    // Test mean
+    const avg = lodash.mean([10, 20, 30, 40, 50])
+    console.log("Test 5: mean([10,20,30,40,50]) =", avg)
+
+    // Test reverse
+    const reversed = lodash.reverse([1, 2, 3, 4, 5])
+    console.log("Test 6: reverse([1,2,3,4,5]) =", JSON.stringify(reversed))
+
+    // Test max
+    const maximum = lodash.max([10, 50, 30, 20, 40])
+    console.log("Test 7: max([10,50,30,20,40]) =", maximum)
+
+    // Test min
+    const minimum = lodash.min([10, 50, 30, 20, 40])
+    console.log("Test 8: min([10,50,30,20,40]) =", minimum)
+
+    console.log("\n" + "=".repeat(60))
+    console.log("All lodash tests completed!")
+    console.log("=".repeat(60))
+
+    return {
+      success: true,
+      tests: {
+        chunked: chunked,
+        unique: unique,
+        picked: picked,
+        sum: total,
+        mean: avg,
+        reversed: reversed,
+        max: maximum,
+        min: minimum
+      }
+    }
+  }
+}
+
+run DataProcessor.process({})

package/examples/test-parse.koi

@@ -0,0 +1,10 @@
+package "test"
+
+role Worker { can execute }
+
+Agent A : Worker {
+on test(args: Json) {
+const x = 5
+return { x: x }
+}
+}

package/examples/test-peers-with-team.koi

@@ -0,0 +1,59 @@
+package "test.peers.team"
+
+role Worker { can work }
+
+Agent WorkerA : Worker {
+  on work(args: Json) {
+    return { from: "WorkerA", data: args }
+  }
+}
+
+Agent WorkerB : Worker {
+  on work(args: Json) {
+    return { from: "WorkerB", data: args }
+  }
+}
+
+Team TeamA {
+  worker = WorkerA
+}
+
+Team TeamB {
+  worker = WorkerB
+}
+
+Agent Coordinator : Worker {
+  uses Team TeamA, TeamB
+
+  on coordinate(args: Json) {
+    // Test 1: Send to all teams via common router
+    console.log("Test 1: Send to all teams (peers.event)")
+    const resultAll = await send peers.event("work").role(Worker).any()({
+      message: "to all teams"
+    }) timeout 10s
+    console.log("Result from all:", JSON.stringify(resultAll))
+
+    // Test 2: Send only to TeamA
+    console.log("\nTest 2: Send to TeamA only (peers(TeamA).event)")
+    const resultTeamA = await send peers(TeamA).event("work").role(Worker).any()({
+      message: "to TeamA only"
+    }) timeout 10s
+    console.log("Result from TeamA:", JSON.stringify(resultTeamA))
+
+    // Test 3: Send only to TeamB
+    console.log("\nTest 3: Send to TeamB only (peers(TeamB).event)")
+    const resultTeamB = await send peers(TeamB).event("work").role(Worker).any()({
+      message: "to TeamB only"
+    }) timeout 10s
+    console.log("Result from TeamB:", JSON.stringify(resultTeamB))
+
+    return {
+      success: true,
+      allTeams: resultAll,
+      teamA: resultTeamA,
+      teamB: resultTeamB
+    }
+  }
+}
+
+run Coordinator.coordinate({ test: true })