@syrin/cli 1.3.2 → 1.4.1

package/dist/cli/commands/init.js

@@ -3,19 +3,26 @@
  * Initializes a new Syrin project with configuration.
  */
 import { generateConfigFile, isProjectInitialized } from '../../config/generator.js';
-import { promptInitOptions, getDefaultInitOptions, } from '../../cli/prompts/init-prompt.js';
+import { promptInitOptions, getDefaultInitOptions, promptGlobalInitOptions, getDefaultGlobalInitOptions, } from '../../cli/prompts/init-prompt.js';
 import { ConfigurationError } from '../../utils/errors.js';
-import { logger } from '../../utils/logger.js';
+import { log } from '../../utils/logger.js';
 import { Messages, Paths } from '../../constants/index.js';
 import { ensureGitignorePattern } from '../../utils/gitignore.js';
-import { displayAlreadyInitialized, displayInitSuccess, } from '../../presentation/init-ui.js';
+import { displayAlreadyInitialized, displayInitSuccess, displayGlobalAlreadyInitialized, displayGlobalInitSuccess, } from '../../presentation/init-ui.js';
 import { showVersionBanner } from '../../cli/utils/version-banner.js';
+import { globalConfigExists, saveGlobalConfig, getGlobalConfigPath, } from '../../config/global-loader.js';
+import { makeSyrinVersion, makeAPIKey, makeModelName } from '../../types/factories.js';
 /**
  * Execute the init command.
  * @param options - Command options
  */
 export async function executeInit(options = {}) {
     await showVersionBanner();
+    // Handle global init
+    if (options.global) {
+        await executeGlobalInit(options);
+        return;
+    }
     const projectRoot = options.projectRoot || process.cwd();
     // Check if project is already initialized
     if (isProjectInitialized(projectRoot)) {
@@ -26,19 +33,19 @@ export async function executeInit(options = {}) {
     let initOptions;
     if (options.yes) {
         // Non-interactive mode: use defaults
-        logger.info('Initializing project with default values (non-interactive mode)');
+        log.info('Initializing project with default values (non-interactive mode)');
         initOptions = getDefaultInitOptions(projectRoot);
     }
     else {
         // Interactive mode: prompt user
-        logger.info('Starting interactive project initialization');
+        log.info('Starting interactive project initialization');
         try {
             initOptions = await promptInitOptions();
         }
         catch (error) {
             if (error instanceof Error && error.name === 'ExitPromptError') {
                 // User cancelled
-                logger.info('Initialization cancelled by user');
+                log.info('Initialization cancelled by user');
                 process.exit(0);
             }
             throw error;
@@ -47,31 +54,25 @@ export async function executeInit(options = {}) {
     try {
         // Generate config file
         const configPath = generateConfigFile(initOptions, projectRoot);
-        logger.info('Configuration file created successfully', {
-            configPath,
-            projectName: initOptions.projectName,
-            transport: initOptions.transport,
-        });
+        log.info(`Configuration file created successfully: ${configPath}`);
         // Update .gitignore to exclude event files and dev history
         try {
             const eventsPatternAdded = await ensureGitignorePattern(projectRoot, Paths.EVENTS_DIR);
             if (eventsPatternAdded) {
-                logger.info(`Added ${Paths.EVENTS_DIR} to .gitignore`);
+                log.info(`Added ${Paths.EVENTS_DIR} to .gitignore`);
             }
             const historyPatternAdded = await ensureGitignorePattern(projectRoot, Paths.DEV_HISTORY_FILE);
             if (historyPatternAdded) {
-                logger.info('Added .syrin/.dev-history to .gitignore');
+                log.info('Added .syrin/.dev-history to .gitignore');
             }
             const dataPatternAdded = await ensureGitignorePattern(projectRoot, Paths.DATA_DIR);
             if (dataPatternAdded) {
-                logger.info(`Added ${Paths.DATA_DIR} to .gitignore`);
+                log.info(`Added ${Paths.DATA_DIR} to .gitignore`);
             }
         }
         catch (error) {
             // Log but don't fail initialization if .gitignore update fails
-            logger.warn('Failed to update .gitignore', {
-                error: error instanceof Error ? error.message : String(error),
-            });
+            log.warn(`Failed to update .gitignore: ${error instanceof Error ? error.message : String(error)}`);
         }
         // Display success message
         displayInitSuccess(configPath);
@@ -83,7 +84,77 @@ export async function executeInit(options = {}) {
                 cause: error instanceof Error ? error : new Error(String(error)),
                 context: { projectRoot },
             });
-        logger.error('Failed to initialize project', configError);
+        log.error(`Error: ${configError.message}`);
+        throw configError;
+    }
+}
+/**
+ * Execute global init command (LLM providers only).
+ * Creates ~/.syrin/syrin.yaml with LLM configuration.
+ * @param options - Command options
+ */
+async function executeGlobalInit(options) {
+    // Check if global config already exists
+    if (globalConfigExists()) {
+        displayGlobalAlreadyInitialized();
+        return;
+    }
+    let globalOptions;
+    if (options.yes) {
+        // Non-interactive mode: use defaults
+        log.info('Initializing global config with default values (non-interactive mode)');
+        globalOptions = getDefaultGlobalInitOptions();
+    }
+    else {
+        // Interactive mode: prompt user
+        log.info('Starting interactive global initialization');
+        try {
+            globalOptions = await promptGlobalInitOptions();
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'ExitPromptError') {
+                // User cancelled
+                log.info('Global initialization cancelled by user');
+                process.exit(0);
+            }
+            throw error;
+        }
+    }
+    try {
+        // Build GlobalSyrinConfig
+        const llmConfig = {};
+        for (const [provider, settings] of Object.entries(globalOptions.llmProviders)) {
+            llmConfig[provider] = {
+                ...('apiKey' in settings && settings.apiKey
+                    ? { API_KEY: makeAPIKey(String(settings.apiKey)) }
+                    : {}),
+                ...(settings.modelName
+                    ? { MODEL_NAME: makeModelName(String(settings.modelName)) }
+                    : {}),
+                default: settings.default || false,
+            };
+        }
+        const globalConfig = {
+            version: makeSyrinVersion('1.0'),
+            project_name: 'GlobalSyrin',
+            agent_name: globalOptions.agentName,
+            llm: llmConfig,
+        };
+        // Save global config
+        saveGlobalConfig(globalConfig);
+        const configPath = getGlobalConfigPath();
+        log.info(`Global configuration file created successfully: ${configPath}`);
+        // Display success message
+        displayGlobalInitSuccess(configPath);
+    }
+    catch (error) {
+        const configError = error instanceof ConfigurationError
+            ? error
+            : new ConfigurationError(Messages.ERROR_GENERATE_CONFIG, {
+                cause: error instanceof Error ? error : new Error(String(error)),
+                context: { type: 'global' },
+            });
+        log.error(`Error: ${configError.message}`);
         throw configError;
     }
 }

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

@@ -0,0 +1,10 @@
+/**
+ * `syrin status` command implementation.
+ * Shows a quick overview of project health (like `git status`).
+ */
+/**
+ * Execute the status command.
+ * @param projectRoot - Project root directory (defaults to current working directory)
+ */
+export declare function executeStatus(projectRoot?: string): Promise<void>;
+//# sourceMappingURL=status.d.ts.map

package/dist/cli/commands/status.js

@@ -0,0 +1,162 @@
+/**
+ * `syrin status` command implementation.
+ * Shows a quick overview of project health (like `git status`).
+ */
+import * as path from 'path';
+import * as fs from 'fs';
+import { loadConfigOptional } from '../../config/loader.js';
+import { loadGlobalConfig, getGlobalConfigPath } from '../../config/global-loader.js';
+import { checkEnvVar } from '../../config/env-checker.js';
+import { handleCommandError } from '../../cli/utils/index.js';
+import { showVersionBanner } from '../../cli/utils/version-banner.js';
+import { log } from '../../utils/logger.js';
+import { Paths, LLMProviders, Icons } from '../../constants/index.js';
+/**
+ * Generate status report.
+ */
+function generateStatusReport(projectRoot) {
+    const localConfig = loadConfigOptional(projectRoot);
+    const globalConfig = loadGlobalConfig();
+    const localEnvPath = path.join(projectRoot, Paths.ENV_FILE);
+    const hasLocalEnv = fs.existsSync(localEnvPath);
+    const report = {
+        hasLocalConfig: !!localConfig,
+        hasGlobalConfig: !!globalConfig,
+        llmProviders: [],
+        hasEnvFile: hasLocalEnv,
+        envFilePath: hasLocalEnv ? localEnvPath : undefined,
+    };
+    const config = localConfig || globalConfig;
+    if (!config) {
+        return report;
+    }
+    if (localConfig) {
+        report.configPath = path.join(projectRoot, Paths.CONFIG_FILE);
+        report.projectName = String(localConfig.project_name);
+        report.transport = String(localConfig.transport);
+        report.mcpUrl = localConfig.mcp_url
+            ? String(localConfig.mcp_url)
+            : undefined;
+        report.script = localConfig.script ? String(localConfig.script) : undefined;
+    }
+    else if (globalConfig) {
+        report.configPath = getGlobalConfigPath();
+    }
+    // Check LLM providers
+    for (const [providerName, providerConfig] of Object.entries(config.llm)) {
+        let isConfigured = false;
+        if (providerName === LLMProviders.OLLAMA) {
+            // Ollama only needs MODEL_NAME
+            if (providerConfig.MODEL_NAME) {
+                const modelCheck = checkEnvVar(String(providerConfig.MODEL_NAME), projectRoot);
+                isConfigured = modelCheck.isSet;
+            }
+        }
+        else {
+            // Cloud providers need API_KEY
+            if (providerConfig.API_KEY) {
+                const apiKeyCheck = checkEnvVar(String(providerConfig.API_KEY), projectRoot);
+                isConfigured = apiKeyCheck.isSet;
+            }
+        }
+        report.llmProviders.push({
+            name: providerName,
+            isDefault: providerConfig.default === true,
+            isConfigured,
+        });
+    }
+    return report;
+}
+/**
+ * Display status report.
+ */
+function displayStatusReport(report) {
+    log.blank();
+    // Configuration Status
+    log.heading('Configuration');
+    log.plain('─'.repeat(40));
+    if (report.hasLocalConfig) {
+        log.plain(`  ${Icons.SUCCESS} Local config:  ${report.configPath}`);
+    }
+    else {
+        log.plain(`  ${Icons.FAILURE} Local config:  Not found`);
+    }
+    if (report.hasGlobalConfig) {
+        const globalPath = getGlobalConfigPath();
+        log.plain(`  ${Icons.SUCCESS} Global config: ${globalPath}`);
+    }
+    else {
+        log.plain(`  ${log.styleText('○', 'dim')} Global config: Not configured`);
+    }
+    log.blank();
+    // Project Info (if local config exists)
+    if (report.hasLocalConfig && report.projectName) {
+        log.heading('Project');
+        log.plain('─'.repeat(40));
+        log.plain(`  Name:      ${report.projectName}`);
+        log.plain(`  Transport: ${report.transport}`);
+        if (report.mcpUrl) {
+            log.plain(`  MCP URL:   ${report.mcpUrl}`);
+        }
+        if (report.script) {
+            log.plain(`  Script:    ${report.script}`);
+        }
+        log.blank();
+    }
+    // LLM Providers
+    if (report.llmProviders.length > 0) {
+        log.heading('LLM Providers');
+        log.plain('─'.repeat(40));
+        for (const provider of report.llmProviders) {
+            const icon = provider.isConfigured ? Icons.SUCCESS : Icons.FAILURE;
+            const defaultLabel = provider.isDefault
+                ? log.styleText(' (default)', 'cyan')
+                : '';
+            const status = provider.isConfigured
+                ? log.styleText('configured', 'green')
+                : log.styleText('not configured', 'red');
+            log.plain(`  ${icon} ${provider.name}${defaultLabel}: ${status}`);
+        }
+        log.blank();
+    }
+    // Environment
+    log.heading('Environment');
+    log.plain('─'.repeat(40));
+    if (report.hasEnvFile) {
+        log.plain(`  ${Icons.SUCCESS} .env file: ${report.envFilePath}`);
+    }
+    else {
+        log.plain(`  ${log.styleText('○', 'dim')} .env file: Not found (optional)`);
+    }
+    log.blank();
+    // Quick Actions
+    const hasIssues = !report.hasLocalConfig && !report.hasGlobalConfig;
+    const hasUnconfiguredProviders = report.llmProviders.some(p => !p.isConfigured);
+    if (hasIssues || hasUnconfiguredProviders) {
+        log.heading('Suggested Actions');
+        log.plain('─'.repeat(40));
+        if (!report.hasLocalConfig && !report.hasGlobalConfig) {
+            log.plain(`  ${Icons.TIP} Run ${log.styleText('syrin init', 'cyan')} to initialize a project`);
+        }
+        if (hasUnconfiguredProviders) {
+            log.plain(`  ${Icons.TIP} Run ${log.styleText('syrin doctor', 'cyan')} for detailed diagnostics`);
+            log.plain(`  ${Icons.TIP} Run ${log.styleText('syrin config edit-env', 'cyan')} to set API keys`);
+        }
+        log.blank();
+    }
+}
+/**
+ * Execute the status command.
+ * @param projectRoot - Project root directory (defaults to current working directory)
+ */
+export async function executeStatus(projectRoot = process.cwd()) {
+    await showVersionBanner();
+    try {
+        const report = generateStatusReport(projectRoot);
+        displayStatusReport(report);
+    }
+    catch (error) {
+        handleCommandError(error);
+    }
+}
+//# sourceMappingURL=status.js.map

package/dist/cli/index.js

@@ -11,7 +11,9 @@ import { executeAnalyse } from '../cli/commands/analyse.js';
 import { executeDev } from '../cli/commands/dev.js';
 import { executeUpdate } from '../cli/commands/update.js';
 import { executeRollback } from '../cli/commands/rollback.js';
-import { logger, log } from '../utils/logger.js';
+import { executeStatus } from '../cli/commands/status.js';
+import { executeConfigSet, executeConfigGet, executeConfigList, executeConfigShow, executeConfigEdit, executeConfigEditEnv, executeConfigSetDefault, executeConfigRemove, } from '../cli/commands/config.js';
+import { log, setQuietMode, setVerboseMode } from '../utils/logger.js';
 import { Messages, ListTypes } from '../constants/index.js';
 import { getCurrentVersion } from '../utils/version-checker.js';
 /**
@@ -19,7 +21,6 @@ import { getCurrentVersion } from '../utils/version-checker.js';
  * Logs full error to internal logger and concise message to user.
  */
 function reportAnalyseError(error) {
-    logger.error('Analyse command failed', error);
     log.error(`Analyse command failed: ${error.message}`);
 }
 const program = new Command();
@@ -32,29 +33,46 @@ export function setupCLI() {
     program
         .name('syrin')
         .description('Syrin - Runtime intelligence system for MCP servers')
-        .version(currentVersion, '-v, --version', 'Display version number');
+        .version(currentVersion, '-v, --version', 'Display version number')
+        .option('-q, --quiet', 'Minimal output (errors only)')
+        .option('--verbose', 'Verbose output for debugging')
+        .hook('preAction', (_thisCommand, actionCommand) => {
+        const opts = actionCommand.optsWithGlobals();
+        if (opts.quiet) {
+            setQuietMode(true);
+        }
+        if (opts.verbose) {
+            setVerboseMode(true);
+        }
+    })
+        .addHelpText('after', '\nAliases:\n' +
+        '  ls        Alias for list\n' +
+        '  doc       Alias for doctor\n' +
+        '  cfg       Alias for config');
     // init command
     program
         .command('init')
         .description('Initialize a new Syrin project')
         .option('-y, --yes', 'Skip interactive prompts and use default values')
         .option('--project-root <path>', 'Project root directory (defaults to current directory)')
+        .option('--global', 'Create global configuration (LLM providers only)')
         .action(async (options) => {
         try {
             await executeInit({
                 yes: options.yes || false,
                 projectRoot: options.projectRoot,
+                global: options.global || false,
             });
         }
         catch (error) {
             // Handle ALREADY_INITIALIZED case first with early return
-            if (error instanceof Error && error.message === 'ALREADY_INITIALIZED') {
+            if (error instanceof Error &&
+                error.message === 'ALREADY_INITIALIZED') {
                 // Already handled in executeInit, just exit
                 return;
             }
             // Handle other Error cases
             if (error instanceof Error) {
-                logger.error('Init command failed', error);
                 log.blank();
                 log.error(`Error: ${error.message}`);
                 log.blank();
@@ -67,6 +85,7 @@ export function setupCLI() {
     // doctor command
     program
         .command('doctor')
+        .alias('doc')
         .description('Validate Syrin project configuration and setup')
         .option('--project-root <path>', 'Project root directory (defaults to current directory)')
         .action(async (options) => {
@@ -76,8 +95,9 @@ export function setupCLI() {
         catch (error) {
             // Error handling is done in executeDoctor, this is a safety net
             if (error instanceof Error) {
-                logger.error('Doctor command failed', error);
+                log.error(`Error: ${error.message}`);
             }
+            process.exit(1);
         }
     });
     // test command
@@ -171,13 +191,15 @@ export function setupCLI() {
         catch (error) {
             // Error handling is done in executeTest
             if (error instanceof Error) {
-                logger.error('Test command failed', error);
+                log.error(`Error: ${error.message}`);
+                process.exit(1);
             }
         }
     });
     // list command
     program
         .command('list')
+        .alias('ls')
         .description('List tools, resources, or prompts from an MCP server')
         .argument('[type]', `Type to list: ${ListTypes.TOOLS}, ${ListTypes.RESOURCES}, or ${ListTypes.PROMPTS} (default: ${ListTypes.TOOLS})`, ListTypes.TOOLS)
         .option('--transport <type>', 'Transport type (http or stdio). If not provided, uses transport from config.yaml')
@@ -216,7 +238,8 @@ export function setupCLI() {
         catch (error) {
             // Error handling is done in executeList
             if (error instanceof Error) {
-                logger.error('List command failed', error);
+                log.error(`Error: ${error.message}`);
+                process.exit(1);
             }
         }
     });
@@ -273,6 +296,9 @@ export function setupCLI() {
         .option('--save-events', 'Save events to file for debugging')
         .option('--event-file <path>', 'Directory path for event files (default: .syrin/events). Events are saved as {sessionId}.jsonl')
         .option('--run-script', 'Run script to spawn server internally. If not provided, stdio uses script automatically, http connects to existing server')
+        .option('--transport <type>', 'Transport type (stdio or http). Required when using global config.')
+        .option('--url <url>', 'MCP server URL (required for http transport when using global config)')
+        .option('--script <command>', 'Script command to run MCP server (required for stdio transport when using global config)')
         .action(async (options) => {
         try {
             await executeDev({
@@ -282,12 +308,16 @@ export function setupCLI() {
                 saveEvents: options.saveEvents || false,
                 eventFile: options.eventFile,
                 runScript: options.runScript || false,
+                transport: options.transport,
+                url: options.url,
+                script: options.script,
             });
         }
         catch (error) {
             // Error handling is done in executeDev
             if (error instanceof Error) {
-                logger.error('Dev command failed', error);
+                log.error(`Error: ${error.message}`);
+                process.exit(1);
             }
         }
     });
@@ -302,7 +332,8 @@ export function setupCLI() {
         catch (error) {
             // Error handling is done in executeUpdate
             if (error instanceof Error) {
-                logger.error('Update command failed', error);
+                log.error(`Error: ${error.message}`);
+                process.exit(1);
             }
         }
     });
@@ -318,10 +349,178 @@ export function setupCLI() {
         catch (error) {
             // Error handling is done in executeRollback
             if (error instanceof Error) {
-                logger.error('Rollback command failed', error);
+                log.error(`Error: ${error.message}`);
+                process.exit(1);
+            }
+        }
+    });
+    // status command
+    program
+        .command('status')
+        .description('Show project health overview (config, LLM, MCP connection)')
+        .option('--project-root <path>', 'Project root directory (defaults to current directory)')
+        .action(async (options) => {
+        try {
+            await executeStatus(options.projectRoot);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                log.error(`Error: ${error.message}`);
+                process.exit(1);
             }
         }
     });
+    // config command
+    const configCommand = program
+        .command('config')
+        .alias('cfg')
+        .description('Manage Syrin configuration (local or global)');
+    // config set
+    configCommand
+        .command('set')
+        .description('Set a configuration value')
+        .argument('<key>', 'Configuration key (e.g., "openai.model", "agent_name")')
+        .argument('<value>', 'Value to set')
+        .option('--global', 'Operate on global config')
+        .option('--local', 'Operate on local config')
+        .action(async (key, value, options) => {
+        try {
+            await executeConfigSet(key, value, options);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                log.error(`Error: ${error.message}`);
+            }
+            process.exit(1);
+        }
+    });
+    // config get
+    configCommand
+        .command('get')
+        .description('Get a configuration value')
+        .argument('<key>', 'Configuration key')
+        .option('--global', 'Operate on global config')
+        .option('--local', 'Operate on local config')
+        .action(async (key, options) => {
+        try {
+            await executeConfigGet(key, options);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                log.error(`Error: ${error.message}`);
+            }
+            process.exit(1);
+        }
+    });
+    // config list
+    configCommand
+        .command('list')
+        .description('List all configuration values')
+        .option('--global', 'Operate on global config')
+        .option('--local', 'Operate on local config')
+        .action(async (options) => {
+        try {
+            await executeConfigList(options);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                log.error(`Error: ${error.message}`);
+            }
+            process.exit(1);
+        }
+    });
+    // config show
+    configCommand
+        .command('show')
+        .description('Show full configuration')
+        .option('--global', 'Operate on global config')
+        .option('--local', 'Operate on local config')
+        .action(async (options) => {
+        try {
+            await executeConfigShow(options);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                log.error(`Error: ${error.message}`);
+            }
+            process.exit(1);
+        }
+    });
+    // config edit
+    configCommand
+        .command('edit')
+        .description('Edit configuration file in editor')
+        .option('--global', 'Operate on global config')
+        .option('--local', 'Operate on local config')
+        .action(async (options) => {
+        try {
+            await executeConfigEdit(options);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                log.error(`Error: ${error.message}`);
+            }
+            process.exit(1);
+        }
+    });
+    // config edit-env
+    configCommand
+        .command('edit-env')
+        .description('Edit environment file in editor')
+        .option('--global', 'Operate on global config')
+        .option('--local', 'Operate on local config')
+        .action(async (options) => {
+        try {
+            await executeConfigEditEnv(options);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                log.error(`Error: ${error.message}`);
+            }
+            process.exit(1);
+        }
+    });
+    // config set-default
+    configCommand
+        .command('set-default')
+        .description('Set default LLM provider')
+        .argument('<provider>', 'LLM provider name (e.g., openai, claude)')
+        .option('--global', 'Operate on global config')
+        .option('--local', 'Operate on local config')
+        .action(async (provider, options) => {
+        try {
+            await executeConfigSetDefault(provider, options);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                log.error(`Error: ${error.message}`);
+            }
+            process.exit(1);
+        }
+    });
+    // config remove
+    configCommand
+        .command('remove')
+        .description('Remove an LLM provider from configuration')
+        .argument('<provider>', 'LLM provider name to remove')
+        .option('--global', 'Operate on global config')
+        .option('--local', 'Operate on local config')
+        .action(async (provider, options) => {
+        try {
+            await executeConfigRemove(provider, options);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                log.error(`Error: ${error.message}`);
+            }
+            process.exit(1);
+        }
+    });
+    // Handle no command provided - show help and exit with 0
+    if (process.argv.length <= 2) {
+        program.outputHelp();
+        process.exit(0);
+    }
     // Parse command line arguments
     program.parse();
 }
@@ -334,7 +533,7 @@ export function run() {
     }
     catch (error) {
         const err = error instanceof Error ? error : new Error(String(error));
-        logger.error('CLI setup failed', err);
+        log.error(`Error: ${err.message}`);
         log.error(Messages.CLI_START_FAILED);
         process.exit(1);
     }