@grunnverk/kodrdriv 1.3.0

package/scripts/build-mcp.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+/**
+ * Build MCP Server
+ * Simple build script to compile the MCP server separately from main build
+ */
+
+import { build } from 'esbuild';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { readFileSync, writeFileSync, chmodSync } from 'fs';
+import { execSync } from 'child_process';
+import os from 'os';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const root = resolve(__dirname, '..');
+
+// Capture git info
+let gitInfo = {
+    branch: '',
+    commit: '',
+    tags: '',
+    commitDate: '',
+};
+
+try {
+    gitInfo = {
+        branch: execSync('git rev-parse --abbrev-ref HEAD').toString().trim(),
+        commit: execSync('git rev-parse --short HEAD').toString().trim(),
+        tags: '',
+        commitDate: execSync('git log -1 --format=%cd --date=iso').toString().trim(),
+    };
+
+    try {
+        gitInfo.tags = execSync('git tag --points-at HEAD | paste -sd "," -').toString().trim();
+    } catch {
+        gitInfo.tags = '';
+    }
+} catch {
+    console.log('No git repository, using placeholder values');
+}
+
+// Capture build metadata
+const buildInfo = {
+    hostname: os.hostname(),
+    timestamp: new Date().toISOString(),
+};
+
+// Get package version
+const packageJson = JSON.parse(readFileSync(resolve(root, 'package.json'), 'utf-8'));
+const version = packageJson.version;
+
+async function buildMCPServer() {
+    try {
+        console.log('Building MCP server...');
+
+        await build({
+            entryPoints: [resolve(root, 'src/mcp/server.ts')],
+            bundle: true,
+            platform: 'node',
+            target: 'esnext',
+            format: 'esm',
+            outfile: resolve(root, 'dist/mcp-server.js'),
+            external: [
+                '@modelcontextprotocol/*',
+                '@grunnverk/*',
+                '@theunwalked/*',
+                '@riotprompt/*',
+                // Winston and its dependencies use dynamic requires that don't work when bundled
+                // These must be external dependencies, not bundled
+                'winston',
+                'winston/*',
+                'logform',
+                'logform/*',
+                '@colors/colors',
+                '@colors/safe',
+            ],
+            sourcemap: true,
+        });
+
+        // Add shebang and replace placeholders
+        const outputPath = resolve(root, 'dist/mcp-server.js');
+        let content = readFileSync(outputPath, 'utf-8');
+
+        // Replace placeholders
+        content = content.replace(/__VERSION__/g, version);
+        content = content.replace(/__GIT_BRANCH__/g, gitInfo.branch);
+        content = content.replace(/__GIT_COMMIT__/g, gitInfo.commit);
+        content = content.replace(/__GIT_TAGS__/g, gitInfo.tags === '' ? '' : `T:${gitInfo.tags}`);
+        content = content.replace(/__GIT_COMMIT_DATE__/g, gitInfo.commitDate);
+        content = content.replace(/__SYSTEM_INFO__/g, `${process.platform} ${process.arch} ${process.version}`);
+        content = content.replace(/__BUILD_HOSTNAME__/g, buildInfo.hostname);
+        content = content.replace(/__BUILD_TIMESTAMP__/g, buildInfo.timestamp);
+
+        if (!content.startsWith('#!')) {
+            content = `#!/usr/bin/env node\n${content}`;
+        }
+
+        writeFileSync(outputPath, content);
+
+        // Make executable
+        chmodSync(outputPath, 0o755);
+
+        console.log('✓ MCP server built successfully');
+    } catch (error) {
+        console.error('✗ MCP server build failed:', error);
+        process.exit(1);
+    }
+}
+
+buildMCPServer();

package/scripts/pre-commit-hook.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+
+# KodrDriv Pre-commit Hook
+# Prevents committing package.json files that contain file: dependencies
+#
+# To install this hook:
+# 1. Copy this file to .git/hooks/pre-commit
+# 2. Make it executable: chmod +x .git/hooks/pre-commit
+#
+# Or run: npm run install-hooks (if you add this script to package.json)
+
+echo "🔍 Checking for file: dependencies in staged package.json files..."
+
+# Find all staged package.json files
+staged_package_files=$(git diff --cached --name-only | grep "package\.json$")
+
+if [ -z "$staged_package_files" ]; then
+    echo "✅ No package.json files staged for commit"
+    exit 0
+fi
+
+found_file_deps=false
+
+# Check each staged package.json file for file: dependencies
+for file in $staged_package_files; do
+    if [ -f "$file" ]; then
+        # Look for "file:" dependencies in the staged version
+        if git show :$file | grep -q '"file:'; then
+            echo "❌ Found file: dependencies in $file:"
+            git show :$file | grep '"file:' | sed 's/^/    /'
+            found_file_deps=true
+        fi
+    fi
+done
+
+if $found_file_deps; then
+    echo ""
+    echo "🚫 COMMIT BLOCKED: Cannot commit package.json files with file: dependencies"
+    echo ""
+    echo "💡 To fix this:"
+    echo "   1. Run 'kodrdriv unlink' to restore registry versions"
+    echo "   2. Commit your changes"
+    echo "   3. Run 'kodrdriv link' again for local development"
+    echo ""
+    echo "   Or to commit anyway (not recommended):"
+    echo "   git commit --no-verify"
+    echo ""
+    exit 1
+fi
+
+echo "✅ No file: dependencies found in staged package.json files"
+exit 0

package/scripts/test-get-version-tool.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+/**
+ * Test get_version MCP tool
+ */
+
+import { spawn } from 'child_process';
+import { resolve } from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const SERVER_PATH = resolve(__dirname, '../dist/mcp-server.js');
+const TIMEOUT_MS = 5000;
+
+console.log('🔍 Testing get_version tool...\n');
+
+function sendMCPRequest(server, method, params = {}) {
+    return new Promise((resolve, reject) => {
+        const id = Math.floor(Math.random() * 1000000);
+        const request = {
+            jsonrpc: '2.0',
+            id,
+            method,
+            params,
+        };
+
+        let response = '';
+        const timeout = setTimeout(() => {
+            reject(new Error('Request timeout'));
+        }, TIMEOUT_MS);
+
+        server.stdout.on('data', (data) => {
+            response += data.toString();
+            try {
+                const parsed = JSON.parse(response);
+                if (parsed.id === id) {
+                    clearTimeout(timeout);
+                    resolve(parsed);
+                }
+            } catch (e) {
+                // Still accumulating response
+            }
+        });
+
+        server.stdin.write(JSON.stringify(request) + '\n');
+    });
+}
+
+async function testGetVersionTool() {
+    const server = spawn('node', [SERVER_PATH], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    try {
+        // Initialize
+        await sendMCPRequest(server, 'initialize', {
+            protocolVersion: '2024-11-05',
+            capabilities: {},
+            clientInfo: { name: 'test', version: '1.0.0' },
+        });
+
+        // Call get_version tool
+        const response = await sendMCPRequest(server, 'tools/call', {
+            name: 'kodrdriv_get_version',
+            arguments: {},
+        });
+
+        if (response.result && response.result.content) {
+            const content = response.result.content[0];
+            console.log('✅ get_version tool executed successfully\n');
+            console.log('Response:');
+            console.log(content.text);
+            console.log('\n');
+
+            // Parse and display structured data
+            try {
+                const data = JSON.parse(content.text);
+                console.log('Parsed data:');
+                console.log('  Version:', data.version);
+                console.log('  Build Hostname:', data.buildHostname);
+                console.log('  Build Timestamp:', data.buildTimestamp);
+            } catch (e) {
+                // Response might be text format
+            }
+        } else {
+            throw new Error('Invalid response from get_version tool');
+        }
+
+        server.kill();
+        return true;
+    } catch (error) {
+        server.kill();
+        console.log(`❌ Test failed: ${error.message}\n`);
+        return false;
+    }
+}
+
+testGetVersionTool().then(success => {
+    process.exit(success ? 0 : 1);
+});

package/scripts/test-mcp-compliance.js

@@ -0,0 +1,254 @@
+#!/usr/bin/env node
+/**
+ * MCP Compliance Test
+ *
+ * Validates that kodrdriv MCP server follows MCP specification.
+ */
+
+import { spawn } from 'child_process';
+import { resolve } from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Test configuration
+const SERVER_PATH = resolve(__dirname, '../dist/mcp-server.js');
+const TIMEOUT_MS = 5000;
+
+console.log('🔍 Testing MCP Compliance for KodrDriv...\n');
+
+/**
+ * Helper to send JSON-RPC request to MCP server
+ */
+function sendMCPRequest(server, method, params = {}) {
+    return new Promise((resolve, reject) => {
+        const id = Math.floor(Math.random() * 1000000);
+        const request = {
+            jsonrpc: '2.0',
+            id,
+            method,
+            params,
+        };
+
+        let response = '';
+        const timeout = setTimeout(() => {
+            reject(new Error('Request timeout'));
+        }, TIMEOUT_MS);
+
+        server.stdout.on('data', (data) => {
+            response += data.toString();
+            try {
+                const parsed = JSON.parse(response);
+                if (parsed.id === id) {
+                    clearTimeout(timeout);
+                    resolve(parsed);
+                }
+            } catch (e) {
+                // Still accumulating response
+            }
+        });
+
+        server.stdin.write(JSON.stringify(request) + '\n');
+    });
+}
+
+// Test 1: Server starts and initializes
+async function testServerInitialization() {
+    console.log('Test 1: Server Initialization...');
+
+    const server = spawn('node', [SERVER_PATH], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    try {
+        const response = await sendMCPRequest(server, 'initialize', {
+            protocolVersion: '2024-11-05',
+            capabilities: {},
+            clientInfo: {
+                name: 'test-client',
+                version: '1.0.0',
+            },
+        });
+
+        if (response.result && response.result.protocolVersion) {
+            console.log('  ✅ Server initializes correctly');
+            console.log(`     Protocol: ${response.result.protocolVersion}`);
+            console.log(`     Server: ${response.result.serverInfo?.name || 'unknown'}\n`);
+        } else {
+            throw new Error('Invalid initialization response');
+        }
+
+        server.kill();
+        return true;
+    } catch (error) {
+        server.kill();
+        console.log(`  ⚠️  Initialization test skipped: ${error.message}\n`);
+        return false;
+    }
+}
+
+// Test 2: Server advertises capabilities
+async function testCapabilities() {
+    console.log('Test 2: Capabilities Advertisement...');
+
+    const server = spawn('node', [SERVER_PATH], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    try {
+        const initResponse = await sendMCPRequest(server, 'initialize', {
+            protocolVersion: '2024-11-05',
+            capabilities: {},
+            clientInfo: { name: 'test', version: '1.0.0' },
+        });
+
+        const caps = initResponse.result?.capabilities;
+        if (caps && caps.tools && caps.resources && caps.prompts) {
+            console.log('  ✅ Capabilities advertised correctly');
+            console.log('     - Tools: supported');
+            console.log('     - Resources: supported');
+            console.log('     - Prompts: supported\n');
+        } else {
+            throw new Error('Missing capabilities');
+        }
+
+        server.kill();
+        return true;
+    } catch (error) {
+        server.kill();
+        console.log(`  ⚠️  Capabilities test skipped: ${error.message}\n`);
+        return false;
+    }
+}
+
+// Test 3: Tools endpoint responds
+async function testToolsEndpoint() {
+    console.log('Test 3: Tools Endpoint...');
+
+    const server = spawn('node', [SERVER_PATH], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    try {
+        // Initialize first
+        await sendMCPRequest(server, 'initialize', {
+            protocolVersion: '2024-11-05',
+            capabilities: {},
+            clientInfo: { name: 'test', version: '1.0.0' },
+        });
+
+        const response = await sendMCPRequest(server, 'tools/list');
+
+        if (response.result && Array.isArray(response.result.tools)) {
+            console.log('  ✅ Tools endpoint responds correctly');
+            console.log(`     Found ${response.result.tools.length} tools`);
+            console.log(`     Sample: ${response.result.tools.slice(0, 3).map(t => t.name).join(', ')}\n`);
+        } else {
+            throw new Error('Invalid tools response');
+        }
+
+        server.kill();
+        return true;
+    } catch (error) {
+        server.kill();
+        console.log(`  ⚠️  Tools test skipped: ${error.message}\n`);
+        return false;
+    }
+}
+
+// Test 4: Resources endpoint responds
+async function testResourcesEndpoint() {
+    console.log('Test 4: Resources Endpoint...');
+
+    const server = spawn('node', [SERVER_PATH], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    try {
+        await sendMCPRequest(server, 'initialize', {
+            protocolVersion: '2024-11-05',
+            capabilities: {},
+            clientInfo: { name: 'test', version: '1.0.0' },
+        });
+
+        const response = await sendMCPRequest(server, 'resources/list');
+
+        if (response.result && Array.isArray(response.result.resources)) {
+            console.log('  ✅ Resources endpoint responds correctly');
+            console.log(`     Found ${response.result.resources.length} resources\n`);
+        } else {
+            throw new Error('Invalid resources response');
+        }
+
+        server.kill();
+        return true;
+    } catch (error) {
+        server.kill();
+        console.log(`  ⚠️  Resources test skipped: ${error.message}\n`);
+        return false;
+    }
+}
+
+// Test 5: Prompts endpoint responds
+async function testPromptsEndpoint() {
+    console.log('Test 5: Prompts Endpoint...');
+
+    const server = spawn('node', [SERVER_PATH], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    try {
+        await sendMCPRequest(server, 'initialize', {
+            protocolVersion: '2024-11-05',
+            capabilities: {},
+            clientInfo: { name: 'test', version: '1.0.0' },
+        });
+
+        const response = await sendMCPRequest(server, 'prompts/list');
+
+        if (response.result && Array.isArray(response.result.prompts)) {
+            console.log('  ✅ Prompts endpoint responds correctly');
+            console.log(`     Found ${response.result.prompts.length} prompts`);
+            console.log(`     Available: ${response.result.prompts.map(p => p.name).join(', ')}\n`);
+        } else {
+            throw new Error('Invalid prompts response');
+        }
+
+        server.kill();
+        return true;
+    } catch (error) {
+        server.kill();
+        console.log(`  ⚠️  Prompts test skipped: ${error.message}\n`);
+        return false;
+    }
+}
+
+// Run all tests
+async function runTests() {
+    let passed = 0;
+    let total = 5;
+
+    console.log(`MCP Server Path: ${SERVER_PATH}\n`);
+
+    if (await testServerInitialization()) passed++;
+    if (await testCapabilities()) passed++;
+    if (await testToolsEndpoint()) passed++;
+    if (await testResourcesEndpoint()) passed++;
+    if (await testPromptsEndpoint()) passed++;
+
+    console.log('─'.repeat(50));
+    if (passed === total) {
+        console.log(`✅ All ${total} compliance tests passed!\n`);
+        process.exit(0);
+    } else if (passed > 0) {
+        console.log(`⚠️  ${passed}/${total} tests passed (some tests skipped)\n`);
+        process.exit(0);
+    } else {
+        console.log(`❌ 0/${total} tests passed\n`);
+        process.exit(1);
+    }
+}
+
+runTests();

package/scripts/update-test-log-assertions.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+/**
+ * Helper script to identify and suggest updates for test log assertions
+ * after migrating to AI-friendly logging format
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Mapping of old emoji-based messages to new structured format patterns
+const logMessageMappings = {
+    // Success messages
+    '✅ ': 'SUCCESS: ',
+    '✓ ': 'SUCCESS: ',
+
+    // Error messages
+    '❌ ': 'FAILED: ',
+    '✗ ': 'FAILED: ',
+
+    // Warning messages
+    '⚠️ ': 'WARNING: ',
+
+    // Info messages
+    '🔄 ': '_SYNCING: ',
+    '📦 ': '_PACKAGE: ',
+    '🎯 ': '_TARGET: ',
+    '🏷️ ': '_TAG: ',
+    '📝 ': '_COMMIT: ',
+    '🚀 ': '_STARTING: ',
+    'ℹ️ ': '_INFO: ',
+    '💡 ': '_HINT: ',
+    '🔧 ': '_RESOLUTION: ',
+    '📊 ': '_ANALYSIS: ',
+    '🎉 ': '_COMPLETE: ',
+    '🔍 ': '_CHECK: ',
+    '📁 ': '_FILE: ',
+    '🤖 ': '_AI: ',
+    '🎵 ': '_AUDIO: ',
+    '🎙️ ': '_RECORDING: ',
+    '🏁 ': '_MILESTONE: ',
+    '🔓 ': '_UNLINK: ',
+    '🔗 ': '_LINK: ',
+};
+
+console.log('AI-Friendly Logging Test Update Helper');
+console.log('======================================\n');
+console.log('This script helps identify test assertions that need updating');
+console.log('after migrating to structured AI-friendly logging format.\n');
+
+console.log('Common patterns to update in tests:\n');
+console.log('OLD: expect(logger.info).toHaveBeenCalledWith(\'✅ Success message\')');
+console.log('NEW: expect(logger.info).toHaveBeenCalledWith(\'OPERATION_SUCCESS: Success message | Status: completed\')\n');
+
+console.log('OLD: expect(logger.warn).toHaveBeenCalledWith(\'⚠️  Warning message\')');
+console.log('NEW: expect(logger.warn).toHaveBeenCalledWith(\'OPERATION_WARNING: Warning message | Impact: ...\')\n');
+
+console.log('OLD: expect(logger.error).toHaveBeenCalledWith(\'❌ Error message\')');
+console.log('NEW: expect(logger.error).toHaveBeenCalledWith(\'OPERATION_FAILED: Error message | Error: ...\')\n');
+
+console.log('\nKey principles for new format:');
+console.log('1. OPERATION_STATE: prefix (SNAKE_CASE)');
+console.log('2. Pipe-separated key-value pairs');
+console.log('3. Include context: Package, Status, Error, Purpose, Action, etc.');
+console.log('4. No emojis in structured prefixes\n');
+
+console.log('Run full test suite to see failures:');
+console.log('  npm test -- --run\n');
+
+console.log('Then update test assertions to match new log format.');
+console.log('See AI-FRIENDLY-LOGGING-GUIDE.md for complete documentation.\n');
+
+process.exit(0);
+