@inkeep/agents-cli 0.1.0

package/dist/commands/init.js

@@ -0,0 +1,171 @@
+import { existsSync, readdirSync, writeFileSync } from 'node:fs';
+import { basename, dirname, join, resolve } from 'node:path';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+/**
+ * Find the most appropriate directory for the config file by looking for
+ * common project root indicators
+ */
+function findProjectRoot(startPath) {
+    let currentPath = resolve(startPath);
+    const root = dirname(currentPath);
+    // Look for common project root indicators
+    const rootIndicators = [
+        'package.json',
+        '.git',
+        '.gitignore',
+        'tsconfig.json',
+        'package-lock.json',
+        'yarn.lock',
+        'pnpm-lock.yaml',
+    ];
+    while (currentPath !== root) {
+        const files = readdirSync(currentPath);
+        // Check if any root indicators exist at this level
+        if (rootIndicators.some((indicator) => files.includes(indicator))) {
+            return currentPath;
+        }
+        const parentPath = dirname(currentPath);
+        if (parentPath === currentPath) {
+            break; // Reached filesystem root
+        }
+        currentPath = parentPath;
+    }
+    // If no project root found, use the original path
+    return startPath;
+}
+export async function initCommand(options) {
+    let configPath;
+    if (options?.path) {
+        // User specified a path
+        const resolvedPath = resolve(process.cwd(), options.path);
+        // Check if it's a directory or a file path
+        if (options.path.endsWith('.ts') || options.path.endsWith('.js')) {
+            // It's a file path
+            configPath = resolvedPath;
+        }
+        else {
+            // It's a directory path
+            configPath = join(resolvedPath, 'inkeep.config.ts');
+        }
+    }
+    else {
+        // Auto-detect project root
+        const projectRoot = findProjectRoot(process.cwd());
+        const suggestedPath = join(projectRoot, 'inkeep.config.ts');
+        if (options?.interactive === false) {
+            // Non-interactive mode: use the detected project root
+            configPath = suggestedPath;
+        }
+        else {
+            // Ask user to confirm or change the location
+            const { confirmedPath } = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'confirmedPath',
+                    message: 'Where should the config file be created?',
+                    default: suggestedPath,
+                    validate: (input) => {
+                        if (!input || input.trim() === '') {
+                            return 'Path is required';
+                        }
+                        // Check if the directory exists
+                        const dir = input.endsWith('.ts') || input.endsWith('.js') ? dirname(input) : input;
+                        const resolvedDir = resolve(process.cwd(), dir);
+                        if (!existsSync(resolvedDir)) {
+                            return `Directory does not exist: ${resolvedDir}`;
+                        }
+                        return true;
+                    },
+                },
+            ]);
+            const resolvedPath = resolve(process.cwd(), confirmedPath);
+            configPath =
+                confirmedPath.endsWith('.ts') || confirmedPath.endsWith('.js')
+                    ? resolvedPath
+                    : join(resolvedPath, 'inkeep.config.ts');
+        }
+    }
+    // Check if config file already exists
+    if (existsSync(configPath)) {
+        const { overwrite } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'overwrite',
+                message: `${basename(configPath)} already exists at this location. Do you want to overwrite it?`,
+                default: false,
+            },
+        ]);
+        if (!overwrite) {
+            console.log(chalk.yellow('Init cancelled.'));
+            return;
+        }
+    }
+    // Prompt for configuration values
+    const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'tenantId',
+            message: 'Enter your tenant ID:',
+            validate: (input) => {
+                if (!input || input.trim() === '') {
+                    return 'Tenant ID is required';
+                }
+                return true;
+            },
+        },
+        {
+            type: 'input',
+            name: 'projectId',
+            message: 'Enter your project ID:',
+            default: 'default',
+            validate: (input) => {
+                if (!input || input.trim() === '') {
+                    return 'Project ID is required';
+                }
+                return true;
+            },
+        },
+        {
+            type: 'input',
+            name: 'apiUrl',
+            message: 'Enter the API URL:',
+            default: 'http://localhost:3002',
+            validate: (input) => {
+                try {
+                    new URL(input);
+                    return true;
+                }
+                catch {
+                    return 'Please enter a valid URL';
+                }
+            },
+        },
+    ]);
+    // Generate the config file content
+    const configContent = `import { defineConfig } from '@inkeep/agents-cli';
+
+export default defineConfig({
+  tenantId: '${answers.tenantId}',
+  projectId: '${answers.projectId}',
+  apiUrl: '${answers.apiUrl}',
+});
+`;
+    // Write the config file
+    try {
+        writeFileSync(configPath, configContent);
+        console.log(chalk.green('✓'), `Created ${chalk.cyan(configPath)}`);
+        console.log(chalk.gray('\nYou can now use the Inkeep CLI commands.'));
+        console.log(chalk.gray('For example: inkeep list-graphs'));
+        // If the config is not in the current directory, provide a hint
+        const configDir = dirname(configPath);
+        if (configDir !== process.cwd()) {
+            console.log(chalk.gray(`\nNote: Config file created in ${configDir}`));
+            console.log(chalk.gray(`Use --config ${configPath} with commands, or run commands from that directory.`));
+        }
+    }
+    catch (error) {
+        console.error(chalk.red('Failed to create config file:'), error);
+        process.exit(1);
+    }
+}

package/dist/commands/list-graphs.d.ts

@@ -0,0 +1,6 @@
+export interface ListGraphsOptions {
+    tenantId?: string;
+    managementApiUrl?: string;
+    configFilePath?: string;
+}
+export declare function listGraphsCommand(options: ListGraphsOptions): Promise<void>;

package/dist/commands/list-graphs.js

@@ -0,0 +1,131 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { dirname, extname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import ora from 'ora';
+import { ManagementApiClient } from '../api.js';
+import { validateConfiguration } from '../config.js';
+export async function listGraphsCommand(options) {
+    // Check if we need to re-run with tsx for TypeScript config files
+    if (!process.env.TSX_RUNNING) {
+        // Helper function to find config file
+        function findConfigFile(startPath = process.cwd()) {
+            let currentPath = resolve(startPath);
+            const root = '/';
+            const configNames = ['inkeep.config.ts', 'inkeep.config.js', '.inkeeprc.ts', '.inkeeprc.js'];
+            while (currentPath !== root) {
+                // Check for config files at this level
+                for (const configName of configNames) {
+                    const configPath = resolve(currentPath, configName);
+                    if (existsSync(configPath)) {
+                        return configPath;
+                    }
+                }
+                const parentPath = dirname(currentPath);
+                if (parentPath === currentPath) {
+                    break; // Reached filesystem root
+                }
+                currentPath = parentPath;
+            }
+            return null;
+        }
+        // Determine if we have a TypeScript config that needs tsx
+        let configPath = null;
+        if (options?.configFilePath) {
+            // User specified a config path
+            configPath = resolve(process.cwd(), options.configFilePath);
+            if (!existsSync(configPath)) {
+                // Config file doesn't exist, let the normal flow handle the error
+                configPath = null;
+            }
+        }
+        else {
+            // Search for config file
+            configPath = findConfigFile();
+        }
+        // If we found a TypeScript config file, re-run with tsx
+        if (configPath && extname(configPath) === '.ts') {
+            // Re-run this command with tsx
+            const __filename = fileURLToPath(import.meta.url);
+            const __dirname = dirname(__filename);
+            const cliPath = resolve(__dirname, '../index.js');
+            const args = [cliPath, 'list-graphs'];
+            if (options?.tenantId)
+                args.push('--tenant-id', options.tenantId);
+            if (options?.managementApiUrl)
+                args.push('--management-api-url', options.managementApiUrl);
+            if (options?.configFilePath)
+                args.push('--config-file-path', options.configFilePath);
+            const child = spawn('npx', ['tsx', ...args], {
+                cwd: process.cwd(),
+                stdio: 'inherit',
+                env: { ...process.env, TSX_RUNNING: '1' },
+            });
+            child.on('error', (error) => {
+                console.error(chalk.red('Failed to load TypeScript configuration:'), error.message);
+                process.exit(1);
+            });
+            child.on('exit', (code) => {
+                process.exit(code || 0);
+            });
+            return;
+        }
+    }
+    // Validate configuration
+    let config;
+    try {
+        config = await validateConfiguration(options.tenantId, options.managementApiUrl, undefined, // executionApiUrl not needed for list-graphs
+        options.configFilePath);
+    }
+    catch (error) {
+        console.error(chalk.red(error.message));
+        process.exit(1);
+    }
+    // Log configuration sources for debugging
+    console.log(chalk.gray('Using configuration:'));
+    console.log(chalk.gray(`  • Tenant ID: ${config.sources.tenantId}`));
+    console.log(chalk.gray(`  • API URL: ${config.sources.managementApiUrl}`));
+    console.log();
+    const api = await ManagementApiClient.create(config.managementApiUrl, options.configFilePath, config.tenantId);
+    const spinner = ora('Fetching graphs...').start();
+    try {
+        const graphs = await api.listGraphs();
+        spinner.succeed(`Found ${graphs.length} graph(s)`);
+        if (graphs.length === 0) {
+            console.log(chalk.gray('No graphs found. Push a graph with: inkeep push <graph-path>'));
+            return;
+        }
+        // Create a table to display graphs
+        const table = new Table({
+            head: [
+                chalk.cyan('Graph ID'),
+                chalk.cyan('Name'),
+                chalk.cyan('Default Agent'),
+                chalk.cyan('Created'),
+            ],
+            style: {
+                head: [],
+                border: [],
+            },
+        });
+        for (const graph of graphs) {
+            const createdDate = graph.createdAt
+                ? new Date(graph.createdAt).toLocaleDateString()
+                : 'Unknown';
+            table.push([
+                graph.id || '',
+                graph.name || graph.id || '',
+                graph.defaultAgentId || chalk.gray('None'),
+                createdDate,
+            ]);
+        }
+        console.log('\n' + table.toString());
+    }
+    catch (error) {
+        spinner.fail('Failed to fetch graphs');
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}

package/dist/commands/mcp-list.d.ts

@@ -0,0 +1,4 @@
+export declare function mcpListCommand(options?: {
+    verbose?: boolean;
+    format?: 'table' | 'tree';
+}): Promise<void>;

package/dist/commands/mcp-list.js

@@ -0,0 +1,156 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import chalk from 'chalk';
+import Table from 'cli-table3';
+const MCP_DIR = join(homedir(), '.inkeep', 'mcp');
+const REGISTRY_FILE = join(MCP_DIR, 'servers.json');
+function loadRegistry() {
+    if (!existsSync(REGISTRY_FILE)) {
+        return { servers: [] };
+    }
+    try {
+        return JSON.parse(readFileSync(REGISTRY_FILE, 'utf-8'));
+    }
+    catch {
+        return { servers: [] };
+    }
+}
+function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function formatUptime(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (days > 0)
+        return `${days}d ${hours % 24}h`;
+    if (hours > 0)
+        return `${hours}h ${minutes % 60}m`;
+    if (minutes > 0)
+        return `${minutes}m`;
+    return `${seconds}s`;
+}
+function getStatusIcon(isRunning, deployment) {
+    if (deployment === 'remote') {
+        return '🔵'; // Remote servers are always "connected"
+    }
+    return isRunning ? '🟢' : '🔴';
+}
+function getDeploymentIcon(deployment) {
+    return deployment === 'local' ? '🏠' : '☁️';
+}
+export async function mcpListCommand(options) {
+    const registry = loadRegistry();
+    if (registry.servers.length === 0) {
+        console.log(chalk.gray('No MCP servers registered'));
+        console.log(chalk.gray('\nStart servers with: inkeep mcp start <graph-file>'));
+        return;
+    }
+    // Group servers by graph
+    const serversByGraph = new Map();
+    for (const server of registry.servers) {
+        const servers = serversByGraph.get(server.graphId) || [];
+        servers.push(server);
+        serversByGraph.set(server.graphId, servers);
+    }
+    if (options?.format === 'tree' || !options?.format) {
+        // Tree format (default)
+        console.log(chalk.bold('\n📡 MCP Servers Overview'));
+        console.log(chalk.gray('━'.repeat(70)) + '\n');
+        let totalRunning = 0;
+        let totalStopped = 0;
+        let totalRemote = 0;
+        for (const [graphId, servers] of serversByGraph) {
+            console.log(chalk.bold.cyan(`Graph: ${graphId}`));
+            for (const server of servers) {
+                const isRunning = server.deployment === 'local' ? isProcessRunning(server.pid) : true;
+                const uptime = isRunning
+                    ? formatUptime(new Date().getTime() - new Date(server.startedAt).getTime())
+                    : 'stopped';
+                if (server.deployment === 'remote') {
+                    totalRemote++;
+                }
+                else if (isRunning) {
+                    totalRunning++;
+                }
+                else {
+                    totalStopped++;
+                }
+                const statusIcon = getStatusIcon(isRunning, server.deployment);
+                const deploymentIcon = getDeploymentIcon(server.deployment);
+                let line = `├─ ${statusIcon} ${chalk.white(server.name.padEnd(16))} | ${deploymentIcon} ${server.deployment.padEnd(6)} | `;
+                if (server.deployment === 'local') {
+                    line += chalk.cyan(`:${server.port}`.padEnd(6));
+                }
+                else {
+                    line += chalk.blue(server.serverUrl?.substring(0, 25) + '...');
+                }
+                line += ` | ${server.transport?.toUpperCase().padEnd(4) || 'IPC '.padEnd(4)}`;
+                line += ` | ${isRunning ? chalk.green(uptime.padEnd(8)) : chalk.red('Stopped '.padEnd(8))}`;
+                console.log(line);
+                if (options?.verbose && server.description) {
+                    console.log(chalk.gray(`│  └─ ${server.description}`));
+                }
+            }
+            console.log();
+        }
+        // Summary
+        console.log(chalk.gray('Summary: ') +
+            chalk.green(`${totalRunning} running`) +
+            ', ' +
+            chalk.red(`${totalStopped} stopped`) +
+            ', ' +
+            chalk.blue(`${totalRemote} remote`));
+    }
+    else if (options.format === 'table') {
+        // Table format
+        const table = new Table({
+            head: [
+                chalk.cyan('Status'),
+                chalk.cyan('Name'),
+                chalk.cyan('Graph'),
+                chalk.cyan('Type'),
+                chalk.cyan('Location'),
+                chalk.cyan('Transport'),
+                chalk.cyan('Uptime'),
+            ],
+            style: {
+                head: [],
+                border: ['gray'],
+            },
+        });
+        for (const server of registry.servers) {
+            const isRunning = server.deployment === 'local' ? isProcessRunning(server.pid) : true;
+            const uptime = isRunning
+                ? formatUptime(new Date().getTime() - new Date(server.startedAt).getTime())
+                : 'N/A';
+            const statusIcon = getStatusIcon(isRunning, server.deployment);
+            const location = server.deployment === 'local'
+                ? chalk.cyan(`:${server.port}`)
+                : chalk.blue(server.serverUrl?.substring(0, 30) || 'N/A');
+            table.push([
+                statusIcon,
+                server.name,
+                server.graphId,
+                server.deployment,
+                location,
+                server.transport?.toUpperCase() || 'IPC',
+                isRunning ? chalk.green(uptime) : chalk.red('Stopped'),
+            ]);
+        }
+        console.log(chalk.bold('\n📡 MCP Servers\n'));
+        console.log(table.toString());
+    }
+    console.log(chalk.gray('\nCommands:'));
+    console.log(chalk.gray('  • Start servers:  inkeep mcp start <graph-file>'));
+    console.log(chalk.gray('  • Stop servers:   inkeep mcp stop'));
+    console.log(chalk.gray('  • Server status:  inkeep mcp status'));
+}

package/dist/commands/mcp-start-simple.d.ts

@@ -0,0 +1,5 @@
+export interface McpStartOptions {
+    detached?: boolean;
+    verbose?: boolean;
+}
+export declare function mcpStartCommand(graphPath: string, options: McpStartOptions): Promise<void>;

package/dist/commands/mcp-start-simple.js

@@ -0,0 +1,193 @@
+import { execSync, spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import chalk from 'chalk';
+import ora from 'ora';
+export async function mcpStartCommand(graphPath, options) {
+    let spinner = ora('Loading graph configuration...').start();
+    try {
+        // Resolve the graph path
+        const fullPath = resolve(graphPath);
+        if (!existsSync(fullPath)) {
+            spinner.fail(`Graph file not found: ${graphPath}`);
+            process.exit(1);
+        }
+        spinner.text = 'Starting MCP servers...';
+        // Get the directory of the graph file for proper module resolution
+        const graphDir = dirname(fullPath);
+        // Check if it's a TypeScript file
+        if (fullPath.endsWith('.ts')) {
+            spinner.text = 'Checking TypeScript runtime...';
+            // Check if tsx is available in the graph directory
+            try {
+                execSync('npx tsx --version', {
+                    stdio: 'pipe',
+                    cwd: graphDir,
+                });
+            }
+            catch {
+                spinner.fail('TypeScript runtime not found');
+                console.log(chalk.yellow('\nTo use TypeScript graph files:'));
+                console.log(chalk.gray('  Option 1: Compile your graph first'));
+                console.log(chalk.gray('    cd inkeep-chat && pnpm build'));
+                console.log(chalk.gray('    inkeep mcp start inkeep-chat/dist/examples/graph.graph.js'));
+                console.log(chalk.gray('\n  Option 2: Ensure tsx is installed in the graph directory'));
+                console.log(chalk.gray('    cd inkeep-chat && pnpm add -D tsx'));
+                process.exit(1);
+            }
+        }
+        // Convert to file URL for import
+        const fileUrl = pathToFileURL(fullPath).href;
+        // Spawn tsx process to run the runner with the graph file
+        const child = spawn('npx', [
+            'tsx',
+            '--eval',
+            `
+            import('${fileUrl}').then(async module => {
+                const servers = module.servers || module.tools || [];
+                const graph = module.graph;
+                
+                let graphId = 'unknown';
+                if (graph && typeof graph.getId === 'function') {
+                    graphId = graph.getId();
+                }
+                
+                const startedServers = [];
+                let nextPort = 3100;
+                
+                for (const server of servers) {
+                    if (!server) continue;
+                    
+                    // Try to get name using getName() method or direct property access
+                    let name = 'unnamed';
+                    if (typeof server.getName === 'function') {
+                        name = server.getName();
+                    } else if (server.config && server.config.name) {
+                        name = server.config.name;
+                    } else if (server.name) {
+                        name = server.name;
+                    }
+                    
+                    // Try to get server URL
+                    let serverUrl = undefined;
+                    if (typeof server.getServerUrl === 'function') {
+                        serverUrl = server.getServerUrl();
+                    } else if (server.config && server.config.serverUrl) {
+                        serverUrl = server.config.serverUrl;
+                    } else if (server.serverUrl) {
+                        serverUrl = server.serverUrl;
+                    }
+                    
+                    const isLocal = !serverUrl;
+                    const port = isLocal ? (server.port || server.config?.port || nextPort++) : undefined;
+                    
+                    console.log(JSON.stringify({
+                        type: 'server_started',
+                        name,
+                        port,
+                        serverUrl,
+                        deployment: isLocal ? 'local' : 'remote'
+                    }));
+                    
+                    startedServers.push(name);
+                }
+                
+                console.log(JSON.stringify({
+                    type: 'all_started',
+                    count: startedServers.length,
+                    graphId
+                }));
+                
+                if (!${options.detached || false}) {
+                    // Keep process alive
+                    process.stdin.resume();
+                    
+                    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);
+            });
+        `,
+        ], {
+            stdio: ['inherit', 'pipe', 'pipe'],
+            cwd: graphDir, // Set working directory to graph file's directory
+            env: {
+                ...process.env,
+                ENVIRONMENT: process.env.ENVIRONMENT || 'test',
+                DB_FILE_NAME: process.env.DB_FILE_NAME || ':memory:',
+                INKEEP_TENANT_ID: process.env.INKEEP_TENANT_ID || 'test-tenant',
+                ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY || 'test-key',
+            },
+        });
+        let serverCount = 0;
+        let graphId = 'unknown';
+        // Handle stdout
+        child.stdout?.on('data', (data) => {
+            const lines = data.toString().split('\n').filter(Boolean);
+            for (const line of lines) {
+                try {
+                    const msg = JSON.parse(line);
+                    if (msg.type === 'server_started') {
+                        const icon = msg.deployment === 'local' ? '🏠' : '☁️';
+                        const location = msg.deployment === 'local'
+                            ? `on port ${chalk.cyan(msg.port)}`
+                            : `at ${chalk.cyan(msg.serverUrl)}`;
+                        spinner.succeed(`${icon} Started ${chalk.green(msg.name)} ${location}`);
+                        spinner = ora().start(); // Create new spinner for next server
+                        serverCount++;
+                    }
+                    else if (msg.type === 'all_started') {
+                        spinner.stop();
+                        console.log(chalk.green(`\n✅ Started ${msg.count} MCP server(s)`));
+                        graphId = msg.graphId || 'unknown';
+                        if (!options.detached) {
+                            console.log(chalk.gray('\nServers are running. Press Ctrl+C to stop all servers.\n'));
+                        }
+                    }
+                    else if (msg.type === 'shutting_down') {
+                        console.log(chalk.yellow('\n\nShutting down MCP servers...'));
+                    }
+                    else if (msg.type === 'error') {
+                        spinner.fail(`Error: ${msg.message}`);
+                    }
+                }
+                catch {
+                    // Not JSON, just print it
+                    if (options.verbose) {
+                        console.log(chalk.gray(line));
+                    }
+                }
+            }
+        });
+        // Handle stderr
+        child.stderr?.on('data', (data) => {
+            if (options.verbose) {
+                console.error(chalk.red(data.toString()));
+            }
+        });
+        // Handle exit
+        child.on('exit', (code) => {
+            if (code !== 0 && code !== null) {
+                spinner.fail('Failed to start MCP servers');
+                process.exit(code);
+            }
+        });
+        // Forward SIGINT to child
+        process.on('SIGINT', () => {
+            child.kill('SIGINT');
+        });
+    }
+    catch (error) {
+        spinner.fail('Failed to start MCP servers');
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}

package/dist/commands/mcp-start.d.ts

@@ -0,0 +1,5 @@
+export interface McpStartOptions {
+    detached?: boolean;
+    verbose?: boolean;
+}
+export declare function mcpStartCommand(graphPath: string, options: McpStartOptions): Promise<void>;