@inkeep/agents-cli 0.1.0

package/dist/commands/chat-enhanced.js

@@ -0,0 +1,396 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { dirname, extname, resolve } from 'node:path';
+import * as readline from 'node:readline';
+import { fileURLToPath } from 'node:url';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import { ManagementApiClient, ExecutionApiClient } from '../api.js';
+import { validateConfiguration } from '../config.js';
+export async function chatCommandEnhanced(graphIdInput, 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, 'chat'];
+            if (graphIdInput)
+                args.push(graphIdInput);
+            if (options?.tenantId)
+                args.push('--tenant-id', options.tenantId);
+            if (options?.managementApiUrl)
+                args.push('--management-api-url', options.managementApiUrl);
+            if (options?.executionApiUrl)
+                args.push('--execution-api-url', options.executionApiUrl);
+            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, options?.executionApiUrl, 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(`  • Management API: ${config.sources.managementApiUrl}`));
+    console.log(chalk.gray(`  • Execution API: ${config.sources.executionApiUrl}`));
+    console.log();
+    const managementApi = await ManagementApiClient.create(config.managementApiUrl, options?.configFilePath, config.tenantId);
+    const executionApi = await ExecutionApiClient.create(config.executionApiUrl, options?.configFilePath, config.tenantId);
+    let graphId = graphIdInput;
+    // If no graph ID provided, show autocomplete selection
+    if (!graphId) {
+        const spinner = ora('Fetching available graphs...').start();
+        try {
+            const graphs = await managementApi.listGraphs();
+            spinner.stop();
+            if (graphs.length === 0) {
+                console.error(chalk.red('No graphs available. Push a graph first with: inkeep push <graph-path>'));
+                process.exit(1);
+            }
+            // Create searchable source for autocomplete
+            const graphChoices = graphs.map((g) => ({
+                name: `${chalk.cyan(g.id)} - ${g.name || 'Unnamed Graph'}`,
+                value: g.id,
+                short: g.id,
+                searchText: `${g.id} ${g.name || ''}`.toLowerCase(),
+            }));
+            // Use list prompt for interactive selection
+            const answer = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'graphId',
+                    message: 'Select a graph to chat with:',
+                    choices: graphChoices,
+                    pageSize: 10,
+                },
+            ]);
+            graphId = answer.graphId;
+        }
+        catch (error) {
+            spinner.fail('Failed to fetch graphs');
+            console.error(chalk.red('Error:'), error instanceof Error ? error.message : error);
+            process.exit(1);
+        }
+    }
+    // Check if graph exists
+    const spinner = ora('Connecting to graph...').start();
+    try {
+        const graph = await managementApi.getGraph(graphId);
+        if (!graph) {
+            spinner.fail(`Graph "${graphId}" not found`);
+            // Show available graphs
+            const graphs = await managementApi.listGraphs();
+            if (graphs.length > 0) {
+                console.log(chalk.yellow('\nAvailable graphs:'));
+                graphs.forEach((g) => {
+                    console.log(chalk.gray(`  • ${g.id} - ${g.name || 'Unnamed'}`));
+                });
+                console.log(chalk.gray('\nRun "inkeep chat" without arguments for interactive selection'));
+            }
+            else {
+                console.log(chalk.yellow('\nNo graphs found. Please create and push a graph first.'));
+                console.log(chalk.gray('Example: inkeep push ./my-graph.js'));
+            }
+            process.exit(1);
+        }
+        spinner.succeed(`Connected to graph: ${chalk.green(graph.name || graphId)}`);
+        // Display graph details
+        if (graph.description) {
+            console.log(chalk.gray(`Description: ${graph.description}`));
+        }
+        if (graph.defaultAgentId || graph.default_agent_id) {
+            console.log(chalk.gray(`Default Agent: ${graph.defaultAgentId || graph.default_agent_id}`));
+        }
+    }
+    catch (error) {
+        spinner.fail('Failed to connect to graph');
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+    // Create readline interface for chat
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: chalk.cyan('You> '),
+    });
+    // Generate a conversation ID for this session
+    const conversationId = `cli-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    const messages = [];
+    let debugMode = false;
+    console.log(chalk.gray('\n💬 Chat session started. Type "exit" or press Ctrl+C to quit.'));
+    console.log(chalk.gray('Commands: help, clear, history, reset, debug\n'));
+    // Function to handle streaming response
+    async function handleStreamingResponse(stream, showDebug = false) {
+        const decoder = new TextDecoder();
+        const reader = stream.getReader();
+        let buffer = '';
+        let responseContent = '';
+        const debugOperations = [];
+        let hasStartedResponse = false;
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (line.startsWith('data: ')) {
+                        const data = line.slice(6);
+                        if (data === '[DONE]')
+                            continue;
+                        try {
+                            const parsed = JSON.parse(data);
+                            // Handle OpenAI-style streaming chunks
+                            const content = parsed.choices?.[0]?.delta?.content;
+                            if (content) {
+                                // Process content character by character to extract JSON objects
+                                let currentPos = 0;
+                                while (currentPos < content.length) {
+                                    // Check if we're at the start of a JSON data operation
+                                    if (content.substring(currentPos).startsWith('{"type":"data-operation"')) {
+                                        // Find the matching closing brace
+                                        let braceCount = 0;
+                                        let jsonEnd = currentPos;
+                                        for (let i = currentPos; i < content.length; i++) {
+                                            if (content[i] === '{')
+                                                braceCount++;
+                                            if (content[i] === '}') {
+                                                braceCount--;
+                                                if (braceCount === 0) {
+                                                    jsonEnd = i + 1;
+                                                    break;
+                                                }
+                                            }
+                                        }
+                                        // Extract and parse the JSON object
+                                        const jsonStr = content.substring(currentPos, jsonEnd);
+                                        try {
+                                            const dataOp = JSON.parse(jsonStr);
+                                            debugOperations.push(dataOp);
+                                            // Show debug info if enabled
+                                            if (showDebug && dataOp.type === 'data-operation') {
+                                                const opType = dataOp.data?.type || 'unknown';
+                                                const ctx = dataOp.data?.ctx || {};
+                                                // Format context based on operation type
+                                                let ctxDisplay = '';
+                                                if (opType === 'agent_thinking' || opType === 'iteration_start') {
+                                                    ctxDisplay = ctx.agent || JSON.stringify(ctx);
+                                                }
+                                                else if (opType === 'task_creation') {
+                                                    ctxDisplay = `agent: ${ctx.agent}`;
+                                                }
+                                                else {
+                                                    ctxDisplay = JSON.stringify(ctx);
+                                                }
+                                                // Add newline before completion operations that come after text
+                                                if (opType === 'completion' && hasStartedResponse) {
+                                                    console.log(''); // Add newline before completion
+                                                }
+                                                console.log(chalk.gray(`  [${opType}] ${ctxDisplay}`));
+                                            }
+                                            currentPos = jsonEnd;
+                                        }
+                                        catch {
+                                            // Failed to parse, treat as regular content
+                                            if (!hasStartedResponse) {
+                                                process.stdout.write(chalk.green('Assistant> '));
+                                                hasStartedResponse = true;
+                                            }
+                                            process.stdout.write(content[currentPos]);
+                                            responseContent += content[currentPos];
+                                            currentPos++;
+                                        }
+                                    }
+                                    else {
+                                        // Regular text content
+                                        if (!hasStartedResponse) {
+                                            process.stdout.write(chalk.green('Assistant> '));
+                                            hasStartedResponse = true;
+                                        }
+                                        process.stdout.write(content[currentPos]);
+                                        responseContent += content[currentPos];
+                                        currentPos++;
+                                    }
+                                }
+                            }
+                        }
+                        catch {
+                            // Ignore parse errors
+                        }
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        // Add final newline if we had content
+        if (hasStartedResponse) {
+            console.log('\n');
+        }
+        else {
+            console.log(chalk.green('Assistant> ') + chalk.gray('(no response)') + '\n');
+        }
+        return responseContent;
+    }
+    // Handle user input
+    rl.on('line', async (input) => {
+        const trimmedInput = input.trim();
+        const command = trimmedInput.toLowerCase().replace(/^\//, '');
+        if (command === 'exit') {
+            console.log(chalk.gray('Goodbye! 👋'));
+            rl.close();
+            process.exit(0);
+        }
+        if (command === 'clear') {
+            console.clear();
+            console.log(chalk.gray('Screen cleared. Conversation context preserved.\n'));
+            rl.prompt();
+            return;
+        }
+        if (command === 'help') {
+            console.log(chalk.cyan('\n📚 Available commands:'));
+            console.log(chalk.gray('  • exit     - End the chat session'));
+            console.log(chalk.gray('  • clear    - Clear the screen (preserves context)'));
+            console.log(chalk.gray('  • history  - Show conversation history'));
+            console.log(chalk.gray('  • reset    - Reset conversation context'));
+            console.log(chalk.gray('  • debug    - Toggle debug mode (show/hide data operations)'));
+            console.log(chalk.gray('  • help     - Show this help message'));
+            console.log(chalk.gray('\n  Commands can be prefixed with / (e.g., /help)\n'));
+            rl.prompt();
+            return;
+        }
+        if (command === 'debug') {
+            debugMode = !debugMode;
+            console.log(chalk.yellow(`\n🔧 Debug mode: ${debugMode ? 'ON' : 'OFF'}`));
+            if (debugMode) {
+                console.log(chalk.gray('Data operations will be shown during responses.\n'));
+            }
+            else {
+                console.log(chalk.gray('Data operations are hidden.\n'));
+            }
+            rl.prompt();
+            return;
+        }
+        if (command === 'history') {
+            console.log(chalk.cyan('\n📜 Conversation History:'));
+            if (messages.length === 0) {
+                console.log(chalk.gray('  (No messages yet)\n'));
+            }
+            else {
+                messages.forEach((msg, idx) => {
+                    const role = msg.role === 'user' ? chalk.blue('You') : chalk.green('Assistant');
+                    const preview = msg.content.substring(0, 100);
+                    const suffix = msg.content.length > 100 ? '...' : '';
+                    console.log(`  ${idx + 1}. ${role}: ${preview}${suffix}`);
+                });
+                console.log();
+            }
+            rl.prompt();
+            return;
+        }
+        if (command === 'reset') {
+            messages.length = 0;
+            console.log(chalk.yellow('⚠️  Conversation context has been reset.\n'));
+            rl.prompt();
+            return;
+        }
+        if (!trimmedInput) {
+            rl.prompt();
+            return;
+        }
+        // Add user message to history
+        messages.push({ role: 'user', content: trimmedInput });
+        try {
+            // Send message to API using execution API
+            const response = await executionApi.chatCompletion(graphId, messages, conversationId);
+            let assistantResponse;
+            if (typeof response === 'string') {
+                // Non-streaming response
+                console.log(chalk.green('Assistant>'), response);
+                assistantResponse = response;
+            }
+            else {
+                // Streaming response
+                assistantResponse = await handleStreamingResponse(response, debugMode);
+            }
+            // Add assistant response to history
+            messages.push({ role: 'assistant', content: assistantResponse });
+        }
+        catch (error) {
+            console.error(chalk.red('Error:'), error instanceof Error ? error.message : error);
+        }
+        rl.prompt();
+    });
+    rl.on('close', () => {
+        console.log(chalk.gray('\n📊 Session Summary:'));
+        console.log(chalk.gray(`  • Graph: ${graphId}`));
+        console.log(chalk.gray(`  • Messages: ${messages.length}`));
+        console.log(chalk.gray(`  • Duration: ${new Date().toLocaleTimeString()}`));
+        console.log(chalk.gray('\nChat session ended.'));
+        process.exit(0);
+    });
+    // Initial prompt
+    rl.prompt();
+}

package/dist/commands/chat.d.ts

@@ -0,0 +1,5 @@
+export interface ChatOptions {
+    url?: string;
+    config?: string;
+}
+export declare function chatCommand(graphId: string, options: ChatOptions): Promise<void>;

package/dist/commands/chat.js

@@ -0,0 +1,125 @@
+import * as readline from 'node:readline';
+import chalk from 'chalk';
+import ora from 'ora';
+import { ManagementApiClient, ExecutionApiClient } from '../api.js';
+export async function chatCommand(graphId, options) {
+    const managementApi = await ManagementApiClient.create(options.url, options.config);
+    const executionApi = await ExecutionApiClient.create(options.url, options.config);
+    // Check if graph exists using management API
+    const spinner = ora('Connecting to graph...').start();
+    try {
+        const graph = await managementApi.getGraph(graphId);
+        if (!graph) {
+            spinner.fail(`Graph "${graphId}" not found`);
+            process.exit(1);
+        }
+        spinner.succeed(`Connected to graph: ${graph.name || graphId}`);
+    }
+    catch (error) {
+        spinner.fail('Failed to connect to graph');
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+    // Create readline interface
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: chalk.cyan('You> '),
+    });
+    // Generate a conversation ID for this session
+    const conversationId = `cli-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    const messages = [];
+    console.log(chalk.gray('\n💬 Chat session started. Type "exit" or press Ctrl+C to quit.\n'));
+    // Function to handle streaming response
+    async function handleStreamingResponse(stream) {
+        const decoder = new TextDecoder();
+        const reader = stream.getReader();
+        let buffer = '';
+        let responseContent = '';
+        process.stdout.write(chalk.green('Assistant> '));
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (line.startsWith('data: ')) {
+                        const data = line.slice(6);
+                        if (data === '[DONE]')
+                            continue;
+                        try {
+                            const parsed = JSON.parse(data);
+                            const content = parsed.choices?.[0]?.delta?.content;
+                            if (content) {
+                                // Debug logging
+                                if (process.env.DEBUG) {
+                                    console.error('Content received:', content);
+                                }
+                                // Filter out data operation JSON messages
+                                if (!content.startsWith('{"type":"data-operation"')) {
+                                    process.stdout.write(content);
+                                    responseContent += content;
+                                }
+                            }
+                        }
+                        catch (err) {
+                            // Log parse errors for debugging
+                            if (process.env.DEBUG) {
+                                console.error('Parse error:', err, 'Data:', data);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        console.log('\n');
+        return responseContent;
+    }
+    // Set up tab completion for graph IDs
+    rl.on('line', async (input) => {
+        const trimmedInput = input.trim();
+        if (trimmedInput.toLowerCase() === 'exit') {
+            console.log(chalk.gray('Goodbye! 👋'));
+            rl.close();
+            process.exit(0);
+        }
+        if (!trimmedInput) {
+            rl.prompt();
+            return;
+        }
+        // Add user message to history
+        messages.push({ role: 'user', content: trimmedInput });
+        try {
+            // Send message to API using execution API
+            const response = await executionApi.chatCompletion(graphId, messages, conversationId);
+            let assistantResponse;
+            if (typeof response === 'string') {
+                // Non-streaming response
+                console.log(chalk.green('Assistant>'), response);
+                assistantResponse = response;
+            }
+            else {
+                // Streaming response
+                assistantResponse = await handleStreamingResponse(response);
+            }
+            // Add assistant response to history
+            messages.push({ role: 'assistant', content: assistantResponse });
+        }
+        catch (error) {
+            console.error(chalk.red('Error:'), error instanceof Error ? error.message : error);
+        }
+        rl.prompt();
+    });
+    rl.on('close', () => {
+        console.log(chalk.gray('\nChat session ended.'));
+        process.exit(0);
+    });
+    // Initial prompt
+    rl.prompt();
+}

package/dist/commands/config.d.ts

@@ -0,0 +1,6 @@
+export interface ConfigOptions {
+    configFilePath?: string;
+}
+export declare function configGetCommand(key?: string, options?: ConfigOptions): Promise<void>;
+export declare function configSetCommand(key: string, value: string, options?: ConfigOptions): Promise<void>;
+export declare function configListCommand(options?: ConfigOptions): Promise<void>;

package/dist/commands/config.js

@@ -0,0 +1,128 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import chalk from 'chalk';
+export async function configGetCommand(key, options) {
+    const configPath = options?.configFilePath || join(process.cwd(), 'inkeep.config.ts');
+    if (!existsSync(configPath)) {
+        console.error(chalk.red('No configuration file found.'));
+        console.log(chalk.gray('Run "inkeep init" to create one, or specify a config file with --config-file-path'));
+        process.exit(1);
+    }
+    try {
+        const content = readFileSync(configPath, 'utf-8');
+        // Parse the config file to extract values
+        const tenantIdMatch = content.match(/tenantId:\s*['"]([^'"]+)['"]/);
+        const apiUrlMatch = content.match(/apiUrl:\s*['"]([^'"]+)['"]/);
+        const config = {
+            tenantId: tenantIdMatch ? tenantIdMatch[1] : undefined,
+            apiUrl: apiUrlMatch ? apiUrlMatch[1] : undefined,
+        };
+        if (key) {
+            // Get specific key
+            const value = config[key];
+            if (value !== undefined) {
+                console.log(value);
+            }
+            else {
+                console.error(chalk.red(`Unknown configuration key: ${key}`));
+                console.log(chalk.gray('Available keys: tenantId, apiUrl'));
+                process.exit(1);
+            }
+        }
+        else {
+            // Display all config
+            console.log(chalk.cyan('Current configuration:'));
+            console.log(chalk.gray('  Config file:'), configPath);
+            console.log(chalk.gray('  Tenant ID:'), config.tenantId || chalk.yellow('(not set)'));
+            console.log(chalk.gray('  API URL:'), config.apiUrl || chalk.yellow('(not set)'));
+        }
+    }
+    catch (error) {
+        console.error(chalk.red('Failed to read configuration:'), error);
+        process.exit(1);
+    }
+}
+export async function configSetCommand(key, value, options) {
+    const configPath = options?.configFilePath || join(process.cwd(), 'inkeep.config.ts');
+    // Validate the key
+    if (!['tenantId', 'apiUrl'].includes(key)) {
+        console.error(chalk.red(`Invalid configuration key: ${key}`));
+        console.log(chalk.gray('Available keys: tenantId, apiUrl'));
+        process.exit(1);
+    }
+    // Validate apiUrl if setting it
+    if (key === 'apiUrl') {
+        try {
+            new URL(value);
+        }
+        catch {
+            console.error(chalk.red('Invalid URL format'));
+            process.exit(1);
+        }
+    }
+    if (!existsSync(configPath)) {
+        // Create a new config file if it doesn't exist
+        const configContent = `import { defineConfig } from '@inkeep/agents-cli';
+
+export default defineConfig({
+    tenantId: '${key === 'tenantId' ? value : ''}',
+    projectId: '${key === 'projectId' ? value : 'default'}',
+    apiUrl: '${key === 'apiUrl' ? value : 'http://localhost:3002'}',
+});
+`;
+        try {
+            writeFileSync(configPath, configContent);
+            console.log(chalk.green('✓'), `Created config file and set ${key} to:`, chalk.cyan(value));
+        }
+        catch (error) {
+            console.error(chalk.red('Failed to create config file:'), error);
+            process.exit(1);
+        }
+    }
+    else {
+        // Update existing config file
+        try {
+            let content = readFileSync(configPath, 'utf-8');
+            if (key === 'tenantId') {
+                // Update or add tenantId
+                if (content.includes('tenantId:')) {
+                    content = content.replace(/tenantId:\s*['"][^'"]*['"]/, `tenantId: '${value}'`);
+                }
+                else {
+                    // Add tenantId to the config object
+                    content = content.replace(/defineConfig\s*\(\s*{/, `defineConfig({\n    tenantId: '${value}',`);
+                }
+            }
+            else if (key === 'projectId') {
+                // Update or add projectId
+                if (content.includes('projectId:')) {
+                    content = content.replace(/projectId:\s*['"][^'"]*['"]/, `projectId: '${value}'`);
+                }
+                else {
+                    // Add projectId after tenantId
+                    content = content.replace(/(tenantId:\s*['"][^'"]*['"]),?/, `$1,\n    projectId: '${value}',`);
+                }
+            }
+            else if (key === 'apiUrl') {
+                // Update or add apiUrl
+                if (content.includes('apiUrl:')) {
+                    content = content.replace(/apiUrl:\s*['"][^'"]*['"]/, `apiUrl: '${value}'`);
+                }
+                else {
+                    // Add apiUrl to the config object
+                    content = content.replace(/defineConfig\s*\(\s*{/, `defineConfig({\n    apiUrl: '${value}',`);
+                }
+            }
+            writeFileSync(configPath, content);
+            console.log(chalk.green('✓'), `Updated ${key} to:`, chalk.cyan(value));
+        }
+        catch (error) {
+            console.error(chalk.red('Failed to update config file:'), error);
+            process.exit(1);
+        }
+    }
+}
+export async function configListCommand(options) {
+    // Alias for configGetCommand without a key
+    await configGetCommand(undefined, options);
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,5 @@
+export interface InitOptions {
+    path?: string;
+    interactive?: boolean;
+}
+export declare function initCommand(options?: InitOptions): Promise<void>;