@inkeep/agents-cli 0.1.0

package/dist/commands/push.js

@@ -0,0 +1,268 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { dirname, extname, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { createDatabaseClient, getProject, createProject } from '@inkeep/agents-core';
+import { ManagementApiClient } from '../api.js';
+import { validateConfiguration } from '../config.js';
+export async function pushCommand(graphPath, options) {
+    const spinner = ora('Loading graph configuration...').start();
+    try {
+        // Resolve the absolute path
+        const absolutePath = resolve(process.cwd(), graphPath);
+        // Check if file exists
+        if (!existsSync(absolutePath)) {
+            spinner.fail('Graph file not found');
+            console.error(chalk.red(`File not found: ${absolutePath}`));
+            process.exit(1);
+        }
+        // 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) {
+                // Stop spinner before spawning child process to avoid conflicts with interactive prompts
+                spinner.stop();
+                // Re-run this command with tsx
+                // Find the inkeep CLI executable
+                const __filename = fileURLToPath(import.meta.url);
+                const __dirname = dirname(__filename);
+                const cliPath = resolve(__dirname, '../index.js');
+                const args = [cliPath, 'push', graphPath];
+                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 file'));
+                    console.error(chalk.red('Error:'), error.message);
+                    process.exit(1);
+                });
+                child.on('exit', (code) => {
+                    process.exit(code || 0);
+                });
+                return;
+            }
+        }
+        // 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) {
+            spinner.fail('No AgentGraph exported from configuration file');
+            console.error(chalk.red('Configuration file must export at least one AgentGraph instance'));
+            process.exit(1);
+        }
+        if (graphExports.length > 1) {
+            spinner.fail('Multiple AgentGraphs exported from configuration file');
+            console.error(chalk.red('Configuration file must export exactly one AgentGraph instance'));
+            console.error(chalk.yellow('Found exports:'), graphExports.join(', '));
+            process.exit(1);
+        }
+        // Get the graph instance
+        const graphKey = graphExports[0];
+        const graph = module[graphKey];
+        spinner.text = 'Loading configuration...';
+        // Validate configuration
+        let config;
+        try {
+            config = await validateConfiguration(options.tenantId, options.managementApiUrl, undefined, // executionApiUrl not needed for push
+            options.configFilePath);
+        }
+        catch (error) {
+            spinner.fail('Configuration validation failed');
+            console.error(chalk.red(error.message));
+            process.exit(1);
+        }
+        spinner.succeed('Configuration loaded');
+        // Log configuration sources for debugging
+        console.log(chalk.gray('Configuration sources:'));
+        console.log(chalk.gray(`  • Tenant ID: ${config.sources.tenantId}`));
+        console.log(chalk.gray(`  • Project ID: ${config.sources.projectId}`));
+        console.log(chalk.gray(`  • API URL: ${config.sources.managementApiUrl}`));
+        const tenantId = config.tenantId;
+        const projectId = config.projectId;
+        const managementApiUrl = config.managementApiUrl;
+        // Check if project exists in the database
+        spinner.text = 'Validating project...';
+        // Use local.db to check if project exists
+        let dbUrl = process.env.DB_FILE_NAME || 'local.db';
+        // Convert relative path to absolute path for libsql
+        if (dbUrl !== ':memory:' &&
+            !dbUrl.startsWith('file:') &&
+            !dbUrl.startsWith('libsql:') &&
+            !dbUrl.startsWith('http')) {
+            const absolutePath = resolve(process.cwd(), dbUrl);
+            // Validate database file exists
+            if (!existsSync(absolutePath)) {
+                spinner.fail(`Database file not found: ${absolutePath}`);
+                console.error(chalk.red('Please ensure the database file exists or set DB_FILE_NAME environment variable'));
+                process.exit(1);
+            }
+            dbUrl = `file:${absolutePath}`;
+        }
+        const dbClient = createDatabaseClient({ url: dbUrl });
+        const existingProject = await getProject(dbClient)({
+            scopes: { tenantId, projectId },
+        });
+        if (!existingProject) {
+            spinner.warn(`Project "${projectId}" does not exist`);
+            spinner.stop(); // Stop spinner before prompting
+            // Ask user if they want to create the project
+            const { shouldCreate } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'shouldCreate',
+                    message: `Project "${projectId}" does not exist. Would you like to create it?`,
+                    default: true,
+                },
+            ]);
+            if (!shouldCreate) {
+                console.log(chalk.yellow('Push cancelled. Project must exist before pushing a graph.'));
+                process.exit(0);
+            }
+            // Prompt for project details
+            const { projectName, projectDescription } = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'projectName',
+                    message: 'Enter a name for the project:',
+                    default: projectId,
+                    validate: (input) => {
+                        if (!input || input.trim() === '') {
+                            return 'Project name is required';
+                        }
+                        return true;
+                    },
+                },
+                {
+                    type: 'input',
+                    name: 'projectDescription',
+                    message: 'Enter a description for the project (optional):',
+                    default: '',
+                },
+            ]);
+            // Create the project
+            spinner.start('Creating project...');
+            try {
+                await createProject(dbClient)({
+                    id: projectId,
+                    tenantId: tenantId,
+                    name: projectName,
+                    description: projectDescription || 'No description provided',
+                });
+                spinner.succeed(`Project "${projectName}" created successfully`);
+            }
+            catch (error) {
+                spinner.fail('Failed to create project');
+                console.error(chalk.red('Error:'), error.message);
+                process.exit(1);
+            }
+        }
+        else {
+            spinner.succeed(`Project "${existingProject.name || projectId}" validated`);
+        }
+        // Create API client with validated configuration (not used directly since graph handles its own API calls)
+        await ManagementApiClient.create(config.managementApiUrl, options.configFilePath, config.tenantId);
+        // Inject configuration into the graph
+        if (typeof graph.setConfig === 'function') {
+            graph.setConfig(tenantId, projectId, managementApiUrl);
+        }
+        spinner.start('Initializing graph...');
+        // Initialize the graph (this will push to the backend)
+        await graph.init();
+        // Get graph details
+        const graphId = graph.getId();
+        const graphName = graph.getName();
+        const stats = graph.getStats();
+        spinner.succeed(`Graph "${graphName}" (${graphId}) pushed successfully`);
+        // Validate for dangling resources
+        const agents = graph.getAgents();
+        const warnings = [];
+        // Check for agents not referenced in any relationships
+        for (const agent of agents) {
+            const agentName = agent.getName();
+            let isReferenced = false;
+            // Check if this agent is referenced by any other agent
+            for (const otherAgent of agents) {
+                if (otherAgent === agent)
+                    continue;
+                // Check transfers (only for internal agents)
+                if (typeof otherAgent.getTransfers === 'function') {
+                    const transfers = otherAgent.getTransfers();
+                    if (transfers.some((h) => h.getName() === agentName)) {
+                        isReferenced = true;
+                        break;
+                    }
+                }
+                // Check delegates (only for internal agents)
+                if (typeof otherAgent.getDelegates === 'function') {
+                    const delegates = otherAgent.getDelegates();
+                    if (delegates.some((d) => d.getName() === agentName)) {
+                        isReferenced = true;
+                        break;
+                    }
+                }
+            }
+            // Check if it's the default agent
+            const defaultAgent = graph.getDefaultAgent();
+            if (defaultAgent && defaultAgent.getName() === agentName) {
+                isReferenced = true;
+            }
+            if (!isReferenced && agents.length > 1) {
+                warnings.push(`Agent "${agentName}" is not referenced in any transfer or delegation relationships`);
+            }
+        }
+        // Display warnings if any
+        if (warnings.length > 0) {
+            console.log(chalk.yellow('\n⚠️  Warnings:'));
+            warnings.forEach((warning) => {
+                console.log(chalk.yellow(`  • ${warning}`));
+            });
+        }
+        // Display summary
+        console.log(chalk.cyan('\n📊 Graph Summary:'));
+        console.log(chalk.gray(`  • Graph ID: ${graphId}`));
+        console.log(chalk.gray(`  • Name: ${graphName}`));
+        console.log(chalk.gray(`  • Agents: ${stats.agentCount}`));
+        console.log(chalk.gray(`  • Tools: ${stats.toolCount}`));
+        console.log(chalk.gray(`  • Relations: ${stats.relationCount}`));
+        // Provide next steps
+        console.log(chalk.green('\n✨ Next steps:'));
+        console.log(chalk.gray(`  • Test your graph: inkeep chat ${graphId}`));
+        console.log(chalk.gray(`  • View all graphs: inkeep list-graphs`));
+        console.log(chalk.gray(`  • Get graph details: inkeep get-graph ${graphId}`));
+        // Force exit to avoid hanging due to OpenTelemetry or other background tasks
+        process.exit(0);
+    }
+    catch (error) {
+        spinner.fail('Failed to push graph');
+        console.error(chalk.red('Error:'), error.message);
+        if (error.stack && process.env.DEBUG) {
+            console.error(chalk.gray(error.stack));
+        }
+        process.exit(1);
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,43 @@
+import type { ModelSettings } from '@inkeep/agents-core';
+export interface InkeepConfig {
+    tenantId?: string;
+    projectId?: string;
+    managementApiUrl?: string;
+    executionApiUrl?: string;
+    outputDirectory?: string;
+    modelSettings?: ModelSettings;
+}
+export interface ValidatedConfiguration {
+    tenantId: string;
+    projectId: string;
+    managementApiUrl: string;
+    executionApiUrl: string;
+    outputDirectory?: string;
+    modelSettings?: ModelSettings;
+    sources: {
+        tenantId: string;
+        projectId: string;
+        managementApiUrl: string;
+        executionApiUrl: string;
+        configFile?: string;
+    };
+}
+export declare function loadConfig(configPath?: string): Promise<InkeepConfig>;
+export declare function getTenantId(configPath?: string): Promise<string | undefined>;
+export declare function getProjectId(configPath?: string): Promise<string>;
+export declare function getManagementApiUrl(overrideUrl?: string, configPath?: string): Promise<string>;
+export declare function getExecutionApiUrl(overrideUrl?: string, configPath?: string): Promise<string>;
+/**
+ * Validates configuration according to these rules:
+ * 1. If --config-file-path is provided, use it (cannot be combined with --tenant-id)
+ * 2. If --tenant-id AND --management-api-url AND --execution-api-url are provided, use them (cannot be combined with --config-file-path)
+ * 3. If only --management-api-url and --execution-api-url are provided, it overrides the managementApiUrl and executionApiUrl from default config
+ * 4. Otherwise, look for default config file (inkeep.config.ts)
+ *
+ * @param tenantIdFlag - tenantId from command line flag
+ * @param managementApiUrlFlag - managementApiUrl from command line flag
+ * @param executionApiUrlFlag - executionApiUrl from command line flag
+ * @param configFilePath - explicit path to config file
+ * @returns configuration with tenantId, managementApiUrl, and sources used
+ */
+export declare function validateConfiguration(tenantIdFlag?: string, managementApiUrlFlag?: string, executionApiUrlFlag?: string, configFilePath?: string): Promise<ValidatedConfiguration>;

package/dist/config.js

@@ -0,0 +1,292 @@
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import dotenv from 'dotenv';
+// Load .env file from current directory if it exists
+dotenv.config({ quiet: true });
+/**
+ * Search for config file in current directory and parent directories
+ */
+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 = join(currentPath, configName);
+            if (existsSync(configPath)) {
+                return configPath;
+            }
+        }
+        const parentPath = dirname(currentPath);
+        if (parentPath === currentPath) {
+            break; // Reached filesystem root
+        }
+        currentPath = parentPath;
+    }
+    return null;
+}
+async function loadConfigFromFile(configPath) {
+    let resolvedPath;
+    if (configPath) {
+        // User specified a config path
+        resolvedPath = resolve(process.cwd(), configPath);
+        if (!existsSync(resolvedPath)) {
+            throw new Error(`Config file not found: ${resolvedPath}`);
+        }
+    }
+    else {
+        // Search for config file
+        resolvedPath = findConfigFile();
+        if (!resolvedPath) {
+            // No config file found
+            return null;
+        }
+    }
+    try {
+        const fileUrl = pathToFileURL(resolvedPath).href;
+        const module = await import(fileUrl);
+        // Support both default export and named export
+        const config = module.default || module.config;
+        if (!config) {
+            throw new Error(`No config exported from ${resolvedPath}`);
+        }
+        return config;
+    }
+    catch (error) {
+        // If loading a TypeScript file fails, try using the ts-loader utility
+        try {
+            const { loadTypeScriptModule } = await import('./utils/ts-loader.js');
+            const module = await loadTypeScriptModule(resolvedPath);
+            return module.default || module.config || null;
+        }
+        catch {
+            console.warn(`Warning: Failed to load config file ${resolvedPath}:`, error);
+            return null;
+        }
+    }
+}
+export async function loadConfig(configPath) {
+    // Default config
+    const config = {
+        managementApiUrl: 'http://localhost:3002',
+        executionApiUrl: 'http://localhost:3003',
+    };
+    // Try to load from inkeep.config.ts or specified config file
+    const fileConfig = await loadConfigFromFile(configPath);
+    if (fileConfig) {
+        Object.assign(config, fileConfig);
+    }
+    // Override with environment variables if present
+    if (process.env.INKEEP_TENANT_ID) {
+        config.tenantId = process.env.INKEEP_TENANT_ID;
+    }
+    if (process.env.INKEEP_PROJECT_ID) {
+        config.projectId = process.env.INKEEP_PROJECT_ID;
+    }
+    if (process.env.INKEEP_MANAGEMENT_API_URL) {
+        config.managementApiUrl = process.env.INKEEP_MANAGEMENT_API_URL;
+    }
+    if (process.env.INKEEP_EXECUTION_API_URL) {
+        config.executionApiUrl = process.env.INKEEP_EXECUTION_API_URL;
+    }
+    if (process.env.INKEEP_EXECUTION_API_URL) {
+        config.executionApiUrl = process.env.INKEEP_EXECUTION_API_URL;
+    }
+    return config;
+}
+export async function getTenantId(configPath) {
+    const config = await loadConfig(configPath);
+    return config.tenantId;
+}
+export async function getProjectId(configPath) {
+    const config = await loadConfig(configPath);
+    return config.projectId || 'default';
+}
+export async function getManagementApiUrl(overrideUrl, configPath) {
+    // Priority: override > config/env > default
+    if (overrideUrl) {
+        return overrideUrl;
+    }
+    const config = await loadConfig(configPath);
+    return config.managementApiUrl || 'http://localhost:3002';
+}
+export async function getExecutionApiUrl(overrideUrl, configPath) {
+    // Priority: override > config/env > default
+    if (overrideUrl) {
+        return overrideUrl;
+    }
+    const config = await loadConfig(configPath);
+    return config.executionApiUrl || 'http://localhost:3003';
+}
+/**
+ * Validates configuration according to these rules:
+ * 1. If --config-file-path is provided, use it (cannot be combined with --tenant-id)
+ * 2. If --tenant-id AND --management-api-url AND --execution-api-url are provided, use them (cannot be combined with --config-file-path)
+ * 3. If only --management-api-url and --execution-api-url are provided, it overrides the managementApiUrl and executionApiUrl from default config
+ * 4. Otherwise, look for default config file (inkeep.config.ts)
+ *
+ * @param tenantIdFlag - tenantId from command line flag
+ * @param managementApiUrlFlag - managementApiUrl from command line flag
+ * @param executionApiUrlFlag - executionApiUrl from command line flag
+ * @param configFilePath - explicit path to config file
+ * @returns configuration with tenantId, managementApiUrl, and sources used
+ */
+export async function validateConfiguration(tenantIdFlag, managementApiUrlFlag, executionApiUrlFlag, configFilePath) {
+    // Validation: Cannot combine --config-file-path with --tenant-id
+    if (configFilePath && tenantIdFlag) {
+        throw new Error('Invalid configuration combination:\n' +
+            'Cannot use --config-file-path with --tenant-id.\n' +
+            'Please use either:\n' +
+            '  1. --config-file-path alone\n' +
+            '  2. --tenant-id with --management-api-url and --execution-api-url\n' +
+            '  3. Default config file (inkeep.config.ts)');
+    }
+    // Case 1: Explicit config file path provided
+    if (configFilePath) {
+        const config = await loadConfig(configFilePath);
+        const tenantId = config.tenantId;
+        const projectId = config.projectId || 'default';
+        const managementApiUrl = managementApiUrlFlag || config.managementApiUrl; // Allow ---management-api-url to override
+        const executionApiUrl = executionApiUrlFlag || config.executionApiUrl; // Allow --execution-api-url to override
+        if (!tenantId) {
+            throw new Error(`Tenant ID is missing from configuration file: ${configFilePath}\n` +
+                'Please ensure your config file exports a valid configuration with tenantId.');
+        }
+        if (!managementApiUrl) {
+            throw new Error(`Management API URL is missing from configuration file: ${configFilePath}\n` +
+                'Please ensure your config file exports a valid configuration with managementApiUrl.');
+        }
+        if (!executionApiUrl) {
+            throw new Error(`Execution API URL is missing from configuration file: ${configFilePath}\n` +
+                'Please ensure your config file exports a valid configuration with executionApiUrl.');
+        }
+        const sources = {
+            tenantId: `config file (${configFilePath})`,
+            projectId: config.projectId ? `config file (${configFilePath})` : 'default',
+            managementApiUrl: managementApiUrlFlag
+                ? 'command-line flag (--management-api-url)'
+                : `config file (${configFilePath})`,
+            executionApiUrl: executionApiUrlFlag
+                ? 'command-line flag (--execution-api-url)'
+                : `config file (${configFilePath})`,
+            configFile: configFilePath,
+        };
+        return {
+            tenantId,
+            projectId,
+            managementApiUrl,
+            executionApiUrl,
+            modelSettings: config.modelSettings || undefined,
+            outputDirectory: config.outputDirectory,
+            sources,
+        };
+    }
+    // Case 2: Both --tenant-id and --management-api-url and --execution-api-url provided
+    if (tenantIdFlag && managementApiUrlFlag && executionApiUrlFlag) {
+        const sources = {
+            tenantId: 'command-line flag (--tenant-id)',
+            projectId: 'default',
+            managementApiUrl: 'command-line flag (--management-api-url)',
+            executionApiUrl: 'command-line flag (--execution-api-url)',
+        };
+        return {
+            tenantId: tenantIdFlag,
+            projectId: 'default',
+            managementApiUrl: managementApiUrlFlag,
+            executionApiUrl: executionApiUrlFlag,
+            modelSettings: undefined,
+            sources,
+        };
+    }
+    // Case 3: Only --tenant-id provided (invalid)
+    if (tenantIdFlag && !managementApiUrlFlag && !executionApiUrlFlag) {
+        throw new Error('Invalid configuration:\n' +
+            '--tenant-id requires --management-api-url and --execution-api-url to be provided as well.\n' +
+            'Please provide both --tenant-id and --management-api-url and --execution-api-url together.');
+    }
+    // Case 4: Try to load from default config file
+    const config = await loadConfig();
+    const tenantId = config.tenantId;
+    const projectId = config.projectId || 'default';
+    const managementApiUrl = managementApiUrlFlag || config.managementApiUrl; // Allow --management-api-url to override
+    const executionApiUrl = executionApiUrlFlag || config.executionApiUrl; // Allow --execution-api-url to override
+    if (!tenantId) {
+        // Check if a default config file exists
+        const configFile = findConfigFile();
+        if (!configFile) {
+            throw new Error('No configuration found. Please use one of:\n' +
+                '  1. Create "inkeep.config.ts" by running "inkeep init"\n' +
+                '  2. Provide --config-file-path to specify a config file\n' +
+                '  3. Provide both --tenant-id and --management-api-url and --execution-api-url flags\n' +
+                '  4. Set INKEEP_TENANT_ID and INKEEP_API_URL environment variables');
+        }
+        else {
+            throw new Error(`Tenant ID is missing from configuration file: ${configFile}\n` +
+                'Please either:\n' +
+                '  1. Update your configuration file with a tenantId\n' +
+                '  2. Provide both --tenant-id and --management-api-url and --execution-api-url flags\n' +
+                '  3. Set INKEEP_TENANT_ID environment variable');
+        }
+    }
+    if (!managementApiUrl) {
+        throw new Error('Management API URL is missing. Please either:\n' +
+            '  1. Provide --management-api-url flag\n' +
+            '  2. Set INKEEP_MANAGEMENT_API_URL environment variable\n' +
+            '  3. Add managementApiUrl to your configuration file');
+    }
+    if (!executionApiUrl) {
+        throw new Error('Execution API URL is missing. Please either:\n' +
+            '  1. Provide --execution-api-url flag\n' +
+            '  2. Set INKEEP_EXECUTION_API_URL environment variable\n' +
+            '  3. Add executionApiUrl to your configuration file');
+    }
+    // Determine sources for Case 4
+    const configFile = findConfigFile();
+    let tenantIdSource = configFile ? `config file (${configFile})` : 'unknown';
+    let managementApiUrlSource = configFile ? `config file (${configFile})` : 'default';
+    let executionApiUrlSource = configFile ? `config file (${configFile})` : 'default';
+    // Check if environment variables were used
+    if (process.env.INKEEP_TENANT_ID === tenantId) {
+        tenantIdSource = 'environment variable (INKEEP_TENANT_ID)';
+    }
+    if (managementApiUrlFlag) {
+        managementApiUrlSource = 'command-line flag (--management-api-url)';
+    }
+    else if (process.env.INKEEP_MANAGEMENT_API_URL === managementApiUrl) {
+        managementApiUrlSource = 'environment variable (INKEEP_MANAGEMENT_API_URL)';
+    }
+    else if (managementApiUrl === 'http://localhost:3002' && !configFile) {
+        managementApiUrlSource = 'default value';
+    }
+    if (executionApiUrlFlag) {
+        executionApiUrlSource = 'command-line flag (--execution-api-url)';
+    }
+    else if (process.env.INKEEP_EXECUTION_API_URL === executionApiUrl) {
+        executionApiUrlSource = 'environment variable (INKEEP_EXECUTION_API_URL)';
+    }
+    else if (executionApiUrl === 'http://localhost:3003' && !configFile) {
+        executionApiUrlSource = 'default value';
+    }
+    const sources = {
+        tenantId: tenantIdSource,
+        projectId: config.projectId
+            ? configFile
+                ? `config file (${configFile})`
+                : 'config'
+            : 'default',
+        managementApiUrl: managementApiUrlSource,
+        executionApiUrl: executionApiUrlSource,
+        configFile: configFile || undefined,
+    };
+    return {
+        tenantId,
+        projectId,
+        managementApiUrl,
+        executionApiUrl,
+        modelSettings: config.modelSettings || undefined,
+        outputDirectory: config.outputDirectory,
+        sources,
+    };
+}

package/dist/exports.d.ts

@@ -0,0 +1,2 @@
+export type { InkeepConfig } from './types/config.js';
+export { defineConfig } from './types/config.js';

package/dist/exports.js

@@ -0,0 +1,2 @@
+// Re-export configuration utilities for use in user's config files
+export { defineConfig } from './types/config.js';

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};