@koi-language/koi 1.0.5 → 1.1.0

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

@@ -1,258 +0,0 @@
-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

@@ -1,35 +0,0 @@
-// 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

@@ -1,67 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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 })

package/examples/test-permissions-fail.koi

@@ -1,20 +0,0 @@
-// Test that permissions are enforced
-package "test.permissions.fail"
-
-// Role without execute permission
-role ReadOnly { can registry_read }
-
-// Agent without execute permission - should fail when trying to print
-Agent ReadOnlyAgent : ReadOnly {
-  llm default = { provider: "openai", model: "gpt-4o-mini" }
-
-  on test(args: Json) {
-    playbook """
-    Try to print a message (should fail due to missing execute permission).
-
-    Show: "❌ This should not appear because print requires execute permission"
-    """
-  }
-}
-
-run ReadOnlyAgent.test({})

package/examples/test-permissions.koi

@@ -1,36 +0,0 @@
-// Test permissions system
-package "test.permissions"
-
-// Role with execute permission
-role Worker { can execute }
-
-// Role without execute permission (empty)
-role ReadOnly { can registry_read }
-
-// Agent with execute permission - should work
-Agent TestAgent : Worker {
-  llm default = { provider: "openai", model: "gpt-4o-mini" }
-
-  on test(args: Json) {
-    playbook """
-    Print a simple message to test permissions.
-
-    Show: "✅ Print action works with execute permission"
-    """
-  }
-}
-
-// Agent without execute permission - should fail
-Agent ReadOnlyAgent : ReadOnly {
-  llm default = { provider: "openai", model: "gpt-4o-mini" }
-
-  on test(args: Json) {
-    playbook """
-    Try to print a message (should fail due to missing execute permission).
-
-    Show: "❌ This should not appear"
-    """
-  }
-}
-
-run TestAgent.test({})

package/examples/test-simple-registry.koi

@@ -1,31 +0,0 @@
-// Simple test for registry operations
-package "test.simple"
-
-role Worker { can execute }
-
-Agent SimpleWorker : Worker {
-  llm default = { provider: "openai", model: "gpt-4o-mini" }
-
-  on saveUser(args: Json) {
-    playbook """
-    Save a user to the registry with key "user:${args.id}" and value:
-    {
-      "name": "${args.name}",
-      "age": ${args.age},
-      "createdAt": "${Date.now()}"
-    }
-
-    Return: { "success": true, "message": "User saved" }
-    """
-  }
-
-  on getUser(args: Json) {
-    playbook """
-    Get the user from registry with key "user:${args.id}".
-    If found, return: { "found": true, "user": [the complete user object] }
-    If not found, return: { "found": false }
-    """
-  }
-}
-
-run SimpleWorker.saveUser({ id: "test1", name: "TestUser", age: 25 })

package/examples/test-typescript-import.koi

@@ -1,64 +0,0 @@
-package "test.typescript.import"
-
-// Import TypeScript module
-import "./utils/math-helpers.ts"
-
-role Worker { can work }
-
-Agent MathAgent : Worker {
-  on calculate(args: Json) {
-    console.log("=".repeat(60))
-    console.log("Testing TypeScript Import")
-    console.log("=".repeat(60))
-
-    // Test simple functions
-    const sum = utils_math_helpers.add(5, 3)
-    console.log("\nTest 1: add(5, 3) =", sum)
-
-    const product = utils_math_helpers.multiply(4, 7)
-    console.log("Test 2: multiply(4, 7) =", product)
-
-    const fib10 = utils_math_helpers.fibonacci(10)
-    console.log("Test 3: fibonacci(10) =", fib10)
-
-    const is17Prime = utils_math_helpers.isPrime(17)
-    console.log("Test 4: isPrime(17) =", is17Prime)
-
-    // Test constants
-    console.log("\nTest 5: PI =", utils_math_helpers.PI)
-    console.log("Test 6: E =", utils_math_helpers.E)
-
-    // Test class instantiation
-    const calc = new utils_math_helpers.Calculator()
-    const r1 = calc.add(10, 20)
-    const r2 = calc.subtract(50, 15)
-    console.log("\nTest 7: Calculator.add(10, 20) =", r1)
-    console.log("Test 8: Calculator.subtract(50, 15) =", r2)
-
-    const history = calc.getHistory()
-    console.log("Test 9: Calculator history:", JSON.stringify(history))
-
-    console.log("\n" + "=".repeat(60))
-    console.log("All tests completed!")
-    console.log("=".repeat(60))
-
-    return {
-      success: true,
-      tests: {
-        add: sum,
-        multiply: product,
-        fibonacci: fib10,
-        isPrime: is17Prime,
-        pi: utils_math_helpers.PI,
-        e: utils_math_helpers.E,
-        calculator: {
-          add: r1,
-          subtract: r2,
-          history: history
-        }
-      }
-    }
-  }
-}
-
-run MathAgent.calculate({})

package/examples/test-uses-team-syntax.koi

@@ -1,25 +0,0 @@
-package "test.uses.team"
-
-role Worker { can work }
-
-Agent TestAgent : Worker {
-  on work(args: Json) {
-    return { result: "working" }
-  }
-}
-
-Team TestTeam {
-  worker = TestAgent
-}
-
-Agent MainAgent : Worker {
-  // Esta sintaxis SÍ debe funcionar
-  uses Team TestTeam
-
-  on start(args: Json) {
-    const result = await send peers.event("work").role(Worker).any()({}) timeout 5s
-    return result
-  }
-}
-
-run MainAgent.start({})

package/examples/test-uses-team.koi

@@ -1,31 +0,0 @@
-package "test.uses.team"
-
-role Worker { can execute }
-role Manager { can manage }
-
-Agent SimpleWorker : Worker {
-  on doWork(args: Json) {
-    playbook """
-    Do some work: ${args.task}
-    Return JSON: { "result": "work done" }
-    """
-  }
-}
-
-Team SimpleTeam {
-  worker = SimpleWorker
-}
-
-Agent TeamUser : Manager {
-  uses Team SimpleTeam
-
-  on requestWork(args: Json) {
-    playbook """
-    Request work from team: ${args.request}
-    Return JSON with actions:
-    { "actions": [{ "intent": "do work", "data": { "task": "${args.request}" } }] }
-    """
-  }
-}
-
-run TeamUser.requestWork({ request: "process data" })