@syrin/cli 1.3.2 → 1.4.1

package/dist/cli/prompts/init-prompt.d.ts

@@ -2,6 +2,7 @@
  * Interactive prompts for the `syrin init` command.
  */
 import type { InitOptions } from '../../config/types.js';
+import { makeAgentName } from '../../types/factories.js';
 /**
  * Prompt user for project initialization details.
  * @param defaults - Default values for non-interactive mode
@@ -14,4 +15,21 @@ export declare function promptInitOptions(defaults?: Partial<InitOptions>): Prom
  * @returns Default options
  */
 export declare function getDefaultInitOptions(projectRoot: string): InitOptions;
+/**
+ * Global init options (LLM providers only).
+ */
+export interface GlobalInitOptions {
+    agentName: ReturnType<typeof makeAgentName>;
+    llmProviders: InitOptions['llmProviders'];
+}
+/**
+ * Prompt user for global initialization details (LLM providers only).
+ * @returns User's answers for global config
+ */
+export declare function promptGlobalInitOptions(): Promise<GlobalInitOptions>;
+/**
+ * Create default global init options for non-interactive mode.
+ * @returns Default options for global config
+ */
+export declare function getDefaultGlobalInitOptions(): GlobalInitOptions;
 //# sourceMappingURL=init-prompt.d.ts.map

package/dist/cli/prompts/init-prompt.js

@@ -6,116 +6,33 @@ import * as path from 'path';
 import { makeProjectName, makeAgentName, makeMCPURL, makeAPIKey, makeModelName, makeScriptCommand, } from '../../types/factories.js';
 import { Messages, TransportTypes, LLMProviders, LLMProviderDisplayNames, Defaults, EnvVars, } from '../../constants/index.js';
 /**
- * Prompt user for project initialization details.
- * @param defaults - Default values for non-interactive mode
- * @returns User's answers
+ * Get LLM provider prompts (shared between init and global init).
+ * @param defaultProviders - Default providers to check (for non-interactive mode)
+ * @returns Array of inquirer questions for LLM provider configuration
  */
-export async function promptInitOptions(defaults) {
-    const currentDirName = path.basename(process.cwd());
-    const defaultProjectName = defaults?.projectName ||
-        currentDirName.replace(/[^a-z0-9-]/gi, '-').toLowerCase();
-    const answers = await inquirer.prompt([
-        {
-            type: 'input',
-            name: 'projectName',
-            message: 'Project name:',
-            default: defaultProjectName,
-            validate: (input) => {
-                if (!input.trim()) {
-                    return Messages.PROMPT_PROJECT_NAME_REQUIRED;
-                }
-                if (!/^[a-z0-9-]+$/i.test(input)) {
-                    return Messages.PROMPT_PROJECT_NAME_INVALID;
-                }
-                return true;
-            },
-        },
-        {
-            type: 'input',
-            name: 'agentName',
-            message: 'Agent name:',
-            default: defaults?.agentName
-                ? String(defaults.agentName)
-                : Defaults.AGENT_NAME,
-            validate: (input) => {
-                if (!input.trim()) {
-                    return Messages.PROMPT_AGENT_NAME_REQUIRED;
-                }
-                return true;
-            },
-        },
-        {
-            type: 'list',
-            name: 'transport',
-            message: 'Transport type:',
-            choices: [
-                {
-                    name: `${TransportTypes.STDIO} - Spawn MCP server as a subprocess`,
-                    value: TransportTypes.STDIO,
-                },
-                {
-                    name: `${TransportTypes.HTTP} - Connect to a running MCP server via HTTP`,
-                    value: TransportTypes.HTTP,
-                },
-            ],
-            default: defaults?.transport || Defaults.TRANSPORT,
-        },
-        {
-            type: 'input',
-            name: 'mcpUrl',
-            message: 'MCP server URL:',
-            default: defaults?.mcpUrl ? String(defaults.mcpUrl) : Defaults.MCP_URL,
-            when: (answers) => answers?.transport === TransportTypes.HTTP,
-            validate: (input, answers) => {
-                if (answers?.transport === TransportTypes.HTTP) {
-                    if (!input.trim()) {
-                        return Messages.PROMPT_MCP_URL_REQUIRED;
-                    }
-                    try {
-                        new URL(input);
-                        return true;
-                    }
-                    catch {
-                        return Messages.PROMPT_URL_INVALID;
-                    }
-                }
-                return true;
-            },
-        },
-        {
-            type: 'input',
-            name: 'script',
-            message: 'Script command to run MCP server:',
-            default: defaults?.script ? String(defaults.script) : 'python3 server.py',
-            validate: (input) => {
-                if (!input.trim()) {
-                    return Messages.PROMPT_SCRIPT_REQUIRED;
-                }
-                return true;
-            },
-        },
+function getLLMProviderPrompts(defaultProviders) {
+    return [
         {
             type: 'checkbox',
             name: 'llmProviders',
-            message: 'Select LLM providers to configure:',
+            message: 'Select LLM providers to configure (SPACE to toggle, ENTER to confirm):',
             choices: [
                 {
                     name: LLMProviderDisplayNames.OPENAI,
                     value: LLMProviders.OPENAI,
-                    checked: true,
+                    checked: defaultProviders?.includes(LLMProviders.OPENAI) ?? true,
                 },
                 {
                     name: LLMProviderDisplayNames.CLAUDE,
                     value: LLMProviders.CLAUDE,
+                    checked: defaultProviders?.includes(LLMProviders.CLAUDE) ?? false,
                 },
                 {
                     name: LLMProviderDisplayNames.OLLAMA,
                     value: LLMProviders.OLLAMA,
+                    checked: defaultProviders?.includes(LLMProviders.OLLAMA) ?? false,
                 },
             ],
-            default: defaults?.llmProviders
-                ? Object.keys(defaults.llmProviders)
-                : [LLMProviders.OPENAI],
             validate: (input) => {
                 if (input.length === 0) {
                     return Messages.PROMPT_LLM_PROVIDER_REQUIRED;
@@ -198,23 +115,29 @@ export async function promptInitOptions(defaults) {
             name: 'defaultProvider',
             message: 'Default LLM provider:',
             choices: (answers) => answers.llmProviders || [],
-            default: (answers) => answers.llmProviders?.[0] || 'openai',
+            default: (answers) => answers.llmProviders?.[0],
         },
-    ]);
-    // Build LLM providers config
+    ];
+}
+/**
+ * Build LLM providers config from answers (shared between init and global init).
+ * @param answers - User answers containing LLM provider selections
+ * @returns LLM providers configuration object
+ */
+function buildLLMProvidersConfig(answers) {
     const llmProviders = {};
     if (answers.llmProviders.includes('openai')) {
         llmProviders.openai = {
             apiKey: makeAPIKey(answers.openaiApiKey || ''),
             modelName: makeModelName(answers.openaiModel || ''),
-            default: answers.defaultProvider === 'openai' || false,
+            default: answers.defaultProvider === 'openai',
         };
     }
     if (answers.llmProviders.includes('claude')) {
         llmProviders.claude = {
             apiKey: makeAPIKey(answers.claudeApiKey || ''),
             modelName: makeModelName(answers.claudeModel || ''),
-            default: answers.defaultProvider === 'claude' || false,
+            default: answers.defaultProvider === 'claude',
         };
     }
     if (answers.llmProviders.includes('ollama')) {
@@ -222,16 +145,112 @@ export async function promptInitOptions(defaults) {
             modelName: answers.ollamaModelName
                 ? makeModelName(answers.ollamaModelName)
                 : undefined,
-            default: answers.defaultProvider === 'ollama' || false,
+            default: answers.defaultProvider === 'ollama',
         };
     }
+    return llmProviders;
+}
+/**
+ * Prompt user for project initialization details.
+ * @param defaults - Default values for non-interactive mode
+ * @returns User's answers
+ */
+export async function promptInitOptions(defaults) {
+    const currentDirName = path.basename(process.cwd());
+    const defaultProjectName = defaults?.projectName ||
+        currentDirName.replace(/[^a-z0-9-]/gi, '-').toLowerCase();
+    const projectPrompts = [
+        {
+            type: 'input',
+            name: 'projectName',
+            message: 'Project name:',
+            default: defaultProjectName,
+            validate: (input) => {
+                if (!input.trim()) {
+                    return Messages.PROMPT_PROJECT_NAME_REQUIRED;
+                }
+                if (!/^[a-z0-9-]+$/i.test(input)) {
+                    return Messages.PROMPT_PROJECT_NAME_INVALID;
+                }
+                return true;
+            },
+        },
+        {
+            type: 'input',
+            name: 'agentName',
+            message: 'Agent name:',
+            default: defaults?.agentName
+                ? String(defaults.agentName)
+                : Defaults.AGENT_NAME,
+            validate: (input) => {
+                if (!input.trim()) {
+                    return Messages.PROMPT_AGENT_NAME_REQUIRED;
+                }
+                return true;
+            },
+        },
+        {
+            type: 'list',
+            name: 'transport',
+            message: 'Transport type:',
+            choices: [
+                {
+                    name: `${TransportTypes.STDIO} - Spawn MCP server as a subprocess`,
+                    value: TransportTypes.STDIO,
+                },
+                {
+                    name: `${TransportTypes.HTTP} - Connect to a running MCP server via HTTP`,
+                    value: TransportTypes.HTTP,
+                },
+            ],
+            default: defaults?.transport || Defaults.TRANSPORT,
+        },
+        {
+            type: 'input',
+            name: 'mcpUrl',
+            message: 'MCP server URL:',
+            default: defaults?.mcpUrl ? String(defaults.mcpUrl) : Defaults.MCP_URL,
+            when: (answers) => answers?.transport === TransportTypes.HTTP,
+            validate: (input, answers) => {
+                if (answers?.transport === TransportTypes.HTTP) {
+                    if (!input.trim()) {
+                        return Messages.PROMPT_MCP_URL_REQUIRED;
+                    }
+                    try {
+                        new URL(input);
+                        return true;
+                    }
+                    catch {
+                        return Messages.PROMPT_URL_INVALID;
+                    }
+                }
+                return true;
+            },
+        },
+        {
+            type: 'input',
+            name: 'script',
+            message: 'Script command to run MCP server:',
+            default: defaults?.script ? String(defaults.script) : 'python3 server.py',
+            validate: (input) => {
+                if (!input.trim()) {
+                    return Messages.PROMPT_SCRIPT_REQUIRED;
+                }
+                return true;
+            },
+        },
+    ];
+    // Combine project prompts with LLM provider prompts
+    const llmPrompts = getLLMProviderPrompts(defaults?.llmProviders ? Object.keys(defaults.llmProviders) : undefined);
+    const allPrompts = [...projectPrompts, ...llmPrompts];
+    const answers = await inquirer.prompt(allPrompts);
     return {
         projectName: makeProjectName(answers.projectName),
         agentName: makeAgentName(answers.agentName),
         transport: answers.transport,
         mcpUrl: answers.mcpUrl ? makeMCPURL(answers.mcpUrl) : undefined,
         script: makeScriptCommand(answers.script),
-        llmProviders,
+        llmProviders: buildLLMProvidersConfig(answers),
         nonInteractive: false,
     };
 }
@@ -260,4 +279,45 @@ export function getDefaultInitOptions(projectRoot) {
         nonInteractive: true,
     };
 }
+/**
+ * Prompt user for global initialization details (LLM providers only).
+ * @returns User's answers for global config
+ */
+export async function promptGlobalInitOptions() {
+    const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'agentName',
+            message: 'Agent name:',
+            default: Defaults.AGENT_NAME,
+            validate: (input) => {
+                if (!input.trim()) {
+                    return Messages.PROMPT_AGENT_NAME_REQUIRED;
+                }
+                return true;
+            },
+        },
+        ...getLLMProviderPrompts(),
+    ]);
+    return {
+        agentName: makeAgentName(answers.agentName),
+        llmProviders: buildLLMProvidersConfig(answers),
+    };
+}
+/**
+ * Create default global init options for non-interactive mode.
+ * @returns Default options for global config
+ */
+export function getDefaultGlobalInitOptions() {
+    return {
+        agentName: makeAgentName(Defaults.AGENT_NAME),
+        llmProviders: {
+            openai: {
+                apiKey: makeAPIKey(EnvVars.OPENAI_API_KEY),
+                modelName: makeModelName(EnvVars.OPENAI_MODEL_NAME),
+                default: true,
+            },
+        },
+    };
+}
 //# sourceMappingURL=init-prompt.js.map

package/dist/cli/utils/command-error-handler.js

@@ -2,8 +2,8 @@
  * Command error handling utilities.
  * Provides consistent error handling patterns for CLI commands.
  */
-import { logger, log } from '../../utils/logger.js';
-import { ConfigurationError, normalizeError, getErrorMessage, } from '../../utils/errors.js';
+import { log } from '../../utils/logger.js';
+import { ConfigurationError, getErrorMessage } from '../../utils/errors.js';
 import { Messages } from '../../constants/index.js';
 /**
  * Handle and display command errors with consistent formatting.
@@ -23,9 +23,6 @@ export function handleCommandError(error, defaultMessage = Messages.ERROR_UNEXPE
         log.blank();
         process.exit(1);
     }
-    const err = normalizeError(error);
-    // Only log to structured logger (won't output unless debug mode is enabled)
-    logger.error('Command failed', err);
     const message = getErrorMessage(error) || defaultMessage;
     log.blank();
     log.error(message);

package/dist/config/env-checker.d.ts

@@ -13,15 +13,25 @@ export interface EnvCheckResult {
     keyExistsInEnvFile?: boolean;
     /** Error message explaining why the variable is not set */
     errorMessage?: string;
+    /** Source of the environment variable: 'process.env' | 'global.env' | 'local.env' */
+    source?: 'process.env' | 'global.env' | 'local.env';
 }
+/**
+ * Load global environment file.
+ * @returns Map of environment variables from ~/.syrin/.env
+ */
+export declare function loadGlobalEnvFile(): Map<string, string>;
 /**
  * Check if an environment variable is set.
- * Checks both process.env and .env file, providing detailed error messages.
+ * Checks in order:
+ *   - For local context: process.env > local .env > global .env
+ *   - For global context: process.env > global .env
  * @param varName - Name of the environment variable
  * @param projectRoot - Root directory of the project
+ * @param isGlobalContext - Whether this check is for global config (affects check order and error messages)
  * @returns Check result with detailed error information
  */
-export declare function checkEnvVar(varName: string, projectRoot?: string): EnvCheckResult;
+export declare function checkEnvVar(varName: string, projectRoot?: string, isGlobalContext?: boolean): EnvCheckResult;
 /**
  * Check if a command exists and is executable.
  * @param command - Command to check (e.g., "python3", "node")

package/dist/config/env-checker.js

@@ -6,6 +6,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { execSync } from 'child_process';
 import { Messages, Paths } from '../constants/index.js';
+import { getGlobalEnvPath } from './global-loader.js';
 /**
  * Parse .env file and return key-value pairs.
  * @param envFilePath - Path to .env file
@@ -44,62 +45,111 @@ function parseEnvFile(envFilePath) {
     }
     return envMap;
 }
+/**
+ * Load global environment file.
+ * @returns Map of environment variables from ~/.syrin/.env
+ */
+export function loadGlobalEnvFile() {
+    const globalEnvPath = getGlobalEnvPath();
+    return parseEnvFile(globalEnvPath);
+}
 /**
  * Check if an environment variable is set.
- * Checks both process.env and .env file, providing detailed error messages.
+ * Checks in order:
+ *   - For local context: process.env > local .env > global .env
+ *   - For global context: process.env > global .env
  * @param varName - Name of the environment variable
  * @param projectRoot - Root directory of the project
+ * @param isGlobalContext - Whether this check is for global config (affects check order and error messages)
  * @returns Check result with detailed error information
  */
-export function checkEnvVar(varName, projectRoot = process.cwd()) {
-    const envFilePath = path.join(projectRoot, Paths.ENV_FILE);
-    const envFileExists = fs.existsSync(envFilePath);
+export function checkEnvVar(varName, projectRoot = process.cwd(), isGlobalContext = false) {
+    const localEnvFilePath = path.join(projectRoot, Paths.ENV_FILE);
+    const globalEnvPath = getGlobalEnvPath();
+    const localEnvFileExists = fs.existsSync(localEnvFilePath);
+    const globalEnvFileExists = fs.existsSync(globalEnvPath);
     // First check process.env (takes precedence)
     const processEnvValue = process.env[varName];
     if (processEnvValue !== undefined && processEnvValue !== '') {
         return {
             isSet: true,
             value: processEnvValue,
-            envFileExists,
-            keyExistsInEnvFile: undefined, // Not checked since process.env has it
+            envFileExists: localEnvFileExists || globalEnvFileExists,
+            keyExistsInEnvFile: undefined,
+            source: 'process.env',
         };
     }
-    // If not in process.env, check .env file
-    if (!envFileExists) {
-        return {
-            isSet: false,
-            envFileExists: false,
-            keyExistsInEnvFile: false,
-            errorMessage: Messages.ENV_FILE_NOT_PRESENT(varName),
-        };
+    // For local context: check local .env first, then global .env
+    // For global context: check global .env only
+    if (!isGlobalContext && localEnvFileExists) {
+        const localEnvMap = parseEnvFile(localEnvFilePath);
+        const keyExistsInLocalEnv = localEnvMap.has(varName);
+        const localEnvValue = localEnvMap.get(varName);
+        if (keyExistsInLocalEnv) {
+            if (localEnvValue === '' || localEnvValue === undefined) {
+                return {
+                    isSet: false,
+                    value: localEnvValue,
+                    envFileExists: true,
+                    keyExistsInEnvFile: true,
+                    errorMessage: Messages.ENV_KEY_EMPTY(varName),
+                    source: 'local.env',
+                };
+            }
+            return {
+                isSet: true,
+                value: localEnvValue,
+                envFileExists: true,
+                keyExistsInEnvFile: true,
+                source: 'local.env',
+            };
+        }
     }
-    // Parse .env file
-    const envMap = parseEnvFile(envFilePath);
-    const keyExistsInEnvFile = envMap.has(varName);
-    const envFileValue = envMap.get(varName);
-    if (!keyExistsInEnvFile) {
-        return {
-            isSet: false,
-            envFileExists: true,
-            keyExistsInEnvFile: false,
-            errorMessage: Messages.ENV_KEY_NOT_FOUND(varName),
-        };
+    // Check global .env file (fallback for local context, primary for global context)
+    if (globalEnvFileExists) {
+        const globalEnvMap = parseEnvFile(globalEnvPath);
+        const keyExistsInGlobalEnv = globalEnvMap.has(varName);
+        const globalEnvValue = globalEnvMap.get(varName);
+        if (keyExistsInGlobalEnv) {
+            if (globalEnvValue === '') {
+                return {
+                    isSet: false,
+                    envFileExists: true,
+                    keyExistsInEnvFile: true,
+                    source: 'global.env',
+                    errorMessage: Messages.ENV_SET_INSTRUCTIONS(varName),
+                };
+            }
+            return {
+                isSet: true,
+                value: globalEnvValue,
+                envFileExists: true,
+                keyExistsInEnvFile: true,
+                source: 'global.env',
+            };
+        }
     }
-    if (envFileValue === '' || envFileValue === undefined) {
-        return {
-            isSet: false,
-            value: envFileValue,
-            envFileExists: true,
-            keyExistsInEnvFile: true,
-            errorMessage: Messages.ENV_KEY_EMPTY(varName),
-        };
+    // Variable not found in any source
+    // Generate appropriate error message based on context
+    let errorMessage;
+    if (isGlobalContext) {
+        // For global config, suggest global .env or environment variables
+        if (globalEnvFileExists) {
+            errorMessage = `Key "${varName}" not found in ${globalEnvPath} or environment variables`;
+        }
+        else {
+            errorMessage = `Global .env file not found at ${globalEnvPath}. Create it with: syrin config edit-env --global`;
+        }
+    }
+    else {
+        // For local config, use original message
+        errorMessage = Messages.ENV_FILE_NOT_PRESENT(varName);
     }
-    // Key exists and has a value
     return {
-        isSet: true,
-        value: envFileValue,
-        envFileExists: true,
-        keyExistsInEnvFile: true,
+        isSet: false,
+        envFileExists: localEnvFileExists || globalEnvFileExists,
+        keyExistsInEnvFile: false,
+        errorMessage,
     };
 }
 /**

package/dist/config/env-templates.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Environment file templates.
+ * Provides templates for creating .env files.
+ */
+/**
+ * Get template for global environment file.
+ * @returns Template content for ~/.syrin/.env
+ */
+export declare function getGlobalEnvTemplate(): string;
+/**
+ * Get template for local environment file.
+ * @returns Template content for ./.env
+ */
+export declare function getLocalEnvTemplate(): string;
+//# sourceMappingURL=env-templates.d.ts.map

package/dist/config/env-templates.js

@@ -0,0 +1,49 @@
+/**
+ * Environment file templates.
+ * Provides templates for creating .env files.
+ */
+/**
+ * Get template for global environment file.
+ * @returns Template content for ~/.syrin/.env
+ */
+export function getGlobalEnvTemplate() {
+    return `# Syrin Global Environment Variables
+# ===========================================
+# Add your API keys and model names here.
+# These will be used when the global config references environment variable names.
+#
+# Example:
+# OPENAI_API_KEY=sk-proj-abc123...
+# OPENAI_MODEL=gpt-4-turbo
+# ANTHROPIC_API_KEY=sk-ant-api03-...
+# ANTHROPIC_MODEL=claude-3-5-sonnet-20241022
+# OLLAMA_MODEL_NAME=llama2
+#
+# Security Note:
+# This file contains sensitive credentials. Keep it secure and never commit it to version control.
+# File permissions are set to 600 (read/write owner only) for security.
+`;
+}
+/**
+ * Get template for local environment file.
+ * @returns Template content for ./.env
+ */
+export function getLocalEnvTemplate() {
+    return `# Syrin Project Environment Variables
+# ===========================================
+# Add your API keys and model names here.
+# These will be used when the local config references environment variable names.
+#
+# Example:
+# OPENAI_API_KEY=sk-proj-abc123...
+# OPENAI_MODEL=gpt-4-turbo
+# ANTHROPIC_API_KEY=sk-ant-api03-...
+# ANTHROPIC_MODEL=claude-3-5-sonnet-20241022
+# OLLAMA_MODEL_NAME=llama2
+#
+# Security Note:
+# This file contains sensitive credentials. Keep it secure and never commit it to version control.
+# File permissions are set to 600 (read/write owner only) for security.
+`;
+}
+//# sourceMappingURL=env-templates.js.map

package/dist/config/generator.js

@@ -155,8 +155,25 @@ function buildConfigContent(options) {
     }
     // Replace LLM providers section
     template = template.replace(/\{\{#LLM_PROVIDERS\}\}([\s\S]*?)\{\{\/LLM_PROVIDERS\}\}/, llmSection);
+    // Clean up whitespace
+    template = cleanupYamlWhitespace(template);
     return template;
 }
+/**
+ * Clean up excessive whitespace in generated YAML.
+ * - Removes trailing whitespace from lines
+ * - Collapses 3+ consecutive blank lines into 2
+ * - Ensures file ends with single newline
+ */
+function cleanupYamlWhitespace(content) {
+    return (content
+        // Remove trailing whitespace from each line
+        .replace(/[ \t]+$/gm, '')
+        // Collapse 3+ consecutive newlines into 2 (one blank line)
+        .replace(/\n{3,}/g, '\n\n')
+        // Ensure single newline at end of file
+        .replace(/\n*$/, '\n'));
+}
 /**
  * Build LLM configuration object from init options.
  */