@syrin/cli 1.3.1 → 1.4.0

package/dist/cli/commands/doctor.js

@@ -2,11 +2,16 @@
  * `syrin doctor` command implementation.
  * Validates the Syrin project configuration and setup.
  */
-import { loadConfig } from '../../config/loader.js';
+import { loadConfigOptional } from '../../config/loader.js';
 import { checkEnvVar, checkCommandExists, extractCommandName, } from '../../config/env-checker.js';
 import { handleCommandError } from '../../cli/utils/index.js';
-import { Messages, TransportTypes, Defaults, LLMProviders } from '../../constants/index.js';
-import { displayDoctorReport } from '../../presentation/doctor-ui.js';
+import { showVersionBanner } from '../../cli/utils/version-banner.js';
+import { Messages, TransportTypes, Defaults, LLMProviders, Paths, } from '../../constants/index.js';
+import { displayDoctorReport, displayGlobalConfigValidation, } from '../../presentation/doctor-ui.js';
+import { loadGlobalConfig, getGlobalConfigPath, getGlobalEnvPath, } from '../../config/global-loader.js';
+import * as path from 'path';
+import * as fs from 'fs';
+import * as os from 'os';
 /**
  * Check transport configuration.
  */
@@ -92,7 +97,7 @@ function checkScript(config) {
 /**
  * Check LLM provider configuration.
  */
-function checkLLMProviders(config, projectRoot) {
+function checkLLMProviders(config, projectRoot, isGlobalContext = false) {
     const checks = [];
     for (const [providerName, providerConfig] of Object.entries(config.llm)) {
         if (providerName === LLMProviders.OLLAMA) {
@@ -106,8 +111,8 @@ function checkLLMProviders(config, projectRoot) {
         const modelVar = providerConfig.MODEL_NAME
             ? String(providerConfig.MODEL_NAME)
             : '';
-        const apiKeyCheck = checkEnvVar(apiKeyVar, projectRoot);
-        const modelCheck = checkEnvVar(modelVar, projectRoot);
+        const apiKeyCheck = checkEnvVar(apiKeyVar, projectRoot, isGlobalContext);
+        const modelCheck = checkEnvVar(modelVar, projectRoot, isGlobalContext);
         checks.push({
             provider: providerName,
             apiKeyCheck: {
@@ -128,6 +133,7 @@ function checkLLMProviders(config, projectRoot) {
                     : modelCheck.errorMessage || Messages.ENV_SET_INSTRUCTIONS(modelVar),
             },
             isDefault: providerConfig.default === true,
+            envSource: apiKeyCheck.source || modelCheck.source,
         });
     }
     return checks;
@@ -135,7 +141,7 @@ function checkLLMProviders(config, projectRoot) {
 /**
  * Check local LLM providers.
  */
-function checkLocalLLMProviders(config, projectRoot) {
+function checkLocalLLMProviders(config, projectRoot, isGlobalContext = false) {
     const checks = [];
     for (const [providerName, providerConfig] of Object.entries(config.llm)) {
         if (providerName === LLMProviders.OLLAMA) {
@@ -143,7 +149,7 @@ function checkLocalLLMProviders(config, projectRoot) {
             const modelVar = providerConfig.MODEL_NAME
                 ? String(providerConfig.MODEL_NAME)
                 : '';
-            const modelCheck = checkEnvVar(modelVar, projectRoot);
+            const modelCheck = checkEnvVar(modelVar, projectRoot, isGlobalContext);
             checks.push({
                 provider: providerName,
                 check: {
@@ -159,12 +165,18 @@ function checkLocalLLMProviders(config, projectRoot) {
 /**
  * Generate doctor report.
  */
-function generateReport(config, projectRoot) {
+function generateReport(config, projectRoot, configSource, configPath) {
+    // Call checkLLMProviders once and reuse the result
+    const llmChecks = checkLLMProviders(config, projectRoot);
+    const envSource = llmChecks[0]?.envSource;
     return {
         config,
+        configSource,
+        configPath,
+        envSource,
         transportCheck: checkTransport(config),
         scriptCheck: checkScript(config),
-        llmChecks: checkLLMProviders(config, projectRoot),
+        llmChecks,
         localLlmChecks: checkLocalLLMProviders(config, projectRoot),
     };
 }
@@ -173,11 +185,35 @@ function generateReport(config, projectRoot) {
  * @param projectRoot - Project root directory (defaults to current working directory)
  */
 export async function executeDoctor(projectRoot = process.cwd()) {
+    await showVersionBanner();
     try {
-        // Load configuration
-        const config = loadConfig(projectRoot);
+        // Try to load local config first
+        const localConfig = loadConfigOptional(projectRoot);
+        const globalConfig = loadGlobalConfig();
+        let config;
+        let configSource;
+        let configPath;
+        if (localConfig) {
+            config = localConfig;
+            configSource = 'local';
+            configPath = path.join(projectRoot, Paths.CONFIG_FILE);
+        }
+        else if (globalConfig) {
+            // Validate global config (including LLM providers)
+            const globalEnvPath = getGlobalEnvPath();
+            const globalEnvExists = fs.existsSync(globalEnvPath);
+            // Run LLM validation for global config (using home directory as project root)
+            const globalProjectRoot = os.homedir();
+            const llmChecks = checkLLMProviders(globalConfig, globalProjectRoot, true);
+            // Display validation results using presentation layer
+            displayGlobalConfigValidation(getGlobalConfigPath(), globalEnvPath, globalEnvExists, llmChecks);
+            return;
+        }
+        else {
+            throw new Error('No configuration found. Create a local config with `syrin init` or set up global config with `syrin init --global`.');
+        }
         // Generate report
-        const report = generateReport(config, projectRoot);
+        const report = generateReport(config, projectRoot, configSource, configPath);
         // Display report using Ink UI
         await displayDoctorReport(report);
         // Exit with appropriate code

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

@@ -7,6 +7,8 @@ export interface InitCommandOptions {
     yes?: boolean;
     /** Project root directory (defaults to current working directory) */
     projectRoot?: string;
+    /** Create global configuration (LLM providers only) */
+    global?: boolean;
 }
 /**
  * Execute the init command.

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