@inkeep/agents-cli 0.1.5 → 0.1.6

package/dist/types/config.d.ts

@@ -1,9 +0,0 @@
-import type { ModelSettings } from '@inkeep/agents-core';
-export interface InkeepConfig {
-    tenantId: string;
-    projectId: string;
-    apiUrl?: string;
-    outputDirectory?: string;
-    modelSettings?: ModelSettings;
-}
-export declare function defineConfig(config: InkeepConfig): InkeepConfig;

package/dist/types/config.js

@@ -1,3 +0,0 @@
-export function defineConfig(config) {
-    return config;
-}

package/dist/types/graph.d.ts

@@ -1,10 +0,0 @@
-export interface GraphData {
-    id: string;
-    name: string;
-    description?: string;
-    agents: Record<string, any>;
-    tools: Record<string, any>;
-    contextConfigs: any[];
-    credentialReferences: any[];
-}
-export type FullGraphDefinition = GraphData;

package/dist/types/graph.js

@@ -1 +0,0 @@
-export {};

package/dist/utils/json-comparator.d.ts

@@ -1,60 +0,0 @@
-/**
- * Options for JSON comparison
- */
-export interface ComparisonOptions {
-    /** Whether to ignore order in arrays (default: true) */
-    ignoreArrayOrder?: boolean;
-    /** Whether to ignore case in string comparisons (default: false) */
-    ignoreCase?: boolean;
-    /** Whether to ignore whitespace differences (default: false) */
-    ignoreWhitespace?: boolean;
-    /** Custom key paths to ignore during comparison */
-    ignorePaths?: string[];
-    /** Whether to show detailed differences (default: false) */
-    showDetails?: boolean;
-}
-/**
- * Result of JSON comparison
- */
-export interface ComparisonResult {
-    /** Whether the objects are equivalent */
-    isEqual: boolean;
-    /** List of differences found */
-    differences: Difference[];
-    /** Summary statistics */
-    stats: {
-        totalKeys: number;
-        differentKeys: number;
-        missingKeys: number;
-        extraKeys: number;
-    };
-}
-/**
- * Represents a difference between two objects
- */
-export interface Difference {
-    /** Path to the differing value */
-    path: string;
-    /** Type of difference */
-    type: 'different' | 'missing' | 'extra' | 'type_mismatch';
-    /** Value in the first object */
-    value1?: any;
-    /** Value in the second object */
-    value2?: any;
-    /** Description of the difference */
-    description: string;
-}
-/**
- * Compare two JSON objects for structural equivalence
- * Handles arrays with different ordering and nested objects
- */
-export declare function compareJsonObjects(obj1: any, obj2: any, options?: ComparisonOptions): ComparisonResult;
-/**
- * Create a normalized version of a JSON object for comparison
- * This can be useful for creating a canonical representation
- */
-export declare function normalizeJsonObject(obj: any, options?: ComparisonOptions): any;
-/**
- * Get a summary of differences in a human-readable format
- */
-export declare function getDifferenceSummary(result: ComparisonResult): string;

package/dist/utils/json-comparator.js

@@ -1,222 +0,0 @@
-/**
- * Compare two JSON objects for structural equivalence
- * Handles arrays with different ordering and nested objects
- */
-export function compareJsonObjects(obj1, obj2, options = {}) {
-    const { ignoreArrayOrder = true, ignoreCase = false, ignoreWhitespace = false, ignorePaths = [], } = options;
-    const differences = [];
-    const stats = {
-        totalKeys: 0,
-        differentKeys: 0,
-        missingKeys: 0,
-        extraKeys: 0,
-    };
-    function normalizeValue(value) {
-        if (typeof value === 'string') {
-            let normalized = value;
-            if (ignoreCase) {
-                normalized = normalized.toLowerCase();
-            }
-            if (ignoreWhitespace) {
-                normalized = normalized.trim().replace(/\s+/g, ' ');
-            }
-            return normalized;
-        }
-        return value;
-    }
-    function shouldIgnorePath(path) {
-        return ignorePaths.some((ignorePath) => {
-            if (ignorePath.endsWith('*')) {
-                return path.startsWith(ignorePath.slice(0, -1));
-            }
-            return path === ignorePath;
-        });
-    }
-    function compareValues(value1, value2, path = '') {
-        if (shouldIgnorePath(path)) {
-            return true;
-        }
-        // Handle null/undefined
-        if (value1 === null || value1 === undefined) {
-            if (value2 === null || value2 === undefined) {
-                return true;
-            }
-            differences.push({
-                path,
-                type: 'different',
-                value1,
-                value2,
-                description: `Null/undefined mismatch: ${value1} vs ${value2}`,
-            });
-            return false;
-        }
-        if (value2 === null || value2 === undefined) {
-            differences.push({
-                path,
-                type: 'different',
-                value1,
-                value2,
-                description: `Null/undefined mismatch: ${value1} vs ${value2}`,
-            });
-            return false;
-        }
-        // Handle different types
-        if (typeof value1 !== typeof value2) {
-            differences.push({
-                path,
-                type: 'type_mismatch',
-                value1,
-                value2,
-                description: `Type mismatch: ${typeof value1} vs ${typeof value2}`,
-            });
-            return false;
-        }
-        // Handle primitives
-        if (typeof value1 !== 'object') {
-            const normalized1 = normalizeValue(value1);
-            const normalized2 = normalizeValue(value2);
-            if (normalized1 !== normalized2) {
-                differences.push({
-                    path,
-                    type: 'different',
-                    value1,
-                    value2,
-                    description: `Value mismatch: ${value1} vs ${value2}`,
-                });
-                return false;
-            }
-            return true;
-        }
-        // Handle arrays
-        if (Array.isArray(value1) && Array.isArray(value2)) {
-            if (value1.length !== value2.length) {
-                differences.push({
-                    path,
-                    type: 'different',
-                    value1: value1.length,
-                    value2: value2.length,
-                    description: `Array length mismatch: ${value1.length} vs ${value2.length}`,
-                });
-                return false; // Array length mismatch is a fundamental difference
-            }
-            if (ignoreArrayOrder) {
-                // Compare arrays ignoring order
-                const sorted1 = [...value1].sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
-                const sorted2 = [...value2].sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
-                for (let i = 0; i < sorted1.length; i++) {
-                    compareValues(sorted1[i], sorted2[i], `${path}[${i}]`); // Don't return false, just collect differences
-                }
-            }
-            else {
-                // Compare arrays in order
-                for (let i = 0; i < value1.length; i++) {
-                    compareValues(value1[i], value2[i], `${path}[${i}]`); // Don't return false, just collect differences
-                }
-            }
-            return true;
-        }
-        // Handle objects
-        if (typeof value1 === 'object' && typeof value2 === 'object') {
-            const keys1 = Object.keys(value1);
-            const keys2 = Object.keys(value2);
-            const allKeys = new Set([...keys1, ...keys2]);
-            stats.totalKeys += allKeys.size;
-            for (const key of allKeys) {
-                const currentPath = path ? `${path}.${key}` : key;
-                if (!keys1.includes(key)) {
-                    differences.push({
-                        path: currentPath,
-                        type: 'missing',
-                        value2: value2[key],
-                        description: `Missing key in first object: ${key}`,
-                    });
-                    stats.missingKeys++;
-                    continue; // Continue checking other keys instead of returning false
-                }
-                if (!keys2.includes(key)) {
-                    differences.push({
-                        path: currentPath,
-                        type: 'extra',
-                        value1: value1[key],
-                        description: `Extra key in first object: ${key}`,
-                    });
-                    stats.extraKeys++;
-                    continue; // Continue checking other keys instead of returning false
-                }
-                if (!compareValues(value1[key], value2[key], currentPath)) {
-                    stats.differentKeys++;
-                    // Don't return false here, continue checking other keys
-                }
-            }
-            return true;
-        }
-        return true;
-    }
-    compareValues(obj1, obj2);
-    return {
-        isEqual: differences.length === 0,
-        differences,
-        stats,
-    };
-}
-/**
- * Create a normalized version of a JSON object for comparison
- * This can be useful for creating a canonical representation
- */
-export function normalizeJsonObject(obj, options = {}) {
-    const { ignoreArrayOrder = true, ignoreCase = false, ignoreWhitespace = false } = options;
-    function normalizeValue(value) {
-        if (typeof value === 'string') {
-            let normalized = value;
-            if (ignoreCase) {
-                normalized = normalized.toLowerCase();
-            }
-            if (ignoreWhitespace) {
-                normalized = normalized.trim().replace(/\s+/g, ' ');
-            }
-            return normalized;
-        }
-        if (Array.isArray(value)) {
-            const normalizedArray = value.map(normalizeValue);
-            if (ignoreArrayOrder) {
-                return normalizedArray.sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
-            }
-            return normalizedArray;
-        }
-        if (typeof value === 'object' && value !== null) {
-            const normalizedObj = {};
-            const sortedKeys = Object.keys(value).sort();
-            for (const key of sortedKeys) {
-                normalizedObj[key] = normalizeValue(value[key]);
-            }
-            return normalizedObj;
-        }
-        return value;
-    }
-    return normalizeValue(obj);
-}
-/**
- * Get a summary of differences in a human-readable format
- */
-export function getDifferenceSummary(result) {
-    if (result.isEqual) {
-        return '✅ Objects are equivalent';
-    }
-    const { differences, stats } = result;
-    const summary = [`❌ Objects differ (${differences.length} differences found)`];
-    summary.push(`📊 Statistics:`);
-    summary.push(`  • Total keys: ${stats.totalKeys}`);
-    summary.push(`  • Different values: ${stats.differentKeys}`);
-    summary.push(`  • Missing keys: ${stats.missingKeys}`);
-    summary.push(`  • Extra keys: ${stats.extraKeys}`);
-    if (differences.length > 0) {
-        summary.push(`\n🔍 Differences:`);
-        differences.slice(0, 10).forEach((diff, index) => {
-            summary.push(`  ${index + 1}. ${diff.path}: ${diff.description}`);
-        });
-        if (differences.length > 10) {
-            summary.push(`  ... and ${differences.length - 10} more differences`);
-        }
-    }
-    return summary.join('\n');
-}

package/dist/utils/mcp-runner.d.ts

@@ -1,6 +0,0 @@
-#!/usr/bin/env node
-/**
- * MCP Runner - Loads and starts MCP servers from a graph file
- * This is executed as a subprocess by the CLI
- */
-export {};

package/dist/utils/mcp-runner.js

@@ -1,147 +0,0 @@
-#!/usr/bin/env node
-/**
- * MCP Runner - Loads and starts MCP servers from a graph file
- * This is executed as a subprocess by the CLI
- */
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
-import http from 'node:http';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-const MCP_DIR = join(homedir(), '.inkeep', 'mcp');
-const REGISTRY_FILE = join(MCP_DIR, 'servers.json');
-// Ensure MCP directory exists
-if (!existsSync(MCP_DIR)) {
-    mkdirSync(MCP_DIR, { recursive: true });
-}
-async function startServers(graphPath) {
-    try {
-        // Import the graph module
-        const module = await import(graphPath);
-        // Get servers
-        const servers = module.servers || module.tools || [];
-        // Get graph ID
-        let graphId = 'unknown';
-        if (module.graph && typeof module.graph.getId === 'function') {
-            graphId = module.graph.getId();
-        }
-        const registeredServers = [];
-        let nextPort = 3100;
-        // Start each server
-        for (const server of servers) {
-            if (!server)
-                continue;
-            // Get server metadata
-            const name = server.name || 'unnamed';
-            const id = server.id || name;
-            const description = server.description || '';
-            // Check deployment type
-            const isLocal = typeof server.execute === 'function' ||
-                typeof server.init === 'function' ||
-                !server.serverUrl;
-            if (isLocal) {
-                // Start local server
-                const port = server.port || nextPort++;
-                // Initialize if needed
-                if (typeof server.init === 'function') {
-                    await server.init();
-                }
-                // Create HTTP server for local MCP
-                if (typeof server.execute === 'function') {
-                    const httpServer = http.createServer(async (req, res) => {
-                        if (req.method === 'POST' && req.url === '/mcp') {
-                            let body = '';
-                            req.on('data', (chunk) => (body += chunk));
-                            req.on('end', async () => {
-                                try {
-                                    const params = JSON.parse(body);
-                                    const result = await server.execute(params);
-                                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                                    res.end(JSON.stringify({ result }));
-                                }
-                                catch (error) {
-                                    res.writeHead(500, { 'Content-Type': 'application/json' });
-                                    res.end(JSON.stringify({ error: error.message }));
-                                }
-                            });
-                        }
-                        else {
-                            res.writeHead(404);
-                            res.end('Not Found');
-                        }
-                    });
-                    httpServer.listen(port, () => {
-                        console.log(JSON.stringify({
-                            type: 'server_started',
-                            name,
-                            port,
-                            deployment: 'local',
-                        }));
-                    });
-                }
-                registeredServers.push({
-                    pid: process.pid,
-                    graphId,
-                    toolId: id,
-                    name,
-                    port,
-                    deployment: 'local',
-                    transport: 'http',
-                    command: graphPath,
-                    startedAt: new Date().toISOString(),
-                    description,
-                });
-            }
-            else {
-                // Register remote server
-                registeredServers.push({
-                    pid: process.pid,
-                    graphId,
-                    toolId: id,
-                    name,
-                    serverUrl: server.serverUrl || server.getServerUrl?.(),
-                    deployment: 'remote',
-                    transport: server.transport || 'http',
-                    command: graphPath,
-                    startedAt: new Date().toISOString(),
-                    description,
-                });
-                console.log(JSON.stringify({
-                    type: 'server_registered',
-                    name,
-                    serverUrl: server.serverUrl,
-                    deployment: 'remote',
-                }));
-            }
-        }
-        // Save to registry
-        writeFileSync(REGISTRY_FILE, JSON.stringify({ servers: registeredServers }, null, 2));
-        console.log(JSON.stringify({
-            type: 'all_started',
-            count: registeredServers.length,
-        }));
-        // Keep process alive
-        process.stdin.resume();
-        // Handle shutdown
-        process.on('SIGINT', () => {
-            console.log(JSON.stringify({ type: 'shutting_down' }));
-            process.exit(0);
-        });
-    }
-    catch (error) {
-        console.error(JSON.stringify({
-            type: 'error',
-            message: error.message,
-        }));
-        process.exit(1);
-    }
-}
-// Get graph path from command line
-const graphPath = process.argv[2];
-if (!graphPath) {
-    console.error(JSON.stringify({
-        type: 'error',
-        message: 'Graph path is required',
-    }));
-    process.exit(1);
-}
-startServers(graphPath);

package/dist/utils/ts-loader.d.ts

@@ -1,5 +0,0 @@
-/**
- * Loads a TypeScript module and returns its exports
- * This works by creating a temporary loader script that tsx can execute
- */
-export declare function loadTypeScriptModule(filePath: string): Promise<any>;

package/dist/utils/ts-loader.js

@@ -1,145 +0,0 @@
-import { execFileSync } from 'node:child_process';
-import { mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { pathToFileURL } from 'node:url';
-/**
- * Loads a TypeScript module and returns its exports
- * This works by creating a temporary loader script that tsx can execute
- */
-export async function loadTypeScriptModule(filePath) {
-    const tempDir = join(tmpdir(), 'inkeep-cli-loader');
-    mkdirSync(tempDir, { recursive: true });
-    const loaderPath = join(tempDir, 'loader.mjs');
-    const outputPath = join(tempDir, 'output.json');
-    // Create a loader script that will import the module and serialize its exports
-    const loaderScript = `
-import { writeFileSync } from 'fs';
-
-async function loadModule() {
-    try {
-        const module = await import('${pathToFileURL(filePath).href}');
-        
-        // Serialize the module exports (functions can't be serialized, so we just mark them)
-        const serializable = {};
-        
-        for (const [key, value] of Object.entries(module)) {
-            if (typeof value === 'function') {
-                // Mark functions
-                serializable[key] = { __type: 'function', name: value.name || key };
-            } else if (value && typeof value === 'object') {
-                // For objects, check if they have specific methods/properties
-                const obj = { __type: 'object' };
-                
-                // Check for config-like properties (for inkeep.config.ts files)
-                if (value.tenantId) obj.tenantId = value.tenantId;
-                if (value.projectId) obj.projectId = value.projectId;
-                if (value.apiUrl) obj.apiUrl = value.apiUrl;
-                if (value.outputDirectory) obj.outputDirectory = value.outputDirectory;
-                if (value.modelSettings) obj.modelSettings = value.modelSettings;
-                
-                // Check for tool-like properties
-                if (value.id) obj.id = value.id;
-                if (value.name) obj.name = value.name;
-                if (value.description) obj.description = value.description;
-                if (value.serverUrl) obj.serverUrl = value.serverUrl;
-                if (value.port) obj.port = value.port;
-                if (value.deployment) obj.deployment = value.deployment;
-                if (value.transport) obj.transport = value.transport;
-                if (typeof value.execute === 'function') obj.hasExecute = true;
-                if (typeof value.init === 'function') obj.hasInit = true;
-                if (typeof value.getServerUrl === 'function') obj.hasGetServerUrl = true;
-                if (typeof value.getId === 'function') {
-                    try {
-                        obj.graphId = value.getId();
-                    } catch {}
-                }
-                
-                // Check if it's an array
-                if (Array.isArray(value)) {
-                    obj.__type = 'array';
-                    obj.items = value.map(item => {
-                        if (item && typeof item === 'object') {
-                            const itemObj = {};
-                            if (item.id) itemObj.id = item.id;
-                            if (item.name) itemObj.name = item.name;
-                            if (item.description) itemObj.description = item.description;
-                            if (item.serverUrl) itemObj.serverUrl = item.serverUrl;
-                            if (item.port) itemObj.port = item.port;
-                            if (item.deployment) itemObj.deployment = item.deployment;
-                            if (item.transport) itemObj.transport = item.transport;
-                            if (typeof item.execute === 'function') itemObj.hasExecute = true;
-                            if (typeof item.init === 'function') itemObj.hasInit = true;
-                            if (typeof item.getServerUrl === 'function') itemObj.hasGetServerUrl = true;
-                            return itemObj;
-                        }
-                        return item;
-                    });
-                }
-                
-                serializable[key] = obj;
-            } else {
-                serializable[key] = value;
-            }
-        }
-        
-        writeFileSync('${outputPath}', JSON.stringify(serializable, null, 2));
-        process.exit(0);
-    } catch (error) {
-        console.error('Failed to load module:', error.message);
-        writeFileSync('${outputPath}', JSON.stringify({ __error: error.message }));
-        process.exit(1);
-    }
-}
-
-loadModule();
-`;
-    try {
-        // Write the loader script
-        writeFileSync(loaderPath, loaderScript);
-        // Execute the loader script with tsx, passing environment variables
-        // Load the .env file from the graph directory if it exists
-        const graphDir = dirname(filePath);
-        const envPath = join(graphDir, '..', '.env');
-        const envVars = { ...process.env };
-        // If no environment variables are set, use test defaults
-        if (!process.env.ENVIRONMENT) {
-            envVars.ENVIRONMENT = 'test';
-            envVars.DB_FILE_NAME = ':memory:'; // Use in-memory DB for CLI testing
-            envVars.ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY || 'test-key';
-        }
-        // Use node directly with tsx for better performance in CI
-        // Try to find tsx in node_modules first for better performance
-        const tsxPath = join(process.cwd(), 'node_modules', '.bin', 'tsx');
-        const command = require('fs').existsSync(tsxPath) ? tsxPath : 'tsx';
-        execFileSync(command, [loaderPath], {
-            cwd: process.cwd(), // Use cwd which is in the pnpm workspace
-            stdio: 'pipe',
-            encoding: 'utf-8',
-            env: envVars,
-            timeout: 15000, // Reduced to 15 second timeout for faster failure detection
-            windowsHide: true, // Hide console window on Windows
-        });
-        // Read the output
-        const outputJson = readFileSync(outputPath, 'utf-8');
-        const output = JSON.parse(outputJson);
-        // Clean up with retries to handle file locks
-        rmSync(tempDir, { recursive: true, force: true, maxRetries: 3 });
-        if (output.__error) {
-            throw new Error(output.__error);
-        }
-        return output;
-    }
-    catch (error) {
-        // Clean up on error
-        try {
-            rmSync(tempDir, { recursive: true, force: true, maxRetries: 3 });
-        }
-        catch { }
-        // Add more context to timeout errors
-        if (error.code === 'ETIMEDOUT' || error.message?.includes('timed out')) {
-            throw new Error(`TypeScript module loading timed out for ${filePath}: ${error.message}`);
-        }
-        throw error;
-    }
-}