@codemieai/code 0.0.1

package/tests/agent-direct.test.mjs

@@ -0,0 +1,45 @@
+/**
+ * Integration Test: Direct agent tool calling
+ * Uses Node.js native test runner
+ */
+
+import { describe, it, before } from 'node:test';
+import assert from 'node:assert';
+import { CodeMieAgent } from '../dist/code/agent.js';
+import { loadConfig } from '../dist/code/config.js';
+import { FilesystemTools } from '../dist/code/tools/filesystem.js';
+import { skipIfNoBaseUrl } from './test-helpers.mjs';
+
+describe('Direct Agent Tool Calling', () => {
+  let agent;
+  let config;
+
+  before(() => {
+    if (skipIfNoBaseUrl()) return;
+
+    config = loadConfig(process.cwd());
+    const filesystemTools = new FilesystemTools({
+      allowedDirectories: [process.cwd()]
+    });
+    const tools = filesystemTools.getTools();
+    agent = new CodeMieAgent(config, tools);
+  });
+
+  it('should load configuration correctly', () => {
+    if (skipIfNoBaseUrl()) return;
+
+    assert.ok(config, 'Config should be loaded');
+    assert.ok(config.model, 'Config should have a model');
+    assert.ok(config.provider, 'Config should have a provider');
+  });
+
+  it('should list files in current directory', async () => {
+    if (skipIfNoBaseUrl()) return;
+
+    const response = await agent.chat('list all files in the current directory');
+
+    assert.ok(response, 'Response should be defined');
+    assert.ok(typeof response === 'string', 'Response should be a string');
+    assert.ok(response.length > 0, 'Response should not be empty');
+  });
+});

package/tests/agent-output.test.mjs

@@ -0,0 +1,64 @@
+/**
+ * Integration Test: Agent output format
+ * Uses Node.js native test runner
+ */
+
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert';
+import { CodeMieCode } from '../dist/code/index.js';
+import { skipIfNoBaseUrl } from './test-helpers.mjs';
+
+describe('Agent Output Format', () => {
+  let assistant;
+
+  before(async () => {
+    if (skipIfNoBaseUrl()) return;
+
+    assistant = new CodeMieCode(process.cwd());
+    await assistant.initialize({ showTips: false });
+  });
+
+  after(async () => {
+    if (assistant) {
+      await assistant.dispose();
+    }
+  });
+
+  it('should produce correctly formatted output', async () => {
+    if (skipIfNoBaseUrl()) return;
+    const capturedOutput = {
+      contentChunks: [],
+      toolCalls: [],
+      toolResults: [],
+      errors: []
+    };
+
+    await assistant.agent.chatStream('list files in current directory', (event) => {
+      switch (event.type) {
+        case 'content_chunk':
+          capturedOutput.contentChunks.push(event.content);
+          break;
+
+        case 'tool_call_start':
+          const args = Object.entries(event.toolArgs)
+            .map(([k, v]) => typeof v === 'string' ? v : JSON.stringify(v))
+            .join(', ');
+          capturedOutput.toolCalls.push(`${event.toolName}(${args})`);
+          break;
+
+        case 'tool_call_result':
+          capturedOutput.toolResults.push(event.result);
+          break;
+
+        case 'tool_call_error':
+          capturedOutput.errors.push(event.error);
+          break;
+      }
+    });
+
+    // Validate output format
+    assert.ok(capturedOutput.contentChunks.length > 0, 'Should have content chunks');
+    assert.ok(capturedOutput.toolCalls.length > 0, 'Should have tool calls');
+    assert.ok(capturedOutput.toolResults.length > 0, 'Should have tool results');
+  });
+});

package/tests/codemie-code.test.mjs

@@ -0,0 +1,42 @@
+/**
+ * Integration Test: CodeMieCode class tool calling
+ * Uses Node.js native test runner
+ */
+
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert';
+import { CodeMieCode } from '../dist/code/index.js';
+import { skipIfNoBaseUrl } from './test-helpers.mjs';
+
+describe('CodeMieCode Tool Calling', () => {
+  let assistant;
+
+  before(async () => {
+    if (skipIfNoBaseUrl()) return;
+
+    assistant = new CodeMieCode(process.cwd());
+    await assistant.initialize({ showTips: false });
+  });
+
+  after(async () => {
+    if (assistant) {
+      await assistant.dispose();
+    }
+  });
+
+  it('should initialize successfully', () => {
+    if (skipIfNoBaseUrl()) return;
+
+    assert.ok(assistant, 'Assistant should be initialized');
+    assert.ok(assistant.agent, 'Assistant should have an agent');
+  });
+
+  it('should list files in current directory', async () => {
+    if (skipIfNoBaseUrl()) return;
+    const response = await assistant.chat('list files in the current directory');
+
+    assert.ok(response, 'Response should be defined');
+    assert.ok(typeof response === 'string', 'Response should be a string');
+    assert.ok(response.length > 0, 'Response should not be empty');
+  });
+});

package/tests/context7-only.test.mjs

@@ -0,0 +1,42 @@
+/**
+ * Integration Test: Context7 MCP Server Only
+ * Uses Node.js native test runner
+ */
+
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert';
+import { MCPTools } from '../dist/code/tools/mcp.js';
+import { skipIfNoBaseUrl } from './test-helpers.mjs';
+
+describe('Context7 MCP Server Only', () => {
+  let mcpTools;
+
+  before(async () => {
+    if (skipIfNoBaseUrl()) return;
+
+    mcpTools = new MCPTools(process.cwd());
+    await mcpTools.initialize(['context7']);
+  });
+
+  after(async () => {
+    if (mcpTools) {
+      await mcpTools.dispose();
+    }
+  });
+
+  it('should load tools from context7 server', async () => {
+    if (skipIfNoBaseUrl()) return;
+    const tools = await mcpTools.getTools();
+    assert.ok(tools.length > 0, 'Should have loaded tools from context7');
+  });
+
+  it('should have library-related tools', async () => {
+    if (skipIfNoBaseUrl()) return;
+    const tools = await mcpTools.getTools();
+    const hasLibraryTools = tools.some(tool =>
+      tool.name.includes('library') || tool.name.includes('resolve')
+    );
+
+    assert.ok(hasLibraryTools, 'Should have library-related tools');
+  });
+});

package/tests/conversation-flow.test.mjs

@@ -0,0 +1,63 @@
+/**
+ * Integration Test: Conversation flow with multiple questions
+ * Uses Node.js native test runner
+ */
+
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert';
+import { CodeMieCode } from '../dist/code/index.js';
+import { skipIfNoBaseUrl } from './test-helpers.mjs';
+
+describe('Conversation Flow', () => {
+  let assistant;
+
+  before(async () => {
+    if (skipIfNoBaseUrl()) return;
+
+    assistant = new CodeMieCode(process.cwd());
+    await assistant.initialize({ showTips: false });
+  });
+
+  after(async () => {
+    if (assistant) {
+      await assistant.dispose();
+    }
+  });
+
+  it('should handle 3 consecutive questions', async () => {
+    if (skipIfNoBaseUrl()) return;
+    // Question 1
+    const response1 = await assistant.chat('What is 2+2?');
+    assert.ok(response1, 'Response 1 should be defined');
+    assert.ok(response1.includes('4'), 'Response 1 should contain "4"');
+
+    // Question 2
+    const response2 = await assistant.chat('What is the capital of France?');
+    assert.ok(response2, 'Response 2 should be defined');
+    assert.ok(response2.toLowerCase().includes('paris'), 'Response 2 should contain "paris"');
+
+    // Question 3
+    const response3 = await assistant.chat('List the files in the current directory');
+    assert.ok(response3, 'Response 3 should be defined');
+
+    // Verify conversation history
+    const history = assistant.agent.getHistory();
+    assert.ok(history.length > 0, 'History should not be empty');
+
+    // Count user messages - should be exactly 3
+    const userMessages = history.filter(m => m.role === 'user');
+    assert.strictEqual(userMessages.length, 3, 'Should have exactly 3 user messages');
+
+    // Verify all 3 questions are in history
+    const questions = [
+      'What is 2+2?',
+      'What is the capital of France?',
+      'List the files in the current directory'
+    ];
+
+    for (let i = 0; i < questions.length; i++) {
+      assert.ok(userMessages[i], `User message ${i} should exist`);
+      assert.strictEqual(userMessages[i].content, questions[i], `User message ${i} should match question`);
+    }
+  });
+});

package/tests/interactive-simulation.test.mjs

@@ -0,0 +1,60 @@
+/**
+ * Integration Test: Interactive conversation simulation
+ * Uses Node.js native test runner
+ */
+
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert';
+import { CodeMieCode } from '../dist/code/index.js';
+import { skipIfNoBaseUrl } from './test-helpers.mjs';
+
+describe('Interactive Conversation Simulation', () => {
+  let assistant;
+
+  before(async () => {
+    if (skipIfNoBaseUrl()) return;
+
+    assistant = new CodeMieCode(process.cwd());
+    await assistant.initialize({ showTips: false });
+  });
+
+  after(async () => {
+    if (assistant) {
+      await assistant.dispose();
+    }
+  });
+
+  it('should handle 3 consecutive interactive questions', async () => {
+    if (skipIfNoBaseUrl()) return;
+    const questions = [
+      'What is 2+2?',
+      'What is the capital of France?',
+      'List files in the current directory'
+    ];
+
+    let completedQuestions = 0;
+
+    for (let i = 0; i < questions.length; i++) {
+      const question = questions[i];
+      let hasCompleted = false;
+      let hasError = false;
+
+      await assistant.agent.chatStream(question, (event) => {
+        if (event.type === 'complete') {
+          hasCompleted = true;
+        }
+        if (event.type === 'error') {
+          hasError = true;
+        }
+      });
+
+      assert.ok(hasCompleted || !hasError, `Question ${i + 1} should complete successfully`);
+
+      if (hasCompleted) {
+        completedQuestions++;
+      }
+    }
+
+    assert.strictEqual(completedQuestions, 3, 'All 3 questions should complete');
+  });
+});

package/tests/live-output.test.mjs

@@ -0,0 +1,53 @@
+/**
+ * Integration Test: Live output format
+ * Uses Node.js native test runner
+ */
+
+import { describe, it, before } from 'node:test';
+import assert from 'node:assert';
+import { CodeMieAgent } from '../dist/code/agent.js';
+import { loadConfig } from '../dist/code/config.js';
+import { FilesystemTools } from '../dist/code/tools/filesystem.js';
+import { skipIfNoBaseUrl } from './test-helpers.mjs';
+
+describe('Live Output Format', () => {
+  let agent;
+
+  before(() => {
+    if (skipIfNoBaseUrl()) return;
+
+    const config = loadConfig(process.cwd());
+    const filesystemTools = new FilesystemTools({
+      allowedDirectories: [process.cwd()]
+    });
+    const tools = filesystemTools.getTools();
+    agent = new CodeMieAgent(config, tools);
+  });
+
+  it('should produce correctly formatted live output', async () => {
+    if (skipIfNoBaseUrl()) return;
+    let hasToolCall = false;
+    let hasToolResult = false;
+    let hasContent = false;
+
+    await agent.chatStream('list files in current directory', (event) => {
+      switch (event.type) {
+        case 'content_chunk':
+          hasContent = true;
+          break;
+
+        case 'tool_call_start':
+          hasToolCall = true;
+          break;
+
+        case 'tool_call_result':
+          hasToolResult = true;
+          break;
+      }
+    });
+
+    assert.ok(hasContent, 'Should have content chunks');
+    assert.ok(hasToolCall, 'Should have tool calls');
+    assert.ok(hasToolResult, 'Should have tool results');
+  });
+});

package/tests/mcp-context7.test.mjs

@@ -0,0 +1,105 @@
+/**
+ * Integration Test: Context7 MCP Server Integration
+ * Uses Node.js native test runner
+ */
+
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert';
+import { MCPTools } from '../dist/code/tools/mcp.js';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import { skipIfNoBaseUrl } from './test-helpers.mjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+describe('MCP Context7 Server', () => {
+  let mcpTools;
+  let configPath;
+  let originalConfig;
+
+  before(async () => {
+    if (skipIfNoBaseUrl()) return;
+    configPath = path.join(os.homedir(), '.codemie', 'config.json');
+
+    // Backup original config
+    try {
+      const content = await fs.readFile(configPath, 'utf-8');
+      originalConfig = JSON.parse(content);
+    } catch (error) {
+      await fs.mkdir(path.dirname(configPath), { recursive: true });
+      originalConfig = {};
+    }
+
+    // Ensure context7 and time servers are configured
+    const config = { ...originalConfig };
+    if (!config.mcpServers) {
+      config.mcpServers = {};
+    }
+
+    config.mcpServers.context7 = {
+      command: 'npx',
+      args: ['-y', '@upstash/context7-mcp']
+    };
+
+    config.mcpServers.time = {
+      transport: 'stdio',
+      command: 'uvx',
+      args: ['mcp-server-time']
+    };
+
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
+
+    mcpTools = new MCPTools(process.cwd());
+    await mcpTools.initialize(['time', 'context7']);
+  });
+
+  after(async () => {
+    if (mcpTools) {
+      await mcpTools.dispose();
+    }
+
+    // Restore original config
+    if (originalConfig) {
+      await fs.writeFile(configPath, JSON.stringify(originalConfig, null, 2), 'utf-8');
+    }
+  });
+
+  it('should load tools from both time and context7 servers', async () => {
+    if (skipIfNoBaseUrl()) return;
+    const tools = await mcpTools.getTools();
+    assert.ok(tools.length > 0, 'Should have loaded tools');
+
+    const timeTools = tools.filter(t => t.name.includes('time'));
+    const context7Tools = tools.filter(t => t.name.includes('library') || t.name.includes('resolve'));
+
+    assert.ok(timeTools.length > 0, 'Should have time tools');
+    assert.ok(context7Tools.length > 0, 'Should have context7 tools');
+  });
+
+  it('should query time in Hong Kong', async () => {
+    if (skipIfNoBaseUrl()) return;
+    const tools = await mcpTools.getTools();
+    const getTimeTool = tools.find(t => t.name === 'mcp_get_current_time');
+
+    const timeResult = await getTimeTool.invoke({ timezone: 'Asia/Hong_Kong' });
+    const timeData = typeof timeResult === 'string' ? JSON.parse(timeResult) : timeResult;
+
+    assert.ok(timeData.timezone && timeData.timezone.includes('Hong_Kong'), 'Should return Hong Kong timezone');
+  });
+
+  it('should resolve library ID for langchain', async () => {
+    if (skipIfNoBaseUrl()) return;
+    const tools = await mcpTools.getTools();
+    const resolveTool = tools.find(t => t.name.includes('resolve') && t.name.includes('library'));
+
+    assert.ok(resolveTool, 'Should have resolve-library-id tool');
+
+    const resolveResult = await resolveTool.invoke({ libraryName: 'langchain' });
+
+    assert.ok(resolveResult, 'Should return a result');
+    assert.ok(typeof resolveResult === 'string' && resolveResult.length > 0, 'Result should be non-empty string');
+  });
+});

package/tests/mcp-e2e.test.mjs

@@ -0,0 +1,109 @@
+/**
+ * Integration Test: End-to-End Time MCP Server Integration
+ * Uses Node.js native test runner
+ */
+
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert';
+import { MCPTools } from '../dist/code/tools/mcp.js';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import { skipIfNoBaseUrl } from './test-helpers.mjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+describe('MCP E2E Time Server Integration', () => {
+  let mcpTools;
+  let configPath;
+  let originalConfig;
+
+  before(async () => {
+    if (skipIfNoBaseUrl()) return;
+    configPath = path.join(os.homedir(), '.codemie', 'config.json');
+
+    // Backup original config
+    try {
+      const content = await fs.readFile(configPath, 'utf-8');
+      originalConfig = JSON.parse(content);
+    } catch (error) {
+      await fs.mkdir(path.dirname(configPath), { recursive: true });
+      originalConfig = {};
+    }
+
+    // Ensure time server is configured
+    const config = { ...originalConfig };
+    if (!config.mcpServers) {
+      config.mcpServers = {};
+    }
+
+    config.mcpServers.time = {
+      transport: 'stdio',
+      command: 'uvx',
+      args: ['mcp-server-time']
+    };
+
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
+
+    mcpTools = new MCPTools(process.cwd());
+    await mcpTools.initialize(['time']);
+  });
+
+  after(async () => {
+    if (mcpTools) {
+      await mcpTools.dispose();
+    }
+
+    // Restore original config
+    if (originalConfig) {
+      await fs.writeFile(configPath, JSON.stringify(originalConfig, null, 2), 'utf-8');
+    }
+  });
+
+  it('should load tools from configured time server', async () => {
+    if (skipIfNoBaseUrl()) return;
+    const tools = await mcpTools.getTools();
+    assert.ok(tools.length > 0, 'Should have loaded tools');
+  });
+
+  it('should query time in Hong Kong', async () => {
+    if (skipIfNoBaseUrl()) return;
+    const tools = await mcpTools.getTools();
+    const getTimeTool = tools.find(t => t.name === 'mcp_get_current_time');
+
+    assert.ok(getTimeTool, 'get_current_time tool should exist');
+
+    const result = await getTimeTool.invoke({ timezone: 'Asia/Hong_Kong' });
+    const data = typeof result === 'string' ? JSON.parse(result) : result;
+
+    assert.ok(data.timezone && data.timezone.includes('Hong_Kong'), 'Should return Hong Kong timezone');
+    assert.ok(data.datetime, 'Should return datetime');
+    assert.ok(data.day_of_week, 'Should return day of week');
+  });
+
+  it('should convert time between timezones', async () => {
+    if (skipIfNoBaseUrl()) return;
+    const tools = await mcpTools.getTools();
+    const convertTimeTool = tools.find(t => t.name === 'mcp_convert_time');
+
+    assert.ok(convertTimeTool, 'convert_time tool should be available');
+
+    const convertResult = await convertTimeTool.invoke({
+      source_timezone: 'Asia/Hong_Kong',
+      time: '14:00',
+      target_timezone: 'America/New_York'
+    });
+
+    assert.ok(convertResult, 'Should return a result');
+
+    const convertData = typeof convertResult === 'string' ? JSON.parse(convertResult) : convertResult;
+
+    assert.ok(convertData.source, 'Should have source timezone data');
+    assert.ok(convertData.target, 'Should have target timezone data');
+    assert.ok(convertData.target.datetime, 'Should have target datetime');
+    assert.ok(convertData.target.timezone.includes('New_York'), 'Should convert to New York timezone');
+    assert.ok(convertData.time_difference, 'Should have time difference');
+  });
+});

package/tests/mcp-time-server.test.mjs

@@ -0,0 +1,58 @@
+/**
+ * Integration Test: Time MCP Server
+ * Uses Node.js native test runner
+ */
+
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert';
+import { MCPTools } from '../dist/code/tools/mcp.js';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { skipIfNoBaseUrl } from './test-helpers.mjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+describe('MCP Time Server', () => {
+  let mcpTools;
+
+  before(async () => {
+    if (skipIfNoBaseUrl()) return;
+
+    mcpTools = new MCPTools(process.cwd());
+    await mcpTools.initialize(['time']);
+  });
+
+  after(async () => {
+    if (mcpTools) {
+      await mcpTools.dispose();
+    }
+  });
+
+  it('should load tools from time server', async () => {
+    if (skipIfNoBaseUrl()) return;
+    const tools = await mcpTools.getTools();
+    assert.ok(tools.length > 0, 'Should have loaded tools from time server');
+  });
+
+  it('should have get_current_time tool', async () => {
+    if (skipIfNoBaseUrl()) return;
+    const tools = await mcpTools.getTools();
+    const getTimeTool = tools.find(t => t.name === 'mcp_get_current_time');
+    assert.ok(getTimeTool, 'get_current_time tool should be available');
+  });
+
+  it('should execute get_current_time tool', async () => {
+    if (skipIfNoBaseUrl()) return;
+    const tools = await mcpTools.getTools();
+    const getTimeTool = tools.find(t => t.name === 'mcp_get_current_time');
+
+    const result = await getTimeTool.invoke({ timezone: 'Europe/Vilnius' });
+
+    assert.ok(result, 'Tool should return a result');
+
+    // Try to parse the result
+    const data = typeof result === 'string' ? JSON.parse(result) : result;
+    assert.ok(data.datetime || data.timezone, 'Result should contain datetime or timezone');
+  });
+});