@syrin/cli 1.3.0

package/dist/cli/commands/dev.js

@@ -0,0 +1,419 @@
+/**
+ * `syrin dev` command implementation.
+ * Interactive development mode for testing MCP tools with LLMs.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { loadConfig } from '../../config/loader.js';
+import { getLLMProvider } from '../../runtime/llm/factory.js';
+import { createMCPClientManager } from '../../runtime/mcp/client/manager.js';
+import { RuntimeEventEmitter } from '../../events/emitter.js';
+import { MemoryEventStore } from '../../events/store/memory-store.js';
+import { FileEventStore } from '../../events/store/file-store.js';
+import { DevSession } from '../../runtime/dev/session.js';
+import { ChatUI } from '../../presentation/dev/chat-ui.js';
+import { DevEventMapper } from '../../runtime/dev/event-mapper.js';
+import { ConfigurationError } from '../../utils/errors.js';
+import { handleCommandError } from '../../cli/utils/index.js';
+import { logger, log } from '../../utils/logger.js';
+import { Messages, Paths, TransportTypes, FileExtensions } from '../../constants/index.js';
+import { makeSessionID } from '../../types/factories.js';
+import { v4 as uuidv4 } from 'uuid';
+import { buildDevWelcomeMessages, formatToolsList, formatCommandHistory, } from '../../presentation/dev-ui.js';
+/**
+ * Resolve the server command to use based on config and run-script flag.
+ * @param config - Syrin configuration
+ * @param runScript - Whether to run the script (spawn server)
+ * @returns Resolved command and whether to spawn the server
+ */
+function resolveServerCommand(config, runScript) {
+    // If run-script flag is provided, spawn using config.script
+    if (runScript) {
+        if (!config.script) {
+            throw new ConfigurationError(Messages.TRANSPORT_SCRIPT_REQUIRED_RUN_FLAG);
+        }
+        return { command: config.script, shouldSpawn: true };
+    }
+    // No run-script flag provided
+    if (config.transport === TransportTypes.STDIO) {
+        // For stdio, always spawn using script
+        if (!config.script) {
+            throw new ConfigurationError(Messages.TRANSPORT_SCRIPT_REQUIRED);
+        }
+        return { command: config.script, shouldSpawn: true };
+    }
+    // For HTTP without run-script flag, don't spawn (connect to existing server)
+    return { command: undefined, shouldSpawn: false };
+}
+/**
+ * Execute the dev command.
+ */
+export async function executeDev(options = {}) {
+    const projectRoot = options.projectRoot || process.cwd();
+    try {
+        // Load configuration
+        const config = loadConfig(projectRoot);
+        // Validate transport configuration
+        if (config.transport === TransportTypes.HTTP && !config.mcp_url) {
+            throw new ConfigurationError(Messages.TRANSPORT_URL_REQUIRED_CONFIG);
+        }
+        // Resolve server command based on transport and run-script flag
+        const { command: serverCommand, shouldSpawn } = resolveServerCommand(config, options.runScript || false);
+        // For stdio, server command is always required
+        if (config.transport === TransportTypes.STDIO && !serverCommand) {
+            throw new ConfigurationError(Messages.TRANSPORT_SCRIPT_REQUIRED);
+        }
+        // Create session ID
+        const sessionId = makeSessionID(`dev-${uuidv4()}`);
+        // Create event store
+        let eventStore;
+        if (options.saveEvents) {
+            // Determine events directory
+            // If eventFile is provided, treat it as a directory path
+            // If it looks like a file path (ends with .jsonl), use its directory
+            let eventsDir;
+            if (options.eventFile) {
+                if (options.eventFile.endsWith(FileExtensions.JSONL)) {
+                    // User provided a file path, use its directory
+                    eventsDir = path.dirname(options.eventFile);
+                }
+                else {
+                    // User provided a directory path
+                    eventsDir = options.eventFile;
+                }
+            }
+            else {
+                // Default to .syrin/events in project root
+                eventsDir = path.join(projectRoot, Paths.EVENTS_DIR);
+            }
+            eventStore = new FileEventStore(eventsDir);
+            const eventFilePath = path.join(eventsDir, `${sessionId}${FileExtensions.JSONL}`);
+            logger.info(`Events will be saved to: ${eventFilePath}`);
+            log.blank();
+            log.info(`Events are being saved to: ${eventFilePath}`);
+            log.blank();
+        }
+        else {
+            eventStore = new MemoryEventStore();
+        }
+        // Create event emitter
+        const eventEmitter = new RuntimeEventEmitter(eventStore, sessionId, null, // workflowId
+        null // promptId
+        );
+        // Create LLM provider
+        const llmProvider = getLLMProvider(options.llm, config, projectRoot);
+        // Create MCP client manager
+        const mcpClientManager = createMCPClientManager(config.transport, config.mcp_url, serverCommand, eventEmitter, shouldSpawn);
+        // Set up cleanup handlers for all exit scenarios
+        // This ensures child processes are always killed, even on unexpected exits
+        const cleanup = async () => {
+            try {
+                // Always disconnect (this kills the child process)
+                await mcpClientManager.disconnect();
+                // Close event store if used
+                if (options.saveEvents && eventStore instanceof FileEventStore) {
+                    await eventStore.close();
+                }
+            }
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                logger.error('Error during cleanup', err);
+                // Even if disconnect fails, try to kill the process directly
+                // This is a safety net to ensure cleanup happens
+            }
+        };
+        // Note: SIGINT handling is now done in the ChatUI section below
+        // Handle SIGTERM
+        process.on('SIGTERM', () => {
+            void (async () => {
+                await cleanup();
+                process.exit(0);
+            })();
+        });
+        // Handle uncaught exceptions
+        process.on('uncaughtException', (error) => {
+            void (async () => {
+                logger.error('Uncaught exception', error);
+                await cleanup();
+                process.exit(1);
+            })();
+        });
+        // Handle unhandled promise rejections
+        process.on('unhandledRejection', (reason) => {
+            void (async () => {
+                logger.error('Unhandled rejection', reason instanceof Error ? reason : new Error(String(reason)));
+                await cleanup();
+                process.exit(1);
+            })();
+        });
+        // Connect to MCP server
+        await mcpClientManager.connect();
+        // Get available tools
+        const availableTools = await mcpClientManager.getAvailableTools();
+        // Create dev session
+        const session = new DevSession({
+            config,
+            llmProvider,
+            mcpClientManager,
+            eventEmitter,
+            executionMode: options.exec || false,
+            projectRoot,
+        });
+        // Initialize session
+        await session.initialize();
+        // Build initial info messages for chat UI (will scroll away when user starts typing)
+        const displayCommand = shouldSpawn && serverCommand ? serverCommand : undefined;
+        const initialMessages = buildDevWelcomeMessages();
+        // Get version info for welcome banner - use same approach as other commands
+        const versionChecker = (await import('../../utils/version-checker.js'));
+        const versionInfo = await versionChecker.checkSyrinVersion();
+        const versionDisplayString = versionChecker.formatVersionWithUpdate(versionInfo);
+        // Create Chat UI
+        const historyFile = path.join(projectRoot, Paths.DEV_HISTORY_FILE);
+        // Bind the method to avoid closure type inference issues
+        const addToHistory = session.addUserMessageToHistory.bind(session);
+        // Declare event mapper variable (will be initialized after ChatUI starts)
+        // We need it in the onExit closure, so declare it here before ChatUI constructor
+        let eventMapper;
+        // Create ChatUI first (event mapper needs it)
+        const chatUI = new ChatUI({
+            agentName: config.agent_name,
+            llmProviderName: llmProvider.getName(),
+            showTimestamps: false,
+            initialMessages,
+            welcomeBanner: {
+                versionDisplay: versionDisplayString,
+                llmProvider: llmProvider.getName(),
+                toolCount: availableTools.length,
+                transport: config.transport,
+                mcpUrl: config.mcp_url,
+                command: displayCommand,
+            },
+            historyFile,
+            maxHistorySize: 1000,
+            getSessionState: () => {
+                const state = session.getState();
+                return {
+                    totalToolCalls: state.totalToolCalls,
+                    toolCalls: state.toolCalls.map(tc => ({
+                        name: tc.name,
+                        timestamp: tc.timestamp,
+                    })),
+                    startTime: state.startTime,
+                };
+            },
+            llmProvider: {
+                chat: async (request) => {
+                    // Convert minimal request to LLMRequest format
+                    const llmRequest = {
+                        messages: request.messages.map(msg => ({
+                            role: msg.role,
+                            content: msg.content,
+                        })),
+                        temperature: request.temperature,
+                        maxTokens: request.maxTokens,
+                    };
+                    const response = await llmProvider.chat(llmRequest);
+                    // Convert LLMResponse to minimal format
+                    return {
+                        content: typeof response.content === 'string'
+                            ? response.content
+                            : JSON.stringify(response.content),
+                    };
+                },
+            },
+            onMessage: async (input) => {
+                // Add user input to session conversation history (even for special commands)
+                // This ensures all commands are saved in chat history
+                addToHistory(input);
+                // Handle special commands
+                if (input === '/tools') {
+                    const tools = session.getAvailableTools();
+                    const toolsList = formatToolsList(tools);
+                    chatUI.addMessage('system', toolsList);
+                    return;
+                }
+                if (input.startsWith('/save-json')) {
+                    // Save tool result JSON to file
+                    // Usage: /save-json [tool-name-or-index]
+                    // If no argument, saves the last tool result
+                    const parts = input.split(/\s+/);
+                    const toolIdentifier = parts[1]; // Optional: tool name or index
+                    try {
+                        const sessionState = session.getState();
+                        const toolCalls = sessionState.toolCalls;
+                        if (toolCalls.length === 0) {
+                            chatUI.addMessage('system', 'No tool calls found. Run a tool first to save its result.');
+                            return;
+                        }
+                        // Find the tool call to save
+                        let toolCallToSave;
+                        if (toolIdentifier) {
+                            // Try to find by index first
+                            const index = parseInt(toolIdentifier, 10);
+                            if (!isNaN(index) && index > 0 && index <= toolCalls.length) {
+                                // 1-indexed for user convenience
+                                toolCallToSave = toolCalls[index - 1];
+                            }
+                            else {
+                                // Try to find by name (case-insensitive, partial match)
+                                const matchingCalls = toolCalls.filter(tc => tc.name.toLowerCase().includes(toolIdentifier.toLowerCase()));
+                                if (matchingCalls.length === 0) {
+                                    chatUI.addMessage('system', `No tool found matching "${toolIdentifier}". Use /save-json without arguments to save the last result, or use a tool index (1-${toolCalls.length}).`);
+                                    return;
+                                }
+                                else if (matchingCalls.length > 1) {
+                                    // Multiple matches - show list
+                                    const toolList = matchingCalls
+                                        .map(tc => `  ${toolCalls.indexOf(tc) + 1}. ${tc.name} (${tc.timestamp.toLocaleTimeString()})`)
+                                        .join('\n');
+                                    chatUI.addMessage('system', `Multiple tools found matching "${toolIdentifier}":\n${toolList}\n\nUse /save-json <index> to save a specific one.`);
+                                    return;
+                                }
+                                else {
+                                    toolCallToSave = matchingCalls[0];
+                                }
+                            }
+                        }
+                        else {
+                            // No identifier - use last tool call
+                            toolCallToSave = toolCalls[toolCalls.length - 1];
+                        }
+                        if (!toolCallToSave) {
+                            chatUI.addMessage('system', 'No tool result available to save.');
+                            return;
+                        }
+                        // Check if result is available (either direct or via reference)
+                        if (!toolCallToSave.result && !toolCallToSave.resultReference) {
+                            chatUI.addMessage('system', 'No tool result available to save.');
+                            return;
+                        }
+                        try {
+                            // Get the result (load from file if externalized)
+                            const result = session.getToolResult(toolCallToSave);
+                            const { saveJSONToFile, getFileSize } = await import('../../utils/json-file-saver.js');
+                            // Save to .syrin/data directory
+                            const dataDir = path.join(projectRoot, '.syrin', 'data');
+                            const filePath = saveJSONToFile(result, toolCallToSave.name, dataDir);
+                            const fileSize = getFileSize(filePath);
+                            chatUI.addMessage('system', `✅ JSON saved to file:\n   ${filePath}\n   Size: ${fileSize}\n   Tool: ${toolCallToSave.name}\n\n💡 You can open this file with: cat "${filePath}" | jq .`);
+                        }
+                        catch (error) {
+                            const errorMessage = error instanceof Error ? error.message : String(error);
+                            chatUI.addMessage('system', `❌ Error loading tool result: ${errorMessage}`);
+                            const err = error instanceof Error ? error : new Error(String(error));
+                            logger.error('Error loading tool result for save', err);
+                        }
+                    }
+                    catch (error) {
+                        const errorMessage = error instanceof Error ? error.message : String(error);
+                        chatUI.addMessage('system', `❌ Error saving JSON: ${errorMessage}`);
+                        const err = error instanceof Error ? error : new Error(String(error));
+                        logger.error('Error saving JSON to file', err);
+                    }
+                    return;
+                }
+                if (input === '/history') {
+                    // Read history from .syrin/.dev-history file
+                    try {
+                        if (fs.existsSync(historyFile)) {
+                            const content = fs.readFileSync(historyFile, 'utf-8');
+                            const historyLines = content
+                                .split('\n')
+                                .filter((line) => line.trim())
+                                .slice(-100); // Show last 100 entries
+                            const historyDisplay = formatCommandHistory(historyLines);
+                            chatUI.addMessage('system', historyDisplay);
+                        }
+                        else {
+                            chatUI.addMessage('system', Messages.DEV_NO_HISTORY);
+                        }
+                    }
+                    catch (error) {
+                        const errorMessage = error instanceof Error ? error.message : String(error);
+                        chatUI.addMessage('system', Messages.DEV_ERROR_READING_HISTORY(errorMessage));
+                        const err = error instanceof Error ? error : new Error(String(error));
+                        logger.error('Error reading history file', err);
+                    }
+                    return;
+                }
+                // Process user input through session
+                try {
+                    await session.processUserInput(input);
+                    // Get the latest assistant response from conversation history
+                    // Note: Tool call events are already displayed incrementally by the event mapper
+                    const stateAfter = session.getState();
+                    const lastMessage = stateAfter.conversationHistory[stateAfter.conversationHistory.length - 1];
+                    if (lastMessage && lastMessage.role === 'assistant') {
+                        chatUI.addMessage('assistant', lastMessage.content);
+                    }
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    chatUI.addMessage('system', `❌ Error: ${errorMessage}`);
+                    const err = error instanceof Error ? error : new Error(String(error));
+                    logger.error('Error processing user input', err);
+                }
+            },
+            onExit: async () => {
+                // Stop event mapper (it's guaranteed to be defined by this point)
+                eventMapper?.stop();
+                // Cleanup on exit
+                try {
+                    await session.complete();
+                    await mcpClientManager.disconnect();
+                    // Close file event store if used
+                    if (options.saveEvents && eventStore instanceof FileEventStore) {
+                        await eventStore.close();
+                        logger.info('Event store closed');
+                    }
+                }
+                catch (error) {
+                    const err = error instanceof Error ? error : new Error(String(error));
+                    logger.error('Error during cleanup', err);
+                }
+            },
+        });
+        // Start Chat UI first to ensure refs are ready
+        // Start Chat UI (header message is already set in options)
+        await chatUI.start();
+        // Create and start event mapper for incremental visibility
+        // This provides real-time event updates to the UI as events are emitted
+        // Must be started AFTER ChatUI is started so refs are ready
+        eventMapper = new DevEventMapper(eventEmitter, chatUI, llmProvider.getName());
+        eventMapper.start(); // Now it's defined, we can call start
+        // Handle SIGINT (Ctrl+C) - ensure cleanup happens
+        let isExiting = false;
+        process.once('SIGINT', () => {
+            if (isExiting) {
+                return; // Already handling exit
+            }
+            isExiting = true;
+            log.plain(Messages.DEV_GOODBYE);
+            // Stop event mapper (it's guaranteed to be defined by this point)
+            eventMapper?.stop();
+            chatUI.stop();
+            void (async () => {
+                try {
+                    await session.complete();
+                    await mcpClientManager.disconnect();
+                    // Close file event store if used
+                    if (options.saveEvents && eventStore instanceof FileEventStore) {
+                        await eventStore.close();
+                    }
+                    // Give a small delay to ensure process is killed
+                    await new Promise(resolve => setTimeout(resolve, 100));
+                }
+                catch (error) {
+                    const err = error instanceof Error ? error : new Error(String(error));
+                    logger.error('Error during SIGINT cleanup', err);
+                }
+                process.exit(0);
+            })();
+        });
+    }
+    catch (error) {
+        handleCommandError(error, Messages.DEV_ERROR_START);
+    }
+}
+//# sourceMappingURL=dev.js.map

package/dist/cli/commands/doctor.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `syrin doctor` command implementation.
+ * Validates the Syrin project configuration and setup.
+ */
+/**
+ * Execute the doctor command.
+ * @param projectRoot - Project root directory (defaults to current working directory)
+ */
+export declare function executeDoctor(projectRoot?: string): Promise<void>;
+//# sourceMappingURL=doctor.d.ts.map

package/dist/cli/commands/doctor.js

@@ -0,0 +1,195 @@
+/**
+ * `syrin doctor` command implementation.
+ * Validates the Syrin project configuration and setup.
+ */
+import { loadConfig } from '../../config/loader.js';
+import { checkEnvVar, checkCommandExists, extractCommandName, } from '../../config/env-checker.js';
+import { handleCommandError } from '../../cli/utils/index.js';
+import { Messages, TransportTypes, Defaults, LLMProviders } from '../../constants/index.js';
+import { displayDoctorReport } from '../../presentation/doctor-ui.js';
+/**
+ * Check transport configuration.
+ */
+function checkTransport(config) {
+    if (config.transport === TransportTypes.HTTP) {
+        if (!config.mcp_url) {
+            return {
+                isValid: false,
+                message: 'MCP URL is missing',
+                fix: Messages.CONFIG_ADD_MCP_URL,
+            };
+        }
+        return {
+            isValid: true,
+            message: Messages.DOCTOR_MCP_URL_INFO(String(config.mcp_url)),
+        };
+    }
+    else {
+        // stdio transport
+        if (!config.script) {
+            return {
+                isValid: false,
+                message: Messages.DOCTOR_SCRIPT_MISSING,
+                fix: Messages.CONFIG_ADD_SCRIPT_STDIO,
+            };
+        }
+        const commandName = extractCommandName(String(config.script));
+        const commandExists = checkCommandExists(commandName);
+        if (!commandExists) {
+            return {
+                isValid: false,
+                message: Messages.DOCTOR_COMMAND_NOT_FOUND(commandName),
+                fix: Messages.DOCTOR_COMMAND_INSTALL(commandName),
+            };
+        }
+        return {
+            isValid: true,
+            message: Messages.DOCTOR_SCRIPT_INFO(String(config.script)),
+        };
+    }
+}
+/**
+ * Check script command.
+ */
+function checkScript(config) {
+    if (!config.script) {
+        // Script is optional for HTTP transport
+        return null;
+    }
+    const script = String(config.script);
+    // Skip validation for scripts that contain shell built-ins or compound commands
+    // These are typically complex shell scripts that can't be validated with simple command checking
+    // Common shell built-ins: source, cd, export, unset, alias, etc.
+    const shellBuiltIns = [
+        'source',
+        'cd',
+        'export',
+        'unset',
+        'alias',
+        'set',
+        'unsetenv',
+    ];
+    const commandName = extractCommandName(script);
+    // If the first command is a shell built-in, skip validation
+    // Scripts with shell built-ins are expected to be run in a shell context
+    if (shellBuiltIns.includes(commandName)) {
+        return {
+            isValid: true, // Assume valid if it uses shell built-ins (will be executed in shell)
+            message: Defaults.WORKING,
+        };
+    }
+    const commandExists = checkCommandExists(commandName);
+    return {
+        isValid: commandExists,
+        message: commandExists
+            ? Defaults.WORKING
+            : Messages.DOCTOR_COMMAND_NOT_FOUND(commandName),
+        fix: commandExists
+            ? undefined
+            : Messages.DOCTOR_COMMAND_INSTALL(commandName),
+    };
+}
+/**
+ * Check LLM provider configuration.
+ */
+function checkLLMProviders(config, projectRoot) {
+    const checks = [];
+    for (const [providerName, providerConfig] of Object.entries(config.llm)) {
+        if (providerName === LLMProviders.OLLAMA) {
+            // Ollama provider - skip API key checks (only MODEL_NAME is needed)
+            continue;
+        }
+        // Cloud provider - check API key and model name
+        const apiKeyVar = providerConfig.API_KEY
+            ? String(providerConfig.API_KEY)
+            : '';
+        const modelVar = providerConfig.MODEL_NAME
+            ? String(providerConfig.MODEL_NAME)
+            : '';
+        const apiKeyCheck = checkEnvVar(apiKeyVar, projectRoot);
+        const modelCheck = checkEnvVar(modelVar, projectRoot);
+        checks.push({
+            provider: providerName,
+            apiKeyCheck: {
+                isValid: apiKeyCheck.isSet,
+                message: apiKeyVar, // Always show the env var name
+                value: apiKeyCheck.value, // Actual API key value (for masking)
+                fix: apiKeyCheck.isSet
+                    ? undefined
+                    : apiKeyCheck.errorMessage ||
+                        Messages.ENV_SET_INSTRUCTIONS(apiKeyVar),
+            },
+            modelCheck: {
+                isValid: modelCheck.isSet,
+                message: modelVar, // Always show the env var name
+                value: modelCheck.value, // Actual model name value
+                fix: modelCheck.isSet
+                    ? undefined
+                    : modelCheck.errorMessage || Messages.ENV_SET_INSTRUCTIONS(modelVar),
+            },
+            isDefault: providerConfig.default === true,
+        });
+    }
+    return checks;
+}
+/**
+ * Check local LLM providers.
+ */
+function checkLocalLLMProviders(config, projectRoot) {
+    const checks = [];
+    for (const [providerName, providerConfig] of Object.entries(config.llm)) {
+        if (providerName === LLMProviders.OLLAMA) {
+            // Get model name for Ollama
+            const modelVar = providerConfig.MODEL_NAME
+                ? String(providerConfig.MODEL_NAME)
+                : '';
+            const modelCheck = checkEnvVar(modelVar, projectRoot);
+            checks.push({
+                provider: providerName,
+                check: {
+                    isValid: modelCheck.isSet,
+                    message: Defaults.WORKING,
+                },
+                modelName: modelCheck.value, // Actual model name
+            });
+        }
+    }
+    return checks.length > 0 ? checks : undefined;
+}
+/**
+ * Generate doctor report.
+ */
+function generateReport(config, projectRoot) {
+    return {
+        config,
+        transportCheck: checkTransport(config),
+        scriptCheck: checkScript(config),
+        llmChecks: checkLLMProviders(config, projectRoot),
+        localLlmChecks: checkLocalLLMProviders(config, projectRoot),
+    };
+}
+/**
+ * Execute the doctor command.
+ * @param projectRoot - Project root directory (defaults to current working directory)
+ */
+export async function executeDoctor(projectRoot = process.cwd()) {
+    try {
+        // Load configuration
+        const config = loadConfig(projectRoot);
+        // Generate report
+        const report = generateReport(config, projectRoot);
+        // Display report using Ink UI
+        await displayDoctorReport(report);
+        // Exit with appropriate code
+        const allValid = report.transportCheck.isValid &&
+            (report.scriptCheck === null || report.scriptCheck.isValid) &&
+            report.llmChecks.every(l => l.apiKeyCheck.isValid && l.modelCheck.isValid);
+        if (!allValid) {
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        handleCommandError(error);
+    }
+}
+//# sourceMappingURL=doctor.js.map

package/dist/cli/commands/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * CLI commands exports.
+ */
+export * from './init.js';
+export * from './doctor.js';
+export * from './test.js';
+export * from './list.js';
+export * from './dev.js';
+export * from './update.js';
+export * from './rollback.js';
+export * from './analyse.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/commands/index.js

@@ -0,0 +1,12 @@
+/**
+ * CLI commands exports.
+ */
+export * from './init.js';
+export * from './doctor.js';
+export * from './test.js';
+export * from './list.js';
+export * from './dev.js';
+export * from './update.js';
+export * from './rollback.js';
+export * from './analyse.js';
+//# sourceMappingURL=index.js.map

package/dist/cli/commands/init.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `syrin init` command implementation.
+ * Initializes a new Syrin project with configuration.
+ */
+export interface InitCommandOptions {
+    /** Skip interactive prompts, use defaults */
+    yes?: boolean;
+    /** Project root directory (defaults to current working directory) */
+    projectRoot?: string;
+}
+/**
+ * Execute the init command.
+ * @param options - Command options
+ */
+export declare function executeInit(options?: InitCommandOptions): Promise<void>;
+//# sourceMappingURL=init.d.ts.map