@inkeep/agents-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Command } from 'commander';
+import { configGetCommand, configListCommand, configSetCommand } from './commands/config.js';
+import { initCommand } from './commands/init.js';
+import { listGraphsCommand } from './commands/list-graphs.js';
+import { pullCommand } from './commands/pull.js';
+import { pushCommand } from './commands/push.js';
+// Get the current directory for ESM
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Read package.json to get version
+const packageJsonPath = join(__dirname, '..', 'package.json');
+const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+const program = new Command();
+program
+    .name('inkeep')
+    .description('CLI tool for Inkeep Agent Framework')
+    .version(packageJson.version);
+// Init command
+program
+    .command('init [path]')
+    .description('Initialize a new Inkeep configuration file')
+    .option('--no-interactive', 'Skip interactive path selection')
+    .action(async (path, options) => {
+    await initCommand({ path, ...options });
+});
+// Config command with subcommands
+const configCommand = program.command('config').description('Manage Inkeep configuration');
+configCommand
+    .command('get [key]')
+    .description('Get configuration value(s)')
+    .option('--config-file-path <path>', 'Path to configuration file')
+    .action(async (key, options) => {
+    await configGetCommand(key, options);
+});
+configCommand
+    .command('set <key> <value>')
+    .description('Set a configuration value')
+    .option('--config-file-path <path>', 'Path to configuration file')
+    .action(async (key, value, options) => {
+    await configSetCommand(key, value, options);
+});
+configCommand
+    .command('list')
+    .description('List all configuration values')
+    .option('--config-file-path <path>', 'Path to configuration file')
+    .action(async (options) => {
+    await configListCommand(options);
+});
+// Push command
+program
+    .command('push <graph-path>')
+    .description('Push a graph configuration to the backend')
+    .option('--tenant-id <tenant-id>', 'Tenant ID (use with --api-url)')
+    .option('--api-url <api-url>', 'API URL (use with --tenant-id or alone to override config)')
+    .option('--config-file-path <path>', 'Path to configuration file (alternative to --tenant-id/--api-url)')
+    .action(async (graphPath, options) => {
+    await pushCommand(graphPath, options);
+});
+// Pull command
+program
+    .command('pull <graph-id>')
+    .description('Pull a graph configuration from the backend and generate TypeScript file')
+    .option('--tenant-id <tenant-id>', 'Tenant ID (use with --api-url)')
+    .option('--api-url <api-url>', 'API URL (use with --tenant-id or alone to override config)')
+    .option('--config-file-path <path>', 'Path to configuration file (alternative to --tenant-id/--api-url)')
+    .option('--output-path <path>', 'Output directory for the generated file (overrides config)')
+    .option('--json', 'Output as JSON file instead of TypeScript')
+    .action(async (graphId, options) => {
+    await pullCommand(graphId, options);
+});
+// Chat command
+program
+    .command('chat [graph-id]')
+    .description('Start an interactive chat session with a graph (interactive selection if no ID provided)')
+    .option('--tenant-id <tenant-id>', 'Tenant ID (use with --api-url)')
+    .option('--api-url <api-url>', 'API URL (use with --tenant-id or alone to override config)')
+    .option('--config-file-path <path>', 'Path to configuration file (alternative to --tenant-id/--api-url)')
+    .action(async (graphId, options) => {
+    // Import the enhanced version with autocomplete
+    const { chatCommandEnhanced } = await import('./commands/chat-enhanced.js');
+    await chatCommandEnhanced(graphId, options);
+});
+// List graphs command
+program
+    .command('list-graphs')
+    .description('List all available graphs for the current tenant')
+    .option('--tenant-id <tenant-id>', 'Tenant ID (use with --api-url)')
+    .option('--api-url <api-url>', 'API URL (use with --tenant-id or alone to override config)')
+    .option('--config-file-path <path>', 'Path to configuration file (alternative to --tenant-id/--api-url)')
+    .action(async (options) => {
+    await listGraphsCommand(options);
+});
+// Parse command line arguments
+program.parse();

package/dist/types/config.d.ts

@@ -0,0 +1,9 @@
+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

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

package/dist/types/graph.d.ts

@@ -0,0 +1,10 @@
+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

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

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

@@ -0,0 +1,60 @@
+/**
+ * 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

@@ -0,0 +1,222 @@
+/**
+ * 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

@@ -0,0 +1,6 @@
+#!/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

@@ -0,0 +1,147 @@
+#!/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/port-manager.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Manages dynamic port allocation for local MCP servers
+ */
+export declare class PortManager {
+    private static instance;
+    private static readonly BASE_PORT;
+    private static readonly MAX_PORT;
+    private allocatedPorts;
+    private constructor();
+    static getInstance(): PortManager;
+    /**
+     * Allocate an available port in the configured range
+     */
+    allocatePort(preferredPort?: number): Promise<number>;
+    /**
+     * Release a previously allocated port
+     */
+    releasePort(port: number): void;
+    /**
+     * Release all allocated ports
+     */
+    releaseAll(): void;
+    /**
+     * Check if a specific port is available
+     */
+    private isPortAvailable;
+    /**
+     * Get list of currently allocated ports
+     */
+    getAllocatedPorts(): number[];
+    /**
+     * Get port allocation statistics
+     */
+    getStats(): {
+        allocated: number;
+        available: number;
+        range: {
+            min: number;
+            max: number;
+        };
+        ports: number[];
+    };
+}