@syrin/cli 1.3.1 → 1.4.0

package/README.md

@@ -97,6 +97,42 @@ It makes MCP systems understandable and testable.
 
 ---
 
+## Global Configuration
+
+Syrin supports both **local** (project-specific) and **global** (user-wide) configurations. This allows you to:
+
+- Use Syrin from any directory without initializing a project
+- Share LLM API keys across multiple projects
+- Set default agent names and LLM providers globally
+
+### Quick Setup
+
+```bash
+# Set up global configuration
+syrin config setup --global
+
+# Set API keys in global .env
+syrin config edit-env --global
+
+# Use Syrin from any directory
+syrin dev --exec --transport http --mcp-url http://localhost:8000/mcp
+```
+
+### Configuration Management
+
+```bash
+# View global config
+syrin config list --global
+
+# Set global LLM provider
+syrin config set openai.model "gpt-4-turbo" --global
+
+# Set default provider
+syrin config set-default claude --global
+```
+
+See the [Configuration Guide](docs/Commands/syrin-config.md) for more details.
+
 ## Key Capabilities
 
 ### Static Tool Contract Analysis (`syrin analyse`)

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

@@ -0,0 +1,47 @@
+/**
+ * `syrin config` command implementation.
+ * Manages both local and global Syrin configurations.
+ */
+export interface ConfigCommandOptions {
+    /** Operate on global config */
+    global?: boolean;
+    /** Operate on local config */
+    local?: boolean;
+    /** Key to get/set (e.g., "openai.model", "agent_name") */
+    key?: string;
+    /** Value to set */
+    value?: string;
+}
+/**
+ * Execute config set command.
+ */
+export declare function executeConfigSet(key: string, value: string, options?: ConfigCommandOptions, projectRoot?: string): Promise<void>;
+/**
+ * Execute config get command.
+ */
+export declare function executeConfigGet(key: string, options?: ConfigCommandOptions, projectRoot?: string): Promise<void>;
+/**
+ * Execute config list command.
+ */
+export declare function executeConfigList(options?: ConfigCommandOptions, projectRoot?: string): Promise<void>;
+/**
+ * Execute config show command (same as list for now).
+ */
+export declare function executeConfigShow(options?: ConfigCommandOptions, projectRoot?: string): Promise<void>;
+/**
+ * Execute config edit command.
+ */
+export declare function executeConfigEdit(options?: ConfigCommandOptions, projectRoot?: string): Promise<void>;
+/**
+ * Execute config edit-env command.
+ */
+export declare function executeConfigEditEnv(options?: ConfigCommandOptions, projectRoot?: string): Promise<void>;
+/**
+ * Execute config set-default command.
+ */
+export declare function executeConfigSetDefault(provider: string, options?: ConfigCommandOptions, projectRoot?: string): Promise<void>;
+/**
+ * Execute config remove command.
+ */
+export declare function executeConfigRemove(provider: string, options?: ConfigCommandOptions, projectRoot?: string): Promise<void>;
+//# sourceMappingURL=config.d.ts.map

package/dist/cli/commands/config.js

@@ -0,0 +1,360 @@
+/**
+ * `syrin config` command implementation.
+ * Manages both local and global Syrin configurations.
+ */
+import * as path from 'path';
+import * as os from 'os';
+import * as fs from 'fs';
+import { loadConfigOptional, saveLocalConfig } from '../../config/loader.js';
+import { loadGlobalConfig, saveGlobalConfig, getGlobalConfigPath, globalConfigExists, } from '../../config/global-loader.js';
+import { getGlobalEnvPath } from '../../config/global-loader.js';
+import { Paths } from '../../constants/index.js';
+import { log } from '../../utils/logger.js';
+import { openInEditor } from '../../utils/editor.js';
+import { displayConfigList, displayConfigUpdated, displayEditorOpening, displayEditorClosed, displayDefaultProviderSet, displayProviderRemoved, } from '../../presentation/config-ui.js';
+import { getGlobalEnvTemplate, getLocalEnvTemplate, } from '../../config/env-templates.js';
+import { makeAgentName, makeAPIKey, makeModelName } from '../../types/factories.js';
+/**
+ * Detect config context (local or global).
+ * @param projectRoot - Project root directory
+ * @param options - Command options
+ * @returns 'local' | 'global' | null
+ */
+function detectConfigContext(projectRoot, options) {
+    // Explicit flags take precedence
+    if (options.local)
+        return 'local';
+    if (options.global)
+        return 'global';
+    // Auto-detect: local if exists, else global
+    const localConfigPath = path.join(projectRoot, Paths.CONFIG_FILE);
+    const localExists = fs.existsSync(localConfigPath);
+    if (localExists)
+        return 'local';
+    if (globalConfigExists())
+        return 'global';
+    return null;
+}
+/**
+ * Get config based on context.
+ * @param skipValidation - Skip validation (for editing operations)
+ */
+function getConfig(projectRoot, context, skipValidation = false) {
+    if (context === 'local') {
+        return loadConfigOptional(projectRoot);
+    }
+    return loadGlobalConfig(skipValidation);
+}
+/**
+ * Save config based on context.
+ */
+function saveConfig(config, context, projectRoot, skipValidation = true) {
+    if (context === 'global') {
+        if ('transport' in config) {
+            throw new Error('Cannot save full config to global. Global config only supports LLM settings.');
+        }
+        saveGlobalConfig(config, skipValidation);
+    }
+    else {
+        if (!('transport' in config)) {
+            throw new Error('Cannot save global config to local. Local config requires transport and other fields.');
+        }
+        saveLocalConfig(config, projectRoot);
+    }
+}
+/**
+ * Parse a config key path (e.g., "openai.model" -> { provider: "openai", field: "model" }).
+ */
+function parseConfigKey(key) {
+    const parts = key.split('.');
+    if (parts.length === 1) {
+        const field = parts[0];
+        if (!field) {
+            throw new Error(`Invalid config key: ${key}. Field cannot be empty.`);
+        }
+        return { field };
+    }
+    if (parts.length === 2) {
+        const provider = parts[0];
+        const field = parts[1];
+        if (!provider || !field) {
+            throw new Error(`Invalid config key: ${key}. Provider and field cannot be empty.`);
+        }
+        return { provider, field };
+    }
+    throw new Error(`Invalid config key: ${key}. Use format "field" or "provider.field"`);
+}
+/**
+ * Set a config value.
+ */
+function setConfigValue(config, key, value, context) {
+    const parsed = parseConfigKey(key);
+    // Validate that global config only allows LLM-related fields
+    if (context === 'global') {
+        const allowedFields = ['agent_name', 'openai', 'claude', 'ollama'];
+        const allowedLLMFields = ['api_key', 'model_name', 'model', 'default'];
+        if (parsed.provider) {
+            // LLM provider field
+            if (!allowedFields.includes(parsed.provider)) {
+                throw new Error(`Cannot set "${key}" in global config. Global config only supports LLM provider settings.`);
+            }
+            if (!allowedLLMFields.includes(parsed.field)) {
+                throw new Error(`Invalid LLM field: ${parsed.field}. Allowed: api_key, model_name, model, default`);
+            }
+        }
+        else {
+            // Top-level field
+            if (parsed.field !== 'agent_name') {
+                throw new Error(`Cannot set "${key}" in global config. Global config only supports "agent_name" and LLM provider settings.`);
+            }
+        }
+    }
+    // Clone config
+    // Note: JSON.parse(JSON.stringify()) strips branded/opaque types (e.g., makeAPIKey, makeModelName)
+    // This is intentional - we reapply the factories when setting new values below
+    const updated = JSON.parse(JSON.stringify(config));
+    if (parsed.provider) {
+        // LLM provider field
+        if (!updated.llm[parsed.provider]) {
+            updated.llm[parsed.provider] = {};
+        }
+        const fieldMap = {
+            api_key: 'API_KEY',
+            model_name: 'MODEL_NAME',
+            model: 'MODEL_NAME',
+        };
+        const actualField = fieldMap[parsed.field] || parsed.field.toUpperCase();
+        if (parsed.field === 'default') {
+            // Set default provider
+            Object.keys(updated.llm).forEach(p => {
+                updated.llm[p].default = p === parsed.provider;
+            });
+        }
+        else {
+            updated.llm[parsed.provider][actualField] =
+                actualField === 'API_KEY' ? makeAPIKey(value) : makeModelName(value);
+        }
+    }
+    else {
+        // Top-level field
+        if (parsed.field === 'agent_name') {
+            updated.agent_name = makeAgentName(value);
+        }
+        else {
+            throw new Error(`Cannot set top-level field "${parsed.field}" via config command.`);
+        }
+    }
+    return updated;
+}
+/**
+ * Get a config value.
+ */
+function getConfigValue(config, key) {
+    const parsed = parseConfigKey(key);
+    if (parsed.provider) {
+        // LLM provider field
+        const provider = config.llm[parsed.provider];
+        if (!provider) {
+            return undefined;
+        }
+        const fieldMap = {
+            api_key: 'API_KEY',
+            model_name: 'MODEL_NAME',
+            model: 'MODEL_NAME',
+        };
+        const actualField = fieldMap[parsed.field] || parsed.field.toUpperCase();
+        if (parsed.field === 'default') {
+            return provider.default || false;
+        }
+        return provider[actualField];
+    }
+    // Top-level field
+    const configRecord = config;
+    return configRecord[parsed.field];
+}
+/**
+ * Execute config set command.
+ */
+export async function executeConfigSet(key, value, options = {}, projectRoot = process.cwd()) {
+    const context = detectConfigContext(projectRoot, options);
+    if (!context) {
+        throw new Error('No config found. Create a local config with `syrin init` or set up global config with `syrin init --global`.');
+    }
+    // For set operations, skip validation to allow partial provider configs
+    const config = getConfig(projectRoot, context, true);
+    if (!config) {
+        if (context === 'global') {
+            throw new Error('No global config found. Run `syrin init --global` to create one.');
+        }
+        else {
+            throw new Error('No local config found. Run `syrin init` to create one, or use `--global` flag for global config.');
+        }
+    }
+    const updated = setConfigValue(config, key, value, context);
+    // Save without strict validation (allow partial provider configs during editing)
+    // Validation will happen when config is actually used (in dev mode, etc.)
+    saveConfig(updated, context, projectRoot);
+    const configPath = context === 'local'
+        ? path.join(projectRoot, Paths.CONFIG_FILE)
+        : getGlobalConfigPath();
+    displayConfigUpdated(key, value, context, configPath);
+}
+/**
+ * Execute config get command.
+ */
+export async function executeConfigGet(key, options = {}, projectRoot = process.cwd()) {
+    const context = detectConfigContext(projectRoot, options);
+    if (!context) {
+        throw new Error('No config found. Create a local config with `syrin init` or set up global config with `syrin init --global`.');
+    }
+    const config = getConfig(projectRoot, context);
+    if (!config) {
+        if (context === 'global') {
+            throw new Error('No global config found. Run `syrin init --global` to create one.');
+        }
+        else {
+            throw new Error('No local config found. Run `syrin init` to create one, or use `--global` flag for global config.');
+        }
+    }
+    const value = getConfigValue(config, key);
+    if (value === undefined) {
+        log.error(`Key "${key}" not found in ${context} config.`);
+        process.exit(1);
+    }
+    log.plain(String(value));
+}
+/**
+ * Execute config list command.
+ */
+export async function executeConfigList(options = {}, projectRoot = process.cwd()) {
+    const context = detectConfigContext(projectRoot, options);
+    if (!context) {
+        throw new Error('No config found. Create a local config with `syrin init` or set up global config with `syrin init --global`.');
+    }
+    const config = getConfig(projectRoot, context);
+    if (!config) {
+        if (context === 'global') {
+            throw new Error('No global config found. Run `syrin init --global` to create one.');
+        }
+        else {
+            throw new Error('No local config found. Run `syrin init` to create one, or use `--global` flag for global config.');
+        }
+    }
+    const configPath = context === 'local'
+        ? path.join(projectRoot, Paths.CONFIG_FILE)
+        : getGlobalConfigPath();
+    displayConfigList(config, context, configPath);
+}
+/**
+ * Execute config show command (same as list for now).
+ */
+export async function executeConfigShow(options = {}, projectRoot = process.cwd()) {
+    await executeConfigList(options, projectRoot);
+}
+/**
+ * Execute config edit command.
+ */
+export async function executeConfigEdit(options = {}, projectRoot = process.cwd()) {
+    const context = detectConfigContext(projectRoot, options);
+    if (!context) {
+        throw new Error('No config found. Create a local config with `syrin init` or set up global config with `syrin init --global`.');
+    }
+    const configPath = context === 'local'
+        ? path.join(projectRoot, Paths.CONFIG_FILE)
+        : getGlobalConfigPath();
+    const editorName = os.platform() === 'win32' ? 'notepad' : 'nano';
+    displayEditorOpening(context, configPath, editorName);
+    await openInEditor(configPath);
+    displayEditorClosed('config');
+}
+/**
+ * Execute config edit-env command.
+ */
+export async function executeConfigEditEnv(options = {}, projectRoot = process.cwd()) {
+    const context = detectConfigContext(projectRoot, options);
+    if (!context) {
+        throw new Error('No config found. Create a local config with `syrin init` or set up global config with `syrin init --global`.');
+    }
+    const envPath = context === 'local'
+        ? path.join(projectRoot, Paths.ENV_FILE)
+        : getGlobalEnvPath();
+    const template = context === 'local' ? getLocalEnvTemplate() : getGlobalEnvTemplate();
+    const editorName = os.platform() === 'win32' ? 'notepad' : 'nano';
+    displayEditorOpening(context, envPath, editorName);
+    await openInEditor(envPath, true, template);
+    displayEditorClosed('env');
+}
+/**
+ * Execute config set-default command.
+ */
+export async function executeConfigSetDefault(provider, options = {}, projectRoot = process.cwd()) {
+    const context = detectConfigContext(projectRoot, options);
+    if (!context) {
+        throw new Error('No config found. Create a local config with `syrin init` or set up global config with `syrin init --global`.');
+    }
+    const config = getConfig(projectRoot, context);
+    if (!config) {
+        if (context === 'global') {
+            throw new Error('No global config found. Run `syrin init --global` to create one.');
+        }
+        else {
+            throw new Error('No local config found. Run `syrin init` to create one, or use `--global` flag for global config.');
+        }
+    }
+    if (!config.llm[provider]) {
+        throw new Error(`LLM provider "${provider}" not found in ${context} config.`);
+    }
+    // Clone config to avoid mutating the original
+    const updated = JSON.parse(JSON.stringify(config));
+    // Set all providers to non-default, then set the specified one to default
+    Object.keys(updated.llm).forEach(p => {
+        const providerConfig = updated.llm[p];
+        if (providerConfig) {
+            providerConfig.default = p === provider;
+        }
+    });
+    saveConfig(updated, context, projectRoot);
+    displayDefaultProviderSet(provider, context);
+}
+/**
+ * Execute config remove command.
+ */
+export async function executeConfigRemove(provider, options = {}, projectRoot = process.cwd()) {
+    const context = detectConfigContext(projectRoot, options);
+    if (!context) {
+        throw new Error('No config found. Create a local config with `syrin init` or set up global config with `syrin init --global`.');
+    }
+    const config = getConfig(projectRoot, context);
+    if (!config) {
+        if (context === 'global') {
+            throw new Error('No global config found. Run `syrin init --global` to create one.');
+        }
+        else {
+            throw new Error('No local config found. Run `syrin init` to create one, or use `--global` flag for global config.');
+        }
+    }
+    if (!config.llm[provider]) {
+        throw new Error(`LLM provider "${provider}" not found in ${context} config.`);
+    }
+    // Check if it's the only provider
+    if (Object.keys(config.llm).length === 1) {
+        throw new Error('Cannot remove the last LLM provider. At least one provider is required.');
+    }
+    // Clone config to avoid mutating the original
+    const updated = JSON.parse(JSON.stringify(config));
+    // Check if it's the default provider
+    if (updated.llm[provider]?.default) {
+        // Set another provider as default
+        const otherProvider = Object.keys(updated.llm).find(p => p !== provider);
+        if (otherProvider) {
+            const otherProviderConfig = updated.llm[otherProvider];
+            if (otherProviderConfig) {
+                otherProviderConfig.default = true;
+            }
+        }
+    }
+    delete updated.llm[provider];
+    saveConfig(updated, context, projectRoot);
+    displayProviderRemoved(provider, context);
+}
+//# sourceMappingURL=config.js.map

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

@@ -15,6 +15,12 @@ export interface DevCommandOptions {
     eventFile?: string;
     /** Run script to spawn server internally */
     runScript?: boolean;
+    /** Transport type override */
+    transport?: 'stdio' | 'http';
+    /** MCP URL override (for http transport) */
+    mcpUrl?: string;
+    /** Script command override (for stdio transport) */
+    script?: string;
 }
 /**
  * Execute the dev command.

package/dist/cli/commands/dev.js

@@ -4,7 +4,8 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
-import { loadConfig } from '../../config/loader.js';
+import { loadConfigWithGlobal, configExists } from '../../config/loader.js';
+import { loadGlobalConfig } from '../../config/global-loader.js';
 import { getLLMProvider } from '../../runtime/llm/factory.js';
 import { createMCPClientManager } from '../../runtime/mcp/client/manager.js';
 import { RuntimeEventEmitter } from '../../events/emitter.js';
@@ -15,7 +16,7 @@ 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 { 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';
@@ -51,8 +52,59 @@ function resolveServerCommand(config, runScript) {
 export async function executeDev(options = {}) {
     const projectRoot = options.projectRoot || process.cwd();
     try {
-        // Load configuration
-        const config = loadConfig(projectRoot);
+        // Load configuration (with global fallback)
+        const localExists = configExists(projectRoot);
+        const globalExists = loadGlobalConfig() !== null;
+        let config;
+        let configSource;
+        try {
+            const configResult = loadConfigWithGlobal(projectRoot, {
+                transport: options.transport,
+                mcp_url: options.mcpUrl,
+                script: options.script,
+            });
+            config = configResult.config;
+            configSource = configResult.source;
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                error.message.includes('No configuration found')) {
+                log.blank();
+                log.error('❌ No configuration found.');
+                log.blank();
+                if (!localExists && !globalExists) {
+                    log.info('💡 Options:');
+                    log.info('   1. Create local config: syrin init');
+                    log.info('   2. Set up global config: syrin init --global');
+                    log.blank();
+                }
+                else if (!localExists) {
+                    log.info('💡 Using global config requires CLI flags:');
+                    log.info('   --transport <stdio|http>');
+                    if (options.transport === 'http') {
+                        log.info('   --mcp-url <url>');
+                    }
+                    else if (options.transport === 'stdio') {
+                        log.info('   --script <command>');
+                    }
+                    else {
+                        // Show both options when transport is not specified
+                        log.info('   --mcp-url <url> (for http transport)');
+                        log.info('   --script <command> (for stdio transport)');
+                    }
+                    log.blank();
+                }
+                throw error;
+            }
+            throw error;
+        }
+        // Show config source
+        if (configSource === 'global') {
+            log.blank();
+            log.info('ℹ️  Using global configuration from ~/.syrin/syrin.yaml');
+            log.info('   (No local syrin.yaml found in current directory)');
+            log.blank();
+        }
         // Validate transport configuration
         if (config.transport === TransportTypes.HTTP && !config.mcp_url) {
             throw new ConfigurationError(Messages.TRANSPORT_URL_REQUIRED_CONFIG);
@@ -88,7 +140,7 @@ export async function executeDev(options = {}) {
             }
             eventStore = new FileEventStore(eventsDir);
             const eventFilePath = path.join(eventsDir, `${sessionId}${FileExtensions.JSONL}`);
-            logger.info(`Events will be saved to: ${eventFilePath}`);
+            log.info(`Events will be saved to: ${eventFilePath}`);
             log.blank();
             log.info(`Events are being saved to: ${eventFilePath}`);
             log.blank();
@@ -117,7 +169,7 @@ export async function executeDev(options = {}) {
             }
             catch (error) {
                 const err = error instanceof Error ? error : new Error(String(error));
-                logger.error('Error during cleanup', err);
+                log.error(`Error: ${err.message}`);
                 // Even if disconnect fails, try to kill the process directly
                 // This is a safety net to ensure cleanup happens
             }
@@ -133,7 +185,7 @@ export async function executeDev(options = {}) {
         // Handle uncaught exceptions
         process.on('uncaughtException', (error) => {
             void (async () => {
-                logger.error('Uncaught exception', error);
+                log.error(`Error: ${error.message}`);
                 await cleanup();
                 process.exit(1);
             })();
@@ -141,7 +193,7 @@ export async function executeDev(options = {}) {
         // Handle unhandled promise rejections
         process.on('unhandledRejection', (reason) => {
             void (async () => {
-                logger.error('Unhandled rejection', reason instanceof Error ? reason : new Error(String(reason)));
+                log.error(`Error: ${reason instanceof Error ? reason.message : String(reason)}`);
                 await cleanup();
                 process.exit(1);
             })();
@@ -302,14 +354,14 @@ export async function executeDev(options = {}) {
                             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);
+                            log.error(`Error: ${err.message}`);
                         }
                     }
                     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);
+                        log.error(`Error: ${err.message}`);
                     }
                     return;
                 }
@@ -333,7 +385,7 @@ export async function executeDev(options = {}) {
                         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);
+                        log.error(`Error: ${err.message}`);
                     }
                     return;
                 }
@@ -352,7 +404,7 @@ export async function executeDev(options = {}) {
                     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);
+                    log.error(`Error: ${err.message}`);
                 }
             },
             onExit: async () => {
@@ -365,12 +417,12 @@ export async function executeDev(options = {}) {
                     // Close file event store if used
                     if (options.saveEvents && eventStore instanceof FileEventStore) {
                         await eventStore.close();
-                        logger.info('Event store closed');
+                        log.info('Event store closed');
                     }
                 }
                 catch (error) {
                     const err = error instanceof Error ? error : new Error(String(error));
-                    logger.error('Error during cleanup', err);
+                    log.error(`Error: ${err.message}`);
                 }
             },
         });
@@ -406,7 +458,7 @@ export async function executeDev(options = {}) {
                 }
                 catch (error) {
                     const err = error instanceof Error ? error : new Error(String(error));
-                    logger.error('Error during SIGINT cleanup', err);
+                    log.error(`Error: ${err.message}`);
                 }
                 process.exit(0);
             })();