lynkr 1.0.0 → 2.0.0

package/test/passthrough-mode.test.js

@@ -0,0 +1,385 @@
+const assert = require("assert");
+const { describe, it, beforeEach, afterEach, mock } = require("node:test");
+
+describe("Passthrough Mode (Client-Side Tool Execution)", () => {
+  let originalEnv;
+  let config;
+  let orchestrator;
+
+  beforeEach(() => {
+    // Store original environment
+    originalEnv = { ...process.env };
+
+    // Ensure clean state for TOOL_EXECUTION_MODE
+    delete process.env.TOOL_EXECUTION_MODE;
+
+    // Set MODEL_PROVIDER to databricks for tests (not azure-openai from .env)
+    process.env.MODEL_PROVIDER = "databricks";
+    process.env.DATABRICKS_API_KEY = "test-key";
+    process.env.DATABRICKS_API_BASE = "http://test.com";
+
+    // Clear module cache
+    delete require.cache[require.resolve("../src/config")];
+    delete require.cache[require.resolve("../src/orchestrator/index")];
+  });
+
+  afterEach(() => {
+    // Restore environment
+    process.env = originalEnv;
+  });
+
+  describe("Configuration", () => {
+    it("should accept 'client' mode", () => {
+      process.env.TOOL_EXECUTION_MODE = "client";
+      process.env.DATABRICKS_API_KEY = "test-key";
+      process.env.DATABRICKS_API_BASE = "http://test.com";
+      config = require("../src/config");
+
+      assert.strictEqual(config.toolExecutionMode, "client");
+    });
+
+    it("should accept 'passthrough' mode (alias for client)", () => {
+      process.env.TOOL_EXECUTION_MODE = "passthrough";
+      process.env.DATABRICKS_API_KEY = "test-key";
+      process.env.DATABRICKS_API_BASE = "http://test.com";
+      config = require("../src/config");
+
+      assert.strictEqual(config.toolExecutionMode, "passthrough");
+    });
+
+    it("should accept 'server' mode explicitly", () => {
+      process.env.TOOL_EXECUTION_MODE = "server";
+      process.env.DATABRICKS_API_KEY = "test-key";
+      process.env.DATABRICKS_API_BASE = "http://test.com";
+      config = require("../src/config");
+
+      assert.strictEqual(config.toolExecutionMode, "server");
+    });
+  });
+
+  describe("Response Format in Passthrough Mode", () => {
+    it("should return Anthropic-formatted response with tool_use blocks", () => {
+      // Mock response from provider with tool calls
+      const mockProviderResponse = {
+        ok: true,
+        status: 200,
+        json: {
+          choices: [
+            {
+              message: {
+                role: "assistant",
+                content: "I'll create that file for you.",
+                tool_calls: [
+                  {
+                    id: "call_123",
+                    type: "function",
+                    function: {
+                      name: "Write",
+                      arguments: JSON.stringify({
+                        file_path: "/tmp/test.txt",
+                        content: "Hello World"
+                      })
+                    }
+                  }
+                ]
+              },
+              finish_reason: "tool_calls"
+            }
+          ],
+          model: "openai/gpt-4o-mini",
+          usage: {
+            prompt_tokens: 10,
+            completion_tokens: 20,
+            total_tokens: 30
+          }
+        }
+      };
+
+      // Expected Anthropic format
+      const expectedContent = [
+        {
+          type: "text",
+          text: "I'll create that file for you."
+        },
+        {
+          type: "tool_use",
+          id: "call_123",
+          name: "Write",
+          input: {
+            file_path: "/tmp/test.txt",
+            content: "Hello World"
+          }
+        }
+      ];
+
+      // Test content conversion
+      const { convertOpenRouterResponseToAnthropic } = require("../src/clients/openrouter-utils");
+      const anthropicResponse = convertOpenRouterResponseToAnthropic(
+        mockProviderResponse.json,
+        "claude-sonnet-4-5"
+      );
+
+      assert.strictEqual(anthropicResponse.role, "assistant");
+      assert.strictEqual(anthropicResponse.stop_reason, "tool_use");
+      assert.strictEqual(Array.isArray(anthropicResponse.content), true);
+      assert.strictEqual(anthropicResponse.content.length, 2);
+      assert.strictEqual(anthropicResponse.content[0].type, "text");
+      assert.strictEqual(anthropicResponse.content[1].type, "tool_use");
+      assert.strictEqual(anthropicResponse.content[1].name, "Write");
+      assert.deepStrictEqual(anthropicResponse.content[1].input, {
+        file_path: "/tmp/test.txt",
+        content: "Hello World"
+      });
+    });
+
+    it("should handle multiple tool calls in one response", () => {
+      const mockProviderResponse = {
+        choices: [
+          {
+            message: {
+              role: "assistant",
+              content: "I'll read the file and then write it.",
+              tool_calls: [
+                {
+                  id: "call_1",
+                  type: "function",
+                  function: {
+                    name: "Read",
+                    arguments: JSON.stringify({ file_path: "/tmp/input.txt" })
+                  }
+                },
+                {
+                  id: "call_2",
+                  type: "function",
+                  function: {
+                    name: "Write",
+                    arguments: JSON.stringify({
+                      file_path: "/tmp/output.txt",
+                      content: "Modified"
+                    })
+                  }
+                }
+              ]
+            },
+            finish_reason: "tool_calls"
+          }
+        ],
+        model: "openai/gpt-4o-mini",
+        usage: { prompt_tokens: 10, completion_tokens: 30, total_tokens: 40 }
+      };
+
+      const { convertOpenRouterResponseToAnthropic } = require("../src/clients/openrouter-utils");
+      const anthropicResponse = convertOpenRouterResponseToAnthropic(
+        mockProviderResponse,
+        "claude-sonnet-4-5"
+      );
+
+      assert.strictEqual(anthropicResponse.content.length, 3); // 1 text + 2 tool_use
+      assert.strictEqual(anthropicResponse.content[1].type, "tool_use");
+      assert.strictEqual(anthropicResponse.content[1].name, "Read");
+      assert.strictEqual(anthropicResponse.content[2].type, "tool_use");
+      assert.strictEqual(anthropicResponse.content[2].name, "Write");
+    });
+
+    it("should handle tool calls without text content", () => {
+      const mockProviderResponse = {
+        choices: [
+          {
+            message: {
+              role: "assistant",
+              content: null,
+              tool_calls: [
+                {
+                  id: "call_1",
+                  type: "function",
+                  function: {
+                    name: "Read",
+                    arguments: JSON.stringify({ file_path: "/tmp/test.txt" })
+                  }
+                }
+              ]
+            },
+            finish_reason: "tool_calls"
+          }
+        ],
+        model: "openai/gpt-4o-mini",
+        usage: { prompt_tokens: 10, completion_tokens: 15, total_tokens: 25 }
+      };
+
+      const { convertOpenRouterResponseToAnthropic } = require("../src/clients/openrouter-utils");
+      const anthropicResponse = convertOpenRouterResponseToAnthropic(
+        mockProviderResponse,
+        "claude-sonnet-4-5"
+      );
+
+      // Should only have tool_use block, no text block
+      assert.strictEqual(anthropicResponse.content.length, 1);
+      assert.strictEqual(anthropicResponse.content[0].type, "tool_use");
+    });
+  });
+
+  describe("Tool Result Processing", () => {
+    it("should accept tool_result blocks from CLI in next request", () => {
+      // Simulate a conversation with tool results coming back from CLI
+      const messagesWithToolResults = [
+        {
+          role: "user",
+          content: "Create a file /tmp/test.txt"
+        },
+        {
+          role: "assistant",
+          content: [
+            { type: "text", text: "I'll create that file." },
+            {
+              type: "tool_use",
+              id: "toolu_123",
+              name: "Write",
+              input: {
+                file_path: "/tmp/test.txt",
+                content: "Hello"
+              }
+            }
+          ]
+        },
+        {
+          role: "user",
+          content: [
+            {
+              type: "tool_result",
+              tool_use_id: "toolu_123",
+              content: "File created successfully"
+            }
+          ]
+        }
+      ];
+
+      // Verify structure
+      assert.strictEqual(messagesWithToolResults.length, 3);
+      assert.strictEqual(messagesWithToolResults[2].role, "user");
+      assert.strictEqual(Array.isArray(messagesWithToolResults[2].content), true);
+      assert.strictEqual(messagesWithToolResults[2].content[0].type, "tool_result");
+      assert.strictEqual(messagesWithToolResults[2].content[0].tool_use_id, "toolu_123");
+    });
+
+    it("should convert tool_result blocks to OpenRouter format", () => {
+      // Must include assistant message with tool_use first
+      const anthropicMessages = [
+        {
+          role: "assistant",
+          content: [
+            {
+              type: "tool_use",
+              id: "toolu_123",
+              name: "Write",
+              input: { file_path: "/tmp/test.txt", content: "Hello" }
+            }
+          ]
+        },
+        {
+          role: "user",
+          content: [
+            {
+              type: "tool_result",
+              tool_use_id: "toolu_123",
+              content: "File created successfully"
+            }
+          ]
+        }
+      ];
+
+      const { convertAnthropicMessagesToOpenRouter } = require("../src/clients/openrouter-utils");
+      const openRouterMessages = convertAnthropicMessagesToOpenRouter(anthropicMessages);
+
+      // Should convert to tool role message for OpenRouter
+      assert.strictEqual(openRouterMessages.length >= 2, true);
+      // OpenRouter expects tool results as separate tool messages
+      const toolMessage = openRouterMessages.find(m => m.role === "tool");
+      assert.ok(toolMessage, "Tool message should be present");
+    });
+  });
+
+  describe("Stop Reason Handling", () => {
+    it("should set stop_reason to 'tool_use' when tools are present", () => {
+      const mockResponse = {
+        choices: [
+          {
+            message: {
+              role: "assistant",
+              content: "Using tool",
+              tool_calls: [
+                {
+                  id: "call_1",
+                  function: {
+                    name: "Read",
+                    arguments: "{}"
+                  }
+                }
+              ]
+            },
+            finish_reason: "tool_calls"
+          }
+        ],
+        model: "test-model",
+        usage: { prompt_tokens: 10, completion_tokens: 10, total_tokens: 20 }
+      };
+
+      const { convertOpenRouterResponseToAnthropic } = require("../src/clients/openrouter-utils");
+      const result = convertOpenRouterResponseToAnthropic(mockResponse, "claude-sonnet-4-5");
+
+      assert.strictEqual(result.stop_reason, "tool_use");
+    });
+
+    it("should set stop_reason to 'end_turn' when no tools", () => {
+      const mockResponse = {
+        choices: [
+          {
+            message: {
+              role: "assistant",
+              content: "Simple response"
+            },
+            finish_reason: "stop"
+          }
+        ],
+        model: "test-model",
+        usage: { prompt_tokens: 10, completion_tokens: 10, total_tokens: 20 }
+      };
+
+      const { convertOpenRouterResponseToAnthropic } = require("../src/clients/openrouter-utils");
+      const result = convertOpenRouterResponseToAnthropic(mockResponse, "claude-sonnet-4-5");
+
+      assert.strictEqual(result.stop_reason, "end_turn");
+    });
+  });
+
+  describe("Session Storage Format", () => {
+    it("should store tool_use blocks in Anthropic format for session", () => {
+      // Session content should always be in Anthropic format
+      // regardless of provider
+      const sessionContent = [
+        {
+          type: "text",
+          text: "I'll help with that."
+        },
+        {
+          type: "tool_use",
+          id: "toolu_abc",
+          name: "Write",
+          input: {
+            file_path: "/tmp/test.txt",
+            content: "data"
+          }
+        }
+      ];
+
+      // Verify all blocks have correct structure
+      sessionContent.forEach(block => {
+        assert.strictEqual(typeof block.type, "string");
+        if (block.type === "tool_use") {
+          assert.strictEqual(typeof block.id, "string");
+          assert.strictEqual(typeof block.name, "string");
+          assert.strictEqual(typeof block.input, "object");
+        }
+      });
+    });
+  });
+});

package/test/routing.test.js

@@ -78,7 +78,9 @@ describe("Routing Logic", () => {
       process.env.PREFER_OLLAMA = "true";
       process.env.OLLAMA_MODEL = "qwen2.5-coder:latest";
       process.env.OLLAMA_MAX_TOOLS_FOR_ROUTING = "3";
-      process.env.OLLAMA_FALLBACK_PROVIDER = "databricks";
+      process.env.OPENROUTER_MAX_TOOLS_FOR_ROUTING = "3"; // Set same as ollama to skip openrouter tier
+      process.env.FALLBACK_PROVIDER = "databricks";
+      process.env.FALLBACK_ENABLED = "true"; // Ensure fallback is enabled
       process.env.DATABRICKS_API_KEY = "test-key";
       process.env.DATABRICKS_API_BASE = "http://test.com";
 
@@ -105,6 +107,7 @@ describe("Routing Logic", () => {
       process.env.PREFER_OLLAMA = "true";
       process.env.OLLAMA_MODEL = "llama3:latest"; // Non-tool-capable model
       process.env.OLLAMA_FALLBACK_PROVIDER = "databricks";
+      process.env.FALLBACK_ENABLED = "true"; // Ensure fallback is enabled
       process.env.DATABRICKS_API_KEY = "test-key";
       process.env.DATABRICKS_API_BASE = "http://test.com";
 
@@ -153,6 +156,9 @@ describe("Routing Logic", () => {
       process.env.MODEL_PROVIDER = "ollama";
       process.env.PREFER_OLLAMA = "true";
       process.env.OLLAMA_MODEL = "qwen2.5-coder:latest";
+      // Override .env file which sets FALLBACK_ENABLED=false
+      // Test default behavior when not set to "false"
+      process.env.FALLBACK_ENABLED = "true";
 
       config = require("../src/config");
       routing = require("../src/clients/routing");
@@ -164,7 +170,7 @@ describe("Routing Logic", () => {
       process.env.MODEL_PROVIDER = "ollama";
       process.env.PREFER_OLLAMA = "true";
       process.env.OLLAMA_MODEL = "qwen2.5-coder:latest";
-      process.env.OLLAMA_FALLBACK_ENABLED = "false";
+      process.env.FALLBACK_ENABLED = "false";
 
       config = require("../src/config");
       routing = require("../src/clients/routing");
@@ -191,7 +197,7 @@ describe("Routing Logic", () => {
       process.env.MODEL_PROVIDER = "ollama";
       process.env.PREFER_OLLAMA = "true";
       process.env.OLLAMA_MODEL = "qwen2.5-coder:latest";
-      process.env.OLLAMA_FALLBACK_PROVIDER = "azure-anthropic";
+      process.env.FALLBACK_PROVIDER = "azure-anthropic";
       process.env.AZURE_ANTHROPIC_ENDPOINT = "http://test.com";
       process.env.AZURE_ANTHROPIC_API_KEY = "test-key";
 

package/test/web-tools.test.js

@@ -3,6 +3,9 @@ const assert = require("node:assert");
 const http = require("http");
 
 // Mock configuration
+process.env.MODEL_PROVIDER = "databricks"; // Override any .env settings
+process.env.DATABRICKS_API_KEY = "test-key";
+process.env.DATABRICKS_API_BASE = "http://test.com";
 process.env.WEB_SEARCH_ENDPOINT = "http://localhost:9999/search";
 process.env.WEB_SEARCH_TIMEOUT_MS = "5000";
 process.env.WEB_FETCH_BODY_PREVIEW_MAX = "1000";

package/test-agents-simple.js

@@ -0,0 +1,43 @@
+// Simple test to verify agent system is working
+// Run: AGENTS_ENABLED=true node test-agents-simple.js
+
+const config = require('./src/config');
+const { listAgents, getAgentStats } = require('./src/agents');
+
+console.log('🧪 Testing Agent System\n');
+
+// Test 1: Check configuration
+console.log('1. Configuration:');
+console.log(`   Agents enabled: ${config.agents?.enabled}`);
+console.log(`   Max concurrent: ${config.agents?.maxConcurrent}`);
+console.log(`   Default model: ${config.agents?.defaultModel}`);
+console.log(`   Max steps: ${config.agents?.maxSteps}`);
+console.log(`   Timeout: ${config.agents?.timeout}ms`);
+
+// Test 2: List available agents
+console.log('\n2. Available Agents:');
+const agents = listAgents();
+agents.forEach(agent => {
+  console.log(`   - ${agent.name} (${agent.model})`);
+  console.log(`     ${agent.description.substring(0, 80)}...`);
+  console.log(`     Tools: ${agent.allowedTools.length === 0 ? 'ALL' : agent.allowedTools.join(', ')}`);
+  console.log(`     Max steps: ${agent.maxSteps}`);
+});
+
+// Test 3: Check stats
+console.log('\n3. Execution Stats:');
+const stats = getAgentStats();
+if (stats.length === 0) {
+  console.log('   No executions yet');
+} else {
+  stats.forEach(stat => {
+    console.log(`   - ${stat.agent_type}:`);
+    console.log(`     Total: ${stat.total_executions}, Completed: ${stat.completed}, Failed: ${stat.failed}`);
+  });
+}
+
+console.log('\n✅ Agent system is operational!\n');
+console.log('Next steps:');
+console.log('1. Start server: AGENTS_ENABLED=true npm start');
+console.log('2. Test with curl (see README)');
+console.log('3. Or run: ./test-subagents.sh\n');

package/test-cli-connection.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+
+echo "🔍 Claude Code CLI Connection Test"
+echo "===================================="
+echo ""
+
+echo "1. Environment Variables:"
+env | grep -i anthropic | sed 's/^/   /'
+
+echo ""
+echo "2. Testing ngrok endpoint:"
+curl -s https://ae619b9fdba2.ngrok-free.app/health -H "ngrok-skip-browser-warning: true" | jq .
+
+echo ""
+echo "3. Testing direct localhost:"
+curl -s http://localhost:8080/health | jq .
+
+echo ""
+echo "4. Checking Claude config file:"
+if [ -f ~/.config/claude/config.json ]; then
+  echo "   Config exists:"
+  cat ~/.config/claude/config.json | jq .api 2>/dev/null || cat ~/.config/claude/config.json
+else
+  echo "   No config file found"
+fi
+
+echo ""
+echo "5. Last 5 requests in server log:"
+tail -100 /tmp/lynkr.log | grep "Request started" | tail -5 | sed 's/^/   /'
+
+echo ""
+echo "======================================"
+echo "Please share this output!"

package/test-learning-unit.js

@@ -0,0 +1,126 @@
+const Skillbook = require('./src/agents/skillbook');
+const Reflector = require('./src/agents/reflector');
+const path = require('path');
+const fs = require('fs');
+
+console.log('========================================');
+console.log('Learning System Unit Test');
+console.log('========================================\n');
+
+async function testLearningSystem() {
+  try {
+    // Test 1: Create and save skillbook
+    console.log('Test 1: Creating skillbook...');
+    const skillbook = new Skillbook('Explore');
+
+    // Add a test skill
+    skillbook.addSkill({
+      pattern: "Search task",
+      action: "Use tools: Glob, Grep, Read",
+      reasoning: "Successfully completed search task using these tools",
+      tools: ["Glob", "Grep", "Read"],
+      confidence: 0.75
+    });
+
+    console.log(`✓ Added 1 skill`);
+    console.log(`  Total skills: ${skillbook.skills.size}\n`);
+
+    // Test 2: Save skillbook
+    console.log('Test 2: Saving skillbook...');
+    const saved = await skillbook.save();
+    console.log(`✓ Skillbook saved: ${saved}\n`);
+
+    // Test 3: Load skillbook
+    console.log('Test 3: Loading skillbook...');
+    const loaded = await Skillbook.load('Explore');
+    console.log(`✓ Loaded skillbook`);
+    console.log(`  Skills: ${loaded.skills.size}\n`);
+
+    // Test 4: Get top skills
+    console.log('Test 4: Getting top skills...');
+    const topSkills = loaded.getTopSkills(3);
+    console.log(`✓ Top skills: ${topSkills.length}`);
+    topSkills.forEach((skill, i) => {
+      console.log(`  ${i + 1}. ${skill.pattern} (confidence: ${Math.round(skill.confidence * 100)}%)`);
+    });
+    console.log('');
+
+    // Test 5: Format for prompt
+    console.log('Test 5: Formatting for prompt...');
+    const promptSection = loaded.formatForPrompt();
+    console.log(`✓ Generated prompt section (${promptSection.length} chars):`);
+    console.log(promptSection.substring(0, 200) + '...\n');
+
+    // Test 6: Test Reflector
+    console.log('Test 6: Testing Reflector...');
+    const mockContext = {
+      agentName: 'Test',
+      taskPrompt: 'Find all JavaScript files in src directory',
+      steps: 3,
+      maxSteps: 10,
+      inputTokens: 500,
+      outputTokens: 300,
+      transcript: [
+        {
+          type: 'tool_call',
+          toolName: 'Glob',
+          timestamp: Date.now() - 2000
+        },
+        {
+          type: 'tool_call',
+          toolName: 'Grep',
+          timestamp: Date.now() - 1000
+        },
+        {
+          type: 'tool_call',
+          toolName: 'Read',
+          timestamp: Date.now()
+        }
+      ]
+    };
+
+    const patterns = Reflector.reflect(mockContext, true);
+    console.log(`✓ Reflector extracted ${patterns.length} patterns:`);
+    patterns.forEach((p, i) => {
+      console.log(`  ${i + 1}. ${p.pattern}`);
+      console.log(`     Action: ${p.action}`);
+      console.log(`     Confidence: ${Math.round(p.confidence * 100)}%`);
+    });
+    console.log('');
+
+    // Test 7: Add reflected patterns to skillbook
+    console.log('Test 7: Adding reflected patterns...');
+    const testSkillbook = new Skillbook('Test');
+    for (const pattern of patterns) {
+      testSkillbook.addSkill(pattern);
+    }
+    console.log(`✓ Added ${patterns.length} patterns`);
+    console.log(`  Total skills: ${testSkillbook.skills.size}\n`);
+
+    // Test 8: Save test skillbook
+    console.log('Test 8: Saving test skillbook...');
+    await testSkillbook.save();
+    console.log(`✓ Test skillbook saved\n`);
+
+    // Test 9: List all skillbooks
+    console.log('Test 9: Listing all skillbooks...');
+    const skillbooksDir = path.join(process.cwd(), 'data', 'skillbooks');
+    const files = fs.readdirSync(skillbooksDir);
+    console.log(`✓ Found ${files.length} skillbook(s):`);
+    files.forEach(file => {
+      console.log(`  - ${file}`);
+    });
+    console.log('');
+
+    console.log('========================================');
+    console.log('✅ All Tests Passed!');
+    console.log('========================================\n');
+
+  } catch (error) {
+    console.error('❌ Test failed:', error.message);
+    console.error(error.stack);
+    process.exit(1);
+  }
+}
+
+testLearningSystem();