@syrin/cli 1.3.2 → 1.4.1

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

package/dist/config/loader.js

@@ -4,10 +4,12 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
-import { load } from 'js-yaml';
+import { load, dump } from 'js-yaml';
 import { validateConfig } from './schema.js';
 import { ConfigurationError } from '../utils/errors.js';
 import { Paths, Messages, ToolCommands } from '../constants/index.js';
+import { loadGlobalConfig } from './global-loader.js';
+import { mergeConfigs, createConfigFromGlobal, } from './merger.js';
 /**
  * Load configuration from syrin.yaml file.
  * @param projectRoot - Root directory of the project (defaults to current working directory)
@@ -15,13 +17,37 @@ import { Paths, Messages, ToolCommands } from '../constants/index.js';
  * @throws {ConfigurationError} If config file is missing or invalid
  */
 export function loadConfig(projectRoot = process.cwd()) {
-    const configPath = path.join(projectRoot, Paths.CONFIG_FILE);
-    // Check if config file exists
-    if (!fs.existsSync(configPath)) {
+    const config = loadConfigOptional(projectRoot);
+    if (config === null) {
+        const configPath = path.join(projectRoot, Paths.CONFIG_FILE);
         throw new ConfigurationError(Messages.ERROR_CONFIG_NOT_FOUND(ToolCommands.INIT), {
             context: { projectRoot, configPath },
         });
     }
+    return config;
+}
+/**
+ * Check if a configuration file exists.
+ * @param projectRoot - Root directory of the project
+ * @returns true if config file exists
+ */
+export function configExists(projectRoot = process.cwd()) {
+    const configPath = path.join(projectRoot, Paths.CONFIG_FILE);
+    return fs.existsSync(configPath);
+}
+/**
+ * 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 function loadConfigOptional(projectRoot = process.cwd()) {
+    const configPath = path.join(projectRoot, Paths.CONFIG_FILE);
+    // Check if config file exists
+    if (!fs.existsSync(configPath)) {
+        return null;
+    }
     try {
         // Read and parse YAML file
         const configContent = fs.readFileSync(configPath, 'utf-8');
@@ -46,12 +72,72 @@ export function loadConfig(projectRoot = process.cwd()) {
     }
 }
 /**
- * Check if a configuration file exists.
- * @param projectRoot - Root directory of the project
- * @returns true if config file exists
+ * 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 function configExists(projectRoot = process.cwd()) {
+export function loadConfigWithGlobal(projectRoot = process.cwd(), flags = {}) {
+    const localConfig = loadConfigOptional(projectRoot);
+    const globalConfig = loadGlobalConfig();
+    if (localConfig) {
+        return { config: mergeConfigs(localConfig, globalConfig), source: 'local' };
+    }
+    if (globalConfig) {
+        const adaptedConfig = createConfigFromGlobal(globalConfig, flags);
+        return { config: adaptedConfig, source: 'global' };
+    }
+    throw new ConfigurationError(Messages.ERROR_CONFIG_NOT_FOUND(ToolCommands.INIT), {
+        context: { projectRoot },
+    });
+}
+/**
+ * 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 function saveLocalConfig(config, projectRoot = process.cwd()) {
     const configPath = path.join(projectRoot, Paths.CONFIG_FILE);
-    return fs.existsSync(configPath);
+    try {
+        // Convert config to plain object for YAML serialization
+        const configObject = {
+            version: config.version,
+            project_name: config.project_name,
+            agent_name: config.agent_name,
+            transport: config.transport,
+            ...(config.mcp_url ? { mcp_url: config.mcp_url } : {}),
+            ...(config.script ? { script: config.script } : {}),
+            llm: Object.fromEntries(Object.entries(config.llm).map(([key, provider]) => [
+                key,
+                {
+                    ...(provider.API_KEY !== undefined
+                        ? { API_KEY: provider.API_KEY }
+                        : {}),
+                    ...(provider.MODEL_NAME !== undefined
+                        ? { MODEL_NAME: provider.MODEL_NAME }
+                        : {}),
+                    default: provider.default,
+                },
+            ])),
+            ...(config.check ? { check: config.check } : {}),
+        };
+        // Serialize to YAML
+        const yamlContent = dump(configObject, {
+            indent: 2,
+            lineWidth: 100,
+            quotingType: '"',
+        });
+        // Write to file
+        fs.writeFileSync(configPath, yamlContent, 'utf-8');
+    }
+    catch (error) {
+        throw new ConfigurationError(`Failed to save local configuration: ${error instanceof Error ? error.message : String(error)}`, {
+            cause: error instanceof Error ? error : new Error(String(error)),
+            context: { configPath },
+        });
+    }
 }
 //# sourceMappingURL=loader.js.map

package/dist/config/merger.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Configuration merger.
+ * Merges local and global configurations with proper precedence.
+ */
+import type { SyrinConfig, GlobalSyrinConfig } from './types.js';
+/**
+ * CLI flags that can override config values.
+ */
+export interface CLIConfigFlags {
+    /** Transport type override */
+    transport?: 'stdio' | 'http';
+    /** MCP URL override (for http transport) */
+    mcp_url?: string;
+    /** Script command override (for stdio transport) */
+    script?: string;
+    /** LLM provider override */
+    llm?: string;
+}
+/**
+ * Merge local and global configurations.
+ * Local LLM providers override global, but other global providers are kept.
+ * @param local - Local configuration (from ./syrin.yaml) or null
+ * @param global - Global configuration (from ~/.syrin/syrin.yaml) or null
+ * @param flags - CLI flags that override config values
+ * @returns Merged configuration
+ * @throws {Error} If neither local nor global config exists
+ */
+export declare function mergeConfigs(local: SyrinConfig | null, global: GlobalSyrinConfig | null, flags?: CLIConfigFlags): SyrinConfig;
+/**
+ * Create a full SyrinConfig from global config and CLI flags.
+ * @param global - Global configuration
+ * @param flags - CLI flags that provide required fields
+ * @returns Full configuration
+ * @throws {Error} If required fields are missing
+ */
+export declare function createConfigFromGlobal(global: GlobalSyrinConfig, flags?: CLIConfigFlags): SyrinConfig;
+//# sourceMappingURL=merger.d.ts.map

package/dist/config/merger.js

@@ -0,0 +1,68 @@
+/**
+ * Configuration merger.
+ * Merges local and global configurations with proper precedence.
+ */
+import { makeProjectName, makeMCPURL, makeScriptCommand, } from '../types/factories.js';
+/**
+ * Merge local and global configurations.
+ * Local LLM providers override global, but other global providers are kept.
+ * @param local - Local configuration (from ./syrin.yaml) or null
+ * @param global - Global configuration (from ~/.syrin/syrin.yaml) or null
+ * @param flags - CLI flags that override config values
+ * @returns Merged configuration
+ * @throws {Error} If neither local nor global config exists
+ */
+export function mergeConfigs(local, global, flags = {}) {
+    // If local config exists, use it as base and merge LLM providers
+    if (local) {
+        const mergedLLM = {
+            ...(global?.llm || {}), // Start with global LLM providers
+            ...local.llm, // Override with local LLM providers
+        };
+        // Apply CLI flag overrides
+        const finalConfig = {
+            ...local,
+            llm: mergedLLM,
+            transport: flags.transport || local.transport,
+            mcp_url: flags.mcp_url ? makeMCPURL(flags.mcp_url) : local.mcp_url,
+            script: flags.script ? makeScriptCommand(flags.script) : local.script,
+        };
+        return finalConfig;
+    }
+    // No local config - create from global with defaults
+    if (!global) {
+        throw new Error('No configuration found. Create a local config with `syrin init` or set up global config with `syrin init --global`.');
+    }
+    // Create config from global
+    return createConfigFromGlobal(global, flags);
+}
+/**
+ * Create a full SyrinConfig from global config and CLI flags.
+ * @param global - Global configuration
+ * @param flags - CLI flags that provide required fields
+ * @returns Full configuration
+ * @throws {Error} If required fields are missing
+ */
+export function createConfigFromGlobal(global, flags = {}) {
+    // Transport is required - must come from flags
+    if (!flags.transport) {
+        throw new Error('Transport type is required when using global config. Use --transport <stdio|http> flag.');
+    }
+    // Validate transport-specific requirements
+    if (flags.transport === 'http' && !flags.mcp_url) {
+        throw new Error('MCP URL is required for HTTP transport. Use --url <url> flag.');
+    }
+    if (flags.transport === 'stdio' && !flags.script) {
+        throw new Error('Script command is required for stdio transport. Use --script <command> flag.');
+    }
+    return {
+        version: global.version,
+        project_name: makeProjectName('GlobalSyrin'),
+        agent_name: global.agent_name,
+        transport: flags.transport,
+        mcp_url: flags.mcp_url ? makeMCPURL(flags.mcp_url) : undefined,
+        script: flags.script ? makeScriptCommand(flags.script) : undefined,
+        llm: global.llm,
+    };
+}
+//# sourceMappingURL=merger.js.map

package/dist/config/schema.d.ts

@@ -3,7 +3,7 @@
  * Provides runtime validation for the Syrin configuration file.
  */
 import { z } from 'zod';
-import type { SyrinConfig } from '../config/types.js';
+import type { SyrinConfig, GlobalSyrinConfig } from '../config/types.js';
 /**
  * Main configuration schema.
  */
@@ -38,5 +38,30 @@ export declare const ConfigSchema: z.ZodObject<{
  * Type inference from schema.
  */
 export type ConfigSchemaType = z.infer<typeof ConfigSchema>;
+/**
+ * Global configuration schema (LLM settings only).
+ * No transport, mcp_url, or script fields.
+ */
+export declare const GlobalConfigSchema: z.ZodObject<{
+    version: z.ZodString;
+    project_name: z.ZodLiteral<"GlobalSyrin">;
+    agent_name: z.ZodString;
+    llm: z.ZodRecord<z.ZodString, z.ZodObject<{
+        API_KEY: z.ZodOptional<z.ZodString>;
+        MODEL_NAME: z.ZodOptional<z.ZodString>;
+        default: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Type inference from global schema.
+ */
+export type GlobalConfigSchemaType = z.infer<typeof GlobalConfigSchema>;
 export declare function validateConfig(config: unknown): SyrinConfig;
+/**
+ * Validate a global configuration object against the schema.
+ * @param config - Global configuration object to validate
+ * @returns Validated global configuration with opaque types
+ * @throws {ConfigurationError} If validation fails
+ */
+export declare function validateGlobalConfig(config: unknown): GlobalSyrinConfig;
 //# sourceMappingURL=schema.d.ts.map