@codemieai/code 0.0.1

package/tests/streaming.test.mjs

@@ -0,0 +1,57 @@
+/**
+ * Integration Test: Streaming functionality
+ * 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('Streaming', () => {
+  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 stream tool calling events', async () => {
+    if (skipIfNoBaseUrl()) return;
+
+    const events = [];
+
+    await new Promise((resolve, reject) => {
+      agent.chatStream('list files in this directory', (event) => {
+        events.push(event.type);
+
+        switch(event.type) {
+          case 'complete':
+            try {
+              assert.ok(events.includes('thinking_start'), 'Should emit thinking_start');
+              assert.ok(events.includes('thinking_end'), 'Should emit thinking_end');
+              assert.ok(events.includes('tool_call_start'), 'Should emit tool_call_start');
+              assert.ok(events.includes('tool_call_result'), 'Should emit tool_call_result');
+              assert.ok(events.includes('content_chunk'), 'Should emit content_chunk');
+              assert.ok(events.includes('complete'), 'Should emit complete');
+              resolve();
+            } catch (error) {
+              reject(error);
+            }
+            break;
+          case 'error':
+            reject(new Error(event.error));
+            break;
+        }
+      });
+    });
+  });
+});

package/tests/test-helpers.mjs

@@ -0,0 +1,94 @@
+/**
+ * Test helpers and utilities
+ * Provides common functionality for test files
+ */
+
+/**
+ * Check if base URL is configured for tests to run
+ * Tests that require LLM interaction need a valid base URL
+ *
+ * @returns {boolean} true if base URL is configured, false otherwise
+ */
+export function isBaseUrlConfigured() {
+  return !!(
+    process.env.CODEMIE_BASE_URL ||
+    process.env.ANTHROPIC_BASE_URL ||
+    process.env.OPENAI_BASE_URL
+  );
+}
+
+/**
+ * Check if we should skip tests that require base URL
+ * Prints a warning message if base URL is not configured
+ *
+ * This function returns true if tests should be skipped. Tests should check
+ * the return value and return early if true.
+ *
+ * @param {string} [customMessage] - Optional custom message to display
+ * @returns {boolean} true if test should be skipped, false otherwise
+ */
+export function skipIfNoBaseUrl(customMessage) {
+  if (!isBaseUrlConfigured()) {
+    const message = customMessage ||
+      'Base URL not configured. Set CODEMIE_BASE_URL, ANTHROPIC_BASE_URL, or OPENAI_BASE_URL environment variable.';
+
+    console.warn(`⚠️  Skipping test: ${message}`);
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Get list of required environment variables that are missing
+ *
+ * @returns {string[]} Array of missing environment variable names
+ */
+export function getMissingEnvVars() {
+  const missing = [];
+
+  // Check base URL
+  if (!isBaseUrlConfigured()) {
+    missing.push('BASE_URL (CODEMIE_BASE_URL, ANTHROPIC_BASE_URL, or OPENAI_BASE_URL)');
+  }
+
+  // Check auth token
+  const hasAuthToken = !!(
+    process.env.CODEMIE_AUTH_TOKEN ||
+    process.env.CODEMIE_API_KEY ||
+    process.env.ANTHROPIC_AUTH_TOKEN ||
+    process.env.ANTHROPIC_API_KEY ||
+    process.env.OPENAI_AUTH_TOKEN ||
+    process.env.OPENAI_API_KEY
+  );
+
+  if (!hasAuthToken) {
+    missing.push('AUTH_TOKEN (CODEMIE_AUTH_TOKEN, ANTHROPIC_AUTH_TOKEN, or OPENAI_AUTH_TOKEN)');
+  }
+
+  return missing;
+}
+
+/**
+ * Check if all required environment variables are configured
+ *
+ * @returns {boolean} true if all required env vars are set
+ */
+export function isFullyConfigured() {
+  return getMissingEnvVars().length === 0;
+}
+
+/**
+ * Print configuration status for debugging
+ */
+export function printConfigStatus() {
+  console.log('\n=== Test Configuration Status ===');
+  console.log('Base URL configured:', isBaseUrlConfigured());
+  console.log('Fully configured:', isFullyConfigured());
+
+  const missing = getMissingEnvVars();
+  if (missing.length > 0) {
+    console.log('\nMissing configuration:');
+    missing.forEach(env => console.log(`  - ${env}`));
+  }
+  console.log('=================================\n');
+}

package/tests/text-wrapping.test.mjs

@@ -0,0 +1,33 @@
+/**
+ * Integration Test: Text wrapping
+ * Uses Node.js native test runner
+ */
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+
+describe('Text Wrapping', () => {
+  it('should split long text into lines', () => {
+    const longText = `I'll list the files in the current directory (\`/Users/Nikita_Levyankov/repos/EPMCDME/codemie-tools\`):
+
+**Directories:**
+- \`.claude\` - Claude configuration
+- \`src\` - Source code
+- \`dist\` - Distribution files`;
+
+    const lines = longText.split('\n');
+
+    assert.ok(lines.length > 1, 'Should have multiple lines');
+    assert.ok(lines[0].includes('list the files'), 'First line should contain intro');
+    assert.ok(lines.some(l => l.includes('Directories')), 'Should contain Directories header');
+  });
+
+  it('should preserve markdown formatting in lines', () => {
+    const text = '**Directories:**\n- `.claude` - Claude configuration';
+    const lines = text.split('\n');
+
+    assert.ok(lines[0].includes('**'), 'Should preserve bold markdown');
+    assert.ok(lines[1].includes('`'), 'Should preserve code markdown');
+    assert.ok(lines[1].startsWith('- '), 'Should preserve list formatting');
+  });
+});

package/tests/tool-count.test.mjs

@@ -0,0 +1,81 @@
+/**
+ * Integration Test: Verify MCP tools are loaded correctly
+ * 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('Tool Loading', () => {
+  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 load all tools', () => {
+    if (skipIfNoBaseUrl()) return;
+    const agent = assistant.agent;
+    const tools = agent.tools;
+
+    assert.ok(tools, 'Tools should be defined');
+    assert.ok(tools.length > 0, 'Should have loaded tools');
+  });
+
+  it('should load tools by category', () => {
+    if (skipIfNoBaseUrl()) return;
+    const agent = assistant.agent;
+    const tools = agent.tools;
+
+    const toolTypes = {
+      filesystem: [],
+      command: [],
+      git: [],
+      mcp: [],
+      other: []
+    };
+
+    tools.forEach(tool => {
+      if (tool.name.startsWith('mcp_')) {
+        toolTypes.mcp.push(tool);
+      } else if (tool.name.includes('file') || tool.name.includes('directory') || tool.name.includes('read') || tool.name.includes('write')) {
+        toolTypes.filesystem.push(tool);
+      } else if (tool.name.includes('command') || tool.name.includes('execute')) {
+        toolTypes.command.push(tool);
+      } else if (tool.name.includes('git')) {
+        toolTypes.git.push(tool);
+      } else {
+        toolTypes.other.push(tool);
+      }
+    });
+
+    assert.ok(toolTypes.filesystem.length >= 8, `Expected >= 8 filesystem tools, got ${toolTypes.filesystem.length}`);
+    assert.ok(toolTypes.command.length >= 2, `Expected >= 2 command tools, got ${toolTypes.command.length}`);
+    assert.ok(toolTypes.git.length >= 3, `Expected >= 3 git tools, got ${toolTypes.git.length}`);
+  });
+
+  it('should load MCP tools from context7', () => {
+    if (skipIfNoBaseUrl()) return;
+    const agent = assistant.agent;
+    const tools = agent.tools;
+
+    const mcpTools = tools.filter(tool => tool.name.startsWith('mcp_'));
+
+    assert.ok(mcpTools.length >= 2, `Expected >= 2 MCP tools, got ${mcpTools.length}`);
+
+    const toolNames = mcpTools.map(t => t.name);
+    assert.ok(toolNames.includes('mcp_resolve-library-id'), 'Should have mcp_resolve-library-id');
+    assert.ok(toolNames.includes('mcp_get-library-docs'), 'Should have mcp_get-library-docs');
+  });
+});

package/tests/ui-format.test.mjs

@@ -0,0 +1,39 @@
+/**
+ * Integration Test: UI formatting
+ * Uses Node.js native test runner
+ */
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+
+describe('UI Format', () => {
+  it('should format tool calls correctly', () => {
+    const toolName = 'Bash';
+    const toolArgs = { command: 'ls -la' };
+    const formatted = `⏺ ${toolName}(${JSON.stringify(toolArgs)})`;
+
+    assert.ok(formatted.includes('⏺'), 'Should include bullet point');
+    assert.ok(formatted.includes('Bash'), 'Should include tool name');
+    assert.ok(formatted.includes('ls -la'), 'Should include arguments');
+  });
+
+  it('should format tool results with indentation', () => {
+    const result = 'total 672\ndrwxr-xr-x@  21 Nikita_Levyankov';
+    const lines = result.split('\n');
+    const formatted = `  ⎿  ${lines[0]}`;
+
+    assert.ok(formatted.includes('⎿'), 'Should include corner symbol');
+    assert.ok(formatted.startsWith('  '), 'Should be indented');
+    assert.ok(formatted.includes('total 672'), 'Should include result content');
+  });
+
+  it('should truncate long multi-line results', () => {
+    const result = Array(20).fill('line').join('\n');
+    const lines = result.split('\n');
+    const displayLines = lines.slice(0, 3);
+    const hiddenLines = Math.max(0, lines.length - 3);
+
+    assert.strictEqual(displayLines.length, 3, 'Should show only 3 lines');
+    assert.strictEqual(hiddenLines, 17, 'Should hide 17 lines');
+  });
+});

package/tests/ui-state.test.mjs

@@ -0,0 +1,72 @@
+/**
+ * Integration Test: UI state management
+ * 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('UI State Management', () => {
+  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 consecutive messages without blocking', async () => {
+    if (skipIfNoBaseUrl()) return;
+    const mockUIState = {
+      isProcessing: false,
+      inputEnabled: true
+    };
+
+    const questions = [
+      'What is 2+2?',
+      'What is the capital of France?',
+      'List files in current directory'
+    ];
+
+    let messageCount = 0;
+
+    for (let i = 0; i < questions.length; i++) {
+      const question = questions[i];
+
+      // Check if processing (simulating UI check)
+      assert.strictEqual(mockUIState.isProcessing, false, `Should not be processing before question ${i + 1}`);
+
+      // Set processing flag (like the UI does)
+      mockUIState.isProcessing = true;
+      mockUIState.inputEnabled = false;
+
+      try {
+        // Call the agent
+        await assistant.agent.chatStream(question, (event) => {
+          // Track events silently
+        });
+
+        messageCount++;
+      } finally {
+        // Reset state (like the UI does)
+        mockUIState.isProcessing = false;
+        mockUIState.inputEnabled = true;
+      }
+
+      // Verify state is properly reset
+      assert.strictEqual(mockUIState.isProcessing, false, `isProcessing should be reset after question ${i + 1}`);
+      assert.strictEqual(mockUIState.inputEnabled, true, `inputEnabled should be reset after question ${i + 1}`);
+    }
+
+    assert.strictEqual(messageCount, 3, 'Should have processed all 3 messages');
+  });
+});