@syrin/cli 1.3.2 → 1.4.0

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.
  */

package/dist/config/global-loader.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Global configuration file loader.
+ * Loads and saves the global syrin.yaml file at ~/.syrin/syrin.yaml
+ */
+import type { GlobalSyrinConfig } from './types.js';
+/**
+ * Get the path to the global Syrin directory.
+ * @returns Absolute path to ~/.syrin/
+ */
+export declare function getGlobalSyrinDir(): string;
+/**
+ * Get the path to the global configuration file.
+ * @returns Absolute path to ~/.syrin/syrin.yaml
+ */
+export declare function getGlobalConfigPath(): string;
+/**
+ * Get the path to the global environment file.
+ * @returns Absolute path to ~/.syrin/.env
+ */
+export declare function getGlobalEnvPath(): string;
+/**
+ * Ensure the global Syrin directory exists.
+ * Creates ~/.syrin/ if it doesn't exist.
+ */
+export declare function ensureGlobalSyrinDir(): void;
+/**
+ * Check if global configuration file exists.
+ * @returns true if global config file exists
+ */
+export declare function globalConfigExists(): boolean;
+/**
+ * Load global configuration from ~/.syrin/syrin.yaml file.
+ * @param skipValidation - If true, skip validation (for editing operations)
+ * @returns Loaded and validated global configuration, or null if file doesn't exist
+ * @throws {ConfigurationError} If config file exists but is invalid
+ */
+export declare function loadGlobalConfig(skipValidation?: boolean): GlobalSyrinConfig | null;
+/**
+ * Save global configuration to ~/.syrin/syrin.yaml file.
+ * @param config - Global configuration to save
+ * @param _skipValidation - Skip validation (for editing operations) - TODO: Implement validation skip logic when needed for future editing operations
+ * @throws {ConfigurationError} If saving fails
+ */
+export declare function saveGlobalConfig(config: GlobalSyrinConfig, _skipValidation?: boolean): void;
+/**
+ * Create a default global configuration.
+ * @returns Default global configuration with system username as agent name
+ */
+export declare function createDefaultGlobalConfig(): GlobalSyrinConfig;
+//# sourceMappingURL=global-loader.d.ts.map

package/dist/config/global-loader.js

@@ -0,0 +1,244 @@
+/**
+ * Global configuration file loader.
+ * Loads and saves the global syrin.yaml file at ~/.syrin/syrin.yaml
+ */
+import * as fs from 'fs';
+import { load, dump } from 'js-yaml';
+import { validateGlobalConfig } from './schema.js';
+import { ConfigurationError } from '../utils/errors.js';
+import { Paths, Messages } from '../constants/index.js';
+import { getDefaultAgentName } from './types.js';
+import { makeSyrinVersion, makeAgentName } from '../types/factories.js';
+/**
+ * Get the path to the global Syrin directory.
+ * @returns Absolute path to ~/.syrin/
+ */
+export function getGlobalSyrinDir() {
+    return Paths.GLOBAL_SYRIN_DIR;
+}
+/**
+ * Get the path to the global configuration file.
+ * @returns Absolute path to ~/.syrin/syrin.yaml
+ */
+export function getGlobalConfigPath() {
+    return Paths.GLOBAL_CONFIG_FILE;
+}
+/**
+ * Get the path to the global environment file.
+ * @returns Absolute path to ~/.syrin/.env
+ */
+export function getGlobalEnvPath() {
+    return Paths.GLOBAL_ENV_FILE;
+}
+/**
+ * Ensure the global Syrin directory exists.
+ * Creates ~/.syrin/ if it doesn't exist.
+ */
+export function ensureGlobalSyrinDir() {
+    const dir = getGlobalSyrinDir();
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+}
+/**
+ * Check if global configuration file exists.
+ * @returns true if global config file exists
+ */
+export function globalConfigExists() {
+    return fs.existsSync(getGlobalConfigPath());
+}
+/**
+ * Load global configuration from ~/.syrin/syrin.yaml file (raw, no validation).
+ * @returns Raw config data, or null if file doesn't exist
+ */
+function loadGlobalConfigRaw() {
+    const configPath = getGlobalConfigPath();
+    if (!fs.existsSync(configPath)) {
+        return null;
+    }
+    try {
+        const configContent = fs.readFileSync(configPath, 'utf-8');
+        const configData = load(configContent);
+        if (!configData || typeof configData !== 'object') {
+            return null;
+        }
+        return configData;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Load global configuration from ~/.syrin/syrin.yaml file.
+ * @param skipValidation - If true, skip validation (for editing operations)
+ * @returns Loaded and validated global configuration, or null if file doesn't exist
+ * @throws {ConfigurationError} If config file exists but is invalid
+ */
+export function loadGlobalConfig(skipValidation = false) {
+    const configPath = getGlobalConfigPath();
+    // Check if config file exists
+    if (!fs.existsSync(configPath)) {
+        return null;
+    }
+    try {
+        // Read and parse YAML file
+        const configContent = fs.readFileSync(configPath, 'utf-8');
+        const configData = load(configContent);
+        if (!configData || typeof configData !== 'object') {
+            throw new ConfigurationError(Messages.ERROR_CONFIG_EMPTY_OR_INVALID, {
+                context: { configPath },
+            });
+        }
+        // Skip validation if requested (for editing operations)
+        if (skipValidation) {
+            const data = configData;
+            // Sanitize version: coerce to string and use makeSyrinVersion or default
+            let version;
+            if (typeof data.version === 'string' && data.version.length > 0) {
+                version = makeSyrinVersion(data.version);
+            }
+            else {
+                version = makeSyrinVersion('1.0');
+            }
+            // Sanitize agent_name: coerce to string and use makeAgentName or default
+            let agent_name;
+            if (typeof data.agent_name === 'string' && data.agent_name.length > 0) {
+                agent_name = makeAgentName(data.agent_name);
+            }
+            else {
+                agent_name = makeAgentName(getDefaultAgentName());
+            }
+            // Sanitize llm: ensure it's an object or fallback to empty object
+            let llm;
+            if (typeof data.llm === 'object' &&
+                data.llm !== null &&
+                !Array.isArray(data.llm)) {
+                llm = data.llm;
+            }
+            else {
+                llm = {};
+            }
+            // Return sanitized structure (not using 'as GlobalSyrinConfig' to avoid unsafe cast)
+            return {
+                version,
+                project_name: 'GlobalSyrin',
+                agent_name,
+                llm,
+            };
+        }
+        // Validate and transform to opaque types
+        const validatedConfig = validateGlobalConfig(configData);
+        return validatedConfig;
+    }
+    catch (error) {
+        if (error instanceof ConfigurationError && !skipValidation) {
+            throw error;
+        }
+        if (skipValidation) {
+            // For editing, return a basic structure even if invalid
+            const raw = loadGlobalConfigRaw();
+            if (raw) {
+                // Sanitize version
+                let version;
+                if (typeof raw.version === 'string' && raw.version.length > 0) {
+                    version = makeSyrinVersion(raw.version);
+                }
+                else {
+                    version = makeSyrinVersion('1.0');
+                }
+                // Sanitize agent_name
+                let agent_name;
+                if (typeof raw.agent_name === 'string' && raw.agent_name.length > 0) {
+                    agent_name = makeAgentName(raw.agent_name);
+                }
+                else {
+                    agent_name = makeAgentName(getDefaultAgentName());
+                }
+                // Sanitize llm
+                let llm;
+                if (typeof raw.llm === 'object' &&
+                    raw.llm !== null &&
+                    !Array.isArray(raw.llm)) {
+                    llm = raw.llm;
+                }
+                else {
+                    llm = {};
+                }
+                return {
+                    version,
+                    project_name: 'GlobalSyrin',
+                    agent_name,
+                    llm,
+                };
+            }
+            return {
+                version: makeSyrinVersion('1.0'),
+                project_name: 'GlobalSyrin',
+                agent_name: makeAgentName(getDefaultAgentName()),
+                llm: {},
+            };
+        }
+        throw new ConfigurationError(`${Messages.ERROR_LOADING_CONFIG}: ${error instanceof Error ? error.message : String(error)}`, {
+            cause: error instanceof Error ? error : new Error(String(error)),
+            context: { configPath },
+        });
+    }
+}
+/**
+ * Save global configuration to ~/.syrin/syrin.yaml file.
+ * @param config - Global configuration to save
+ * @param _skipValidation - Skip validation (for editing operations) - TODO: Implement validation skip logic when needed for future editing operations
+ * @throws {ConfigurationError} If saving fails
+ */
+export function saveGlobalConfig(config, _skipValidation = false) {
+    // TODO: When implementing validation skip, use _skipValidation to bypass
+    // validateGlobalConfig() before saving. Currently always validates.
+    const configPath = getGlobalConfigPath();
+    try {
+        // Ensure directory exists
+        ensureGlobalSyrinDir();
+        // Convert config to plain object for YAML serialization
+        const configObject = {
+            version: config.version,
+            project_name: config.project_name,
+            agent_name: config.agent_name,
+            llm: Object.fromEntries(Object.entries(config.llm).map(([key, provider]) => [
+                key,
+                {
+                    API_KEY: provider.API_KEY,
+                    MODEL_NAME: provider.MODEL_NAME,
+                    default: provider.default,
+                },
+            ])),
+        };
+        // Serialize to YAML
+        const yamlContent = dump(configObject, {
+            indent: 2,
+            lineWidth: 100,
+            quotingType: '"',
+        });
+        // Write to file
+        fs.writeFileSync(configPath, yamlContent, 'utf-8');
+        // Set secure permissions (read/write owner only)
+        fs.chmodSync(configPath, 0o600);
+    }
+    catch (error) {
+        throw new ConfigurationError(`Failed to save global configuration: ${error instanceof Error ? error.message : String(error)}`, {
+            cause: error instanceof Error ? error : new Error(String(error)),
+            context: { configPath },
+        });
+    }
+}
+/**
+ * Create a default global configuration.
+ * @returns Default global configuration with system username as agent name
+ */
+export function createDefaultGlobalConfig() {
+    return {
+        version: makeSyrinVersion('1.0'),
+        project_name: 'GlobalSyrin',
+        agent_name: makeAgentName(getDefaultAgentName()),
+        llm: {},
+    };
+}
+//# sourceMappingURL=global-loader.js.map

package/dist/config/loader.d.ts

@@ -3,6 +3,7 @@
  * Loads and parses the syrin.yaml file.
  */
 import type { SyrinConfig } from './types.js';
+import { type CLIConfigFlags } from './merger.js';
 /**
  * Load configuration from syrin.yaml file.
  * @param projectRoot - Root directory of the project (defaults to current working directory)
@@ -16,4 +17,31 @@ export declare function loadConfig(projectRoot?: string): SyrinConfig;
  * @returns true if config file exists
  */
 export declare function configExists(projectRoot?: string): boolean;
+/**
+ * Load configuration from syrin.yaml file (optional).
+ * Returns null if file doesn't exist instead of throwing.
+ * @param projectRoot - Root directory of the project (defaults to current working directory)
+ * @returns Loaded and validated configuration, or null if file doesn't exist
+ * @throws {ConfigurationError} If config file exists but is invalid
+ */
+export declare function loadConfigOptional(projectRoot?: string): SyrinConfig | null;
+/**
+ * Load configuration with global fallback.
+ * Tries local config first, then global config, then throws error.
+ * @param projectRoot - Root directory of the project (defaults to current working directory)
+ * @param flags - CLI flags that can override config values
+ * @returns Loaded and merged configuration
+ * @throws {Error} If neither local nor global config exists
+ */
+export declare function loadConfigWithGlobal(projectRoot?: string, flags?: CLIConfigFlags): {
+    config: SyrinConfig;
+    source: 'local' | 'global';
+};
+/**
+ * Save local configuration to syrin.yaml file.
+ * @param config - Configuration to save
+ * @param projectRoot - Root directory of the project (defaults to current working directory)
+ * @throws {ConfigurationError} If saving fails
+ */
+export declare function saveLocalConfig(config: SyrinConfig, projectRoot?: string): void;
 //# sourceMappingURL=loader.d.ts.map