@inkeep/agents-cli 0.1.5 → 0.1.6

package/dist/commands/pull.js

@@ -1,305 +0,0 @@
-import { spawn } from 'node:child_process';
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
-import { dirname, extname, join, resolve } from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-import chalk from 'chalk';
-import ora from 'ora';
-import { validateConfiguration } from '../config.js';
-import { compareJsonObjects, getDifferenceSummary } from '../utils/json-comparator.js';
-import { generateTypeScriptFileWithLLM } from './pull.llm-generate.js';
-/**
- * Convert a TypeScript graph file to its JSON representation
- * Uses the exact same approach as the push command
- */
-export async function convertTypeScriptToJson(graphPath) {
-    // Resolve the absolute path
-    const absolutePath = resolve(process.cwd(), graphPath);
-    // Check if file exists
-    if (!existsSync(absolutePath)) {
-        throw new Error(`File not found: ${absolutePath}`);
-    }
-    // Check if this is a TypeScript file
-    const ext = extname(absolutePath);
-    if (ext === '.ts') {
-        // For TypeScript files, we need to use tsx to run this entire command
-        // Check if we're already running under tsx
-        if (!process.env.TSX_RUNNING) {
-            // Re-run this function with tsx - just like push does
-            const __filename = fileURLToPath(import.meta.url);
-            const __dirname = dirname(__filename);
-            const pullPath = resolve(__dirname, '../commands/pull.js');
-            return new Promise((resolve, reject) => {
-                const child = spawn('npx', ['tsx', pullPath, 'convert', graphPath], {
-                    cwd: process.cwd(),
-                    stdio: ['pipe', 'pipe', 'pipe'],
-                    env: {
-                        ...process.env,
-                        TSX_RUNNING: '1',
-                    },
-                });
-                let stdout = '';
-                let stderr = '';
-                child.stdout.on('data', (data) => {
-                    stdout += data.toString();
-                });
-                child.stderr.on('data', (data) => {
-                    stderr += data.toString();
-                });
-                child.on('error', (error) => {
-                    reject(new Error(`Failed to load TypeScript file: ${error.message}`));
-                });
-                child.on('exit', (code) => {
-                    if (code === 0) {
-                        try {
-                            // Look for JSON markers in stdout
-                            const jsonStartMarker = '===JSON_START===';
-                            const jsonEndMarker = '===JSON_END===';
-                            const startIndex = stdout.indexOf(jsonStartMarker);
-                            const endIndex = stdout.indexOf(jsonEndMarker);
-                            if (startIndex === -1 || endIndex === -1) {
-                                reject(new Error('JSON markers not found in output'));
-                                return;
-                            }
-                            const jsonString = stdout
-                                .substring(startIndex + jsonStartMarker.length, endIndex)
-                                .trim();
-                            const result = JSON.parse(jsonString);
-                            resolve(result);
-                        }
-                        catch (error) {
-                            reject(new Error(`Failed to parse conversion result: ${error}`));
-                        }
-                    }
-                    else {
-                        reject(new Error(`Conversion failed: ${stderr}`));
-                    }
-                });
-            });
-        }
-    }
-    // Now we can import the module (either JS directly, or TS via tsx)
-    const fileUrl = pathToFileURL(absolutePath).href;
-    const module = await import(fileUrl);
-    // Validate that exactly one graph is exported
-    const exports = Object.keys(module);
-    const graphExports = exports.filter((key) => {
-        const value = module[key];
-        // Check for AgentGraph-like objects (has required methods)
-        return (value &&
-            typeof value === 'object' &&
-            typeof value.init === 'function' &&
-            typeof value.getId === 'function' &&
-            typeof value.getName === 'function' &&
-            typeof value.getAgents === 'function');
-    });
-    if (graphExports.length === 0) {
-        throw new Error('No AgentGraph exported from configuration file');
-    }
-    if (graphExports.length > 1) {
-        throw new Error(`Multiple AgentGraphs exported from configuration file. Found: ${graphExports.join(', ')}`);
-    }
-    // Get the graph instance
-    const graphKey = graphExports[0];
-    const graph = module[graphKey];
-    // Get the full graph definition using the same method as push
-    return await graph.toFullGraphDefinition();
-}
-/**
- * CLI entry point for the converter (used when running with tsx)
- */
-async function cliConvert(graphPath) {
-    try {
-        // Suppress ALL console output except our JSON
-        const originalConsoleLog = console.log;
-        const originalConsoleError = console.error;
-        const originalConsoleWarn = console.warn;
-        const originalConsoleInfo = console.info;
-        // Suppress all console output
-        console.log = () => { };
-        console.error = () => { };
-        console.warn = () => { };
-        console.info = () => { };
-        const result = await convertTypeScriptToJson(graphPath);
-        // Restore console functions
-        console.log = originalConsoleLog;
-        console.error = originalConsoleError;
-        console.warn = originalConsoleWarn;
-        console.info = originalConsoleInfo;
-        // Output a clear marker before JSON so parent process knows where to start parsing
-        console.log('===JSON_START===');
-        console.log(JSON.stringify(result, null, 2));
-        console.log('===JSON_END===');
-    }
-    catch (error) {
-        console.error('Error:', error.message);
-        process.exit(1);
-    }
-}
-export async function pullCommand(graphId, options) {
-    const spinner = ora('Loading configuration...').start();
-    try {
-        // Validate configuration
-        let config;
-        try {
-            config = await validateConfiguration(options.tenantId, options.apiUrl, options.configFilePath);
-        }
-        catch (error) {
-            spinner.fail('Configuration validation failed');
-            console.error(chalk.red(error.message));
-            process.exit(1);
-        }
-        // Get output directory from options or config
-        const outputDirectory = options.outputPath || config.outputDirectory || './agent-configurations';
-        // Create output directory if it doesn't exist
-        const absoluteOutputPath = resolve(process.cwd(), outputDirectory);
-        if (!existsSync(absoluteOutputPath)) {
-            mkdirSync(absoluteOutputPath, { recursive: true });
-        }
-        spinner.text = 'Fetching graph from API...';
-        // Fetch graph from API
-        const response = await fetch(`${config.managementApiUrl}/tenants/${config.tenantId}/crud/projects/${config.projectId}/graph/${graphId}`, {
-            method: 'GET',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-        });
-        if (!response.ok) {
-            if (response.status === 404) {
-                spinner.fail(`Graph with ID "${graphId}" not found`);
-                process.exit(1);
-            }
-            spinner.fail(`Failed to fetch graph: ${response.statusText}`);
-            process.exit(1);
-        }
-        const responseData = await response.json();
-        const graphData = responseData.data;
-        if (options.json) {
-            // Output JSON file
-            spinner.text = 'Writing JSON file...';
-            const jsonFilePath = join(absoluteOutputPath, `${graphId}.json`);
-            writeFileSync(jsonFilePath, JSON.stringify(graphData, null, 2), 'utf-8');
-            spinner.succeed(`Graph "${graphData.name}" pulled successfully`);
-            console.log(chalk.green(`✅ JSON file created: ${jsonFilePath}`));
-            // Display next steps for JSON
-            console.log(chalk.cyan('\n✨ Next steps:'));
-            console.log(chalk.gray(`  • View the file: ${jsonFilePath}`));
-            console.log(chalk.gray(`  • Use the data in your application`));
-        }
-        else {
-            // Generate TypeScript file using LLM
-            spinner.text = 'Generating TypeScript file with LLM...';
-            const outputFilePath = join(absoluteOutputPath, `${graphId}.graph.ts`);
-            if (!config.modelSettings) {
-                spinner.fail('Model Settings is required for TypeScript generation');
-                console.error(chalk.red('Error: No modelSettings found in configuration.'));
-                console.error(chalk.yellow('Please add modelSettings to your inkeep.config.ts file.'));
-                console.error(chalk.gray('Example:'));
-                console.error(chalk.gray('  modelSettings: {'));
-                console.error(chalk.gray('    model: "anthropic/claude-3-5-sonnet-20241022",'));
-                console.error(chalk.gray('    providerOptions: { anthropic: {} }'));
-                console.error(chalk.gray('  }'));
-                process.exit(1);
-            }
-            // Generate TypeScript file with validation and retry logic
-            const maxRetries = options.maxRetries || 3;
-            let attempt = 1;
-            let validationPassed = false;
-            let previousDifferences = [];
-            while (attempt <= maxRetries && !validationPassed) {
-                if (attempt > 1) {
-                    spinner.text = `Regenerating TypeScript file (attempt ${attempt}/${maxRetries})...`;
-                }
-                else {
-                    spinner.text = 'Generating TypeScript file with LLM...';
-                }
-                await generateTypeScriptFileWithLLM(graphData, graphId, outputFilePath, config.modelSettings, {
-                    attempt,
-                    maxRetries,
-                    previousDifferences: attempt > 1 ? previousDifferences : undefined,
-                });
-                // Always validate the generated TypeScript file
-                spinner.text = 'Validating generated TypeScript file...';
-                try {
-                    // Convert the generated TypeScript back to JSON
-                    const convertedResult = await convertTypeScriptToJson(outputFilePath);
-                    // Compare with the original graph data
-                    const comparison = compareJsonObjects(graphData, convertedResult, {
-                        ignoreArrayOrder: true,
-                        ignoreCase: false,
-                        ignoreWhitespace: false,
-                        showDetails: true,
-                    });
-                    if (comparison.isEqual) {
-                        validationPassed = true;
-                        spinner.succeed('TypeScript file validation passed');
-                        console.log(chalk.green('✅ Generated TypeScript file matches original graph data'));
-                    }
-                    else {
-                        // Collect differences for next retry
-                        previousDifferences = comparison.differences.map((diff) => `${diff.path}: ${diff.description}`);
-                        if (attempt < maxRetries) {
-                            spinner.warn(`Validation failed (attempt ${attempt}/${maxRetries}), retrying...`);
-                            console.log(chalk.yellow('⚠️  Generated TypeScript file has differences from original graph data:'));
-                            console.log(chalk.gray(getDifferenceSummary(comparison)));
-                            console.log(chalk.gray('\n🔄 Retrying with improved prompt...'));
-                        }
-                        else {
-                            // Final attempt failed
-                            spinner.fail('TypeScript file validation failed after all retries');
-                            console.log(chalk.red('❌ Generated TypeScript file has differences from original:'));
-                            console.log(chalk.gray(getDifferenceSummary(comparison)));
-                            console.log(chalk.yellow('\n💡 You may need to manually edit the generated file or check the LLM configuration.'));
-                        }
-                    }
-                }
-                catch (validationError) {
-                    // Collect validation error for next retry
-                    previousDifferences = [`Validation error: ${validationError.message}`];
-                    if (attempt < maxRetries) {
-                        spinner.warn(`Validation failed (attempt ${attempt}/${maxRetries}), retrying...`);
-                        console.log(chalk.yellow('⚠️  Could not validate generated TypeScript file against original graph data:'));
-                        console.log(chalk.gray(validationError.message));
-                        console.log(chalk.gray('This might be due to the generated file having syntax errors or missing dependencies.'));
-                        console.log(chalk.gray('\n🔄 Retrying with improved prompt...'));
-                    }
-                    else {
-                        // Final attempt failed
-                        spinner.fail('TypeScript file validation failed after all retries');
-                        console.log(chalk.red('❌ Could not validate generated TypeScript file against original graph data:'));
-                        console.log(chalk.gray(validationError.message));
-                        console.log(chalk.gray('This might be due to the generated file having syntax errors or missing dependencies.'));
-                        console.log(chalk.yellow('\n💡 You may need to manually edit the generated file or check the LLM configuration.'));
-                    }
-                }
-                attempt++;
-            }
-            spinner.succeed(`Graph "${graphData.name}" pulled successfully`);
-            console.log(chalk.green(`✅ TypeScript file created: ${outputFilePath}`));
-            // Display next steps
-            console.log(chalk.cyan('\n✨ Next steps:'));
-            console.log(chalk.gray(`  • Edit the file: ${outputFilePath}`));
-            console.log(chalk.gray(`  • Test locally: inkeep push ${outputFilePath}`));
-            console.log(chalk.gray(`  • Version control: git add ${outputFilePath}`));
-        }
-    }
-    catch (error) {
-        spinner.fail('Failed to pull graph');
-        console.error(chalk.red('Error:'), error.message);
-        if (error.stack && process.env.DEBUG) {
-            console.error(chalk.gray(error.stack));
-        }
-        process.exit(1);
-    }
-}
-// CLI entry point for conversion
-if (import.meta.url === `file://${process.argv[1]}`) {
-    const command = process.argv[2];
-    const graphPath = process.argv[3];
-    if (command === 'convert' && graphPath) {
-        cliConvert(graphPath);
-    }
-    else {
-        console.error('Usage: tsx pull.js convert <graph-path>');
-        process.exit(1);
-    }
-}

package/dist/commands/pull.llm-generate.d.ts

@@ -1,10 +0,0 @@
-import type { ModelSettings } from '@inkeep/agents-core';
-import type { FullGraphDefinition } from '../types/graph.js';
-/**
- * Generate TypeScript code using LLM to intelligently merge graph data
- */
-export declare function generateTypeScriptFileWithLLM(graphData: FullGraphDefinition, graphId: string, outputFilePath: string, modelSettings: ModelSettings, retryContext?: {
-    attempt: number;
-    maxRetries: number;
-    previousDifferences?: string[];
-}): Promise<void>;

package/dist/commands/pull.llm-generate.js

@@ -1,184 +0,0 @@
-import { anthropic, createAnthropic } from '@ai-sdk/anthropic';
-import { createOpenAI, openai } from '@ai-sdk/openai';
-import { generateText } from 'ai';
-/**
- * Create a language model instance from configuration
- * Similar to ModelFactory but simplified for CLI use
- */
-function createModel(config) {
-    // Extract from base model settings or use defaults
-    const modelString = config.model || 'anthropic/claude-4-sonnet-20250514';
-    const providerOptions = config.providerOptions;
-    const { provider, modelName } = parseModelString(modelString);
-    switch (provider) {
-        case 'anthropic':
-            if (providerOptions) {
-                const provider = createAnthropic(providerOptions);
-                return provider(modelName);
-            }
-            return anthropic(modelName);
-        case 'openai':
-            if (providerOptions) {
-                const provider = createOpenAI(providerOptions);
-                return provider(modelName);
-            }
-            return openai(modelName);
-        default:
-            throw new Error(`Unsupported provider: ${provider}`);
-    }
-}
-/**
- * Parse model string to extract provider and model name
- */
-function parseModelString(modelString) {
-    if (modelString.includes('/')) {
-        const [provider, ...modelParts] = modelString.split('/');
-        return {
-            provider: provider.toLowerCase(),
-            modelName: modelParts.join('/'),
-        };
-    }
-    // Default to anthropic if no provider specified
-    return {
-        provider: 'anthropic',
-        modelName: modelString,
-    };
-}
-/**
- * Generate TypeScript code using LLM to intelligently merge graph data
- */
-export async function generateTypeScriptFileWithLLM(graphData, graphId, outputFilePath, modelSettings, retryContext) {
-    const fs = await import('fs');
-    // Read existing file content if it exists
-    let existingContent = '';
-    let fileExists = false;
-    try {
-        existingContent = fs.readFileSync(outputFilePath, 'utf-8');
-        fileExists = true;
-    }
-    catch {
-        // File doesn't exist, we'll create a new one
-        fileExists = false;
-    }
-    // Create the model instance
-    const model = createModel(modelSettings);
-    // Prepare the prompt
-    const prompt = createPrompt(graphData, graphId, existingContent, fileExists, retryContext);
-    try {
-        // Generate the updated code using the LLM
-        const { text } = await generateText({
-            model,
-            prompt,
-            temperature: 0.1, // Low temperature for consistent code generation
-            maxOutputTokens: 16000, // Increased to handle large TypeScript files
-        });
-        // Write the generated code to the file
-        fs.writeFileSync(outputFilePath, text, 'utf-8');
-        console.log(`✅ Successfully generated TypeScript file: ${outputFilePath}`);
-    }
-    catch (error) {
-        console.error('❌ Error generating TypeScript file with LLM:', error);
-        throw error;
-    }
-}
-/**
- * Create a comprehensive prompt for the LLM to generate/update TypeScript code
- */
-function createPrompt(graphData, graphId, existingContent, fileExists, retryContext) {
-    const graphDataJson = JSON.stringify(graphData, null, 2);
-    // Add retry context to the prompt if this is a retry
-    const retryInstructions = retryContext && retryContext.attempt > 1
-        ? `
-RETRY CONTEXT:
-This is attempt ${retryContext.attempt} of ${retryContext.maxRetries}. Previous attempts had validation issues.
-
-${retryContext.previousDifferences && retryContext.previousDifferences.length > 0
-            ? `
-PREVIOUS VALIDATION ISSUES:
-${retryContext.previousDifferences.map((diff, index) => `${index + 1}. ${diff}`).join('\n')}
-
-IMPORTANT: Pay special attention to these specific issues and ensure they are resolved in this attempt.
-`
-            : ''}
-
-CRITICAL: This is a retry attempt. You must be extremely careful to match the exact structure and values from the graph data. Double-check all IDs, names, and configurations.
-`
-        : '';
-    if (!fileExists) {
-        // Create new file
-        return `You are an expert TypeScript developer. Generate a complete TypeScript file for an Inkeep agent graph configuration.${retryInstructions}
-
-GRAPH DATA (JSON):
-${graphDataJson}
-
-GRAPH ID: ${graphId}
-
-REQUIREMENTS:
-1. Create a complete TypeScript file that exports an agentGraph configuration
-2. Use the exact structure and patterns shown in the graph data
-3. For agents, use the \`agent()\` function with proper configuration
-4. For MCP tools, use the \`mcpTool()\` function with proper configuration
-5. For context configs, use the \`contextConfig()\` function
-6. For credential references, use the \`credentialReference()\` function
-7. Use proper TypeScript syntax with correct imports
-8. Handle multi-line strings with template literals (backticks) when needed
-9. Preserve the exact structure and relationships from the graph data
-10. Use descriptive variable names based on IDs (e.g., \`qaAgent\`, \`factsTool\`)
-11. Include helpful comments for complex configurations
-12. Preserve all configuration details exactly as provided in the graph data
-
-IMPORTANT:
-- If tools array contains numeric indices, use the actual tool IDs instead
-- Preserve all configuration details exactly as provided
-- Use proper TypeScript formatting and indentation
-- Include all necessary imports at the top
-- Add comments for complex objects like GraphQL queries or multi-line instructions
-- Keep the same structure and organization as typical Inkeep graph files
-
-CRITICAL: Generate ONLY the raw TypeScript code. Do NOT wrap it in markdown code blocks (no triple backticks with typescript). Do NOT include any explanations, comments, or markdown formatting. Return only the pure TypeScript code that can be written directly to a .ts file.`;
-    }
-    else {
-        // Update existing file
-        return `You are an expert TypeScript developer. You must make MINIMAL changes to an existing TypeScript file. Your job is to update ONLY the specific values that have changed, while preserving EVERYTHING else exactly as it is.${retryInstructions}
-
-EXISTING FILE CONTENT:
-\`\`\`typescript
-${existingContent}
-\`\`\`
-
-NEW GRAPH DATA (JSON):
-${graphDataJson}
-
-GRAPH ID: ${graphId}
-
-CRITICAL RULES - FOLLOW THESE EXACTLY:
-1. PRESERVE ALL EXISTING CONTENT - Do not delete, rewrite, or restructure anything
-2. ONLY change property values that are actually different between the existing file and new graph data
-3. KEEP ALL COMMENTS - Do not remove any comments unless they are factually incorrect
-4. KEEP ALL FORMATTING - Preserve exact spacing, indentation, line breaks, and code style
-5. KEEP ALL IMPORTS - Do not change import statements
-6. KEEP ALL VARIABLE NAMES - Use the exact same variable names as in the existing file
-7. KEEP ALL STRUCTURE - Do not reorganize code blocks or change the order of definitions
-
-WHAT TO CHANGE:
-- Only update property values (like id, name, description, instructions, etc.) that are different
-- If a property value is the same, leave it exactly as it is
-- If a new agent/tool/config is added in the graph data, add it following the existing patterns
-- If an agent/tool/config is removed from the graph data, remove it from the file
-
-WHAT NOT TO CHANGE:
-- Do not rewrite entire functions or objects
-- Do not change the structure or organization
-- Do not remove or modify comments
-- Do not change formatting or style
-- Do not reorganize code blocks
-- Do not change variable names or function names
-
-EXAMPLES OF MINIMAL CHANGES:
-- If only the description changed: update only that one line
-- If only a tool was added: add only the new tool definition
-- If only a property value changed: update only that specific property
-
-CRITICAL: Return ONLY the raw TypeScript code. Do NOT wrap it in markdown code blocks (no triple backticks with typescript). Do NOT include any explanations, comments, or markdown formatting. Return only the pure TypeScript code that can be written directly to a .ts file.`;
-    }
-}

package/dist/commands/push.d.ts

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