@syrin/cli 1.3.2 → 1.4.1

package/dist/config/schema.js

@@ -5,6 +5,20 @@
 import { z } from 'zod';
 import { ConfigurationError } from '../utils/errors.js';
 import { makeProjectName, makeAgentName, makeMCPURL, makeAPIKey, makeModelName, makeScriptCommand, makeSyrinVersion, } from '../types/factories.js';
+/**
+ * Helper function to check if at least one LLM provider is set as default.
+ * @param llm - Record of LLM provider configurations
+ * @returns true if at least one provider has default === true
+ */
+function hasDefaultLLMProvider(llm) {
+    const providers = Object.values(llm);
+    return providers.some(provider => {
+        return (provider &&
+            typeof provider === 'object' &&
+            'default' in provider &&
+            provider.default === true);
+    });
+}
 /**
  * Schema for LLM provider configuration.
  */
@@ -86,14 +100,26 @@ export const ConfigSchema = z
     message: 'script is required when transport is "stdio"',
     path: ['script'],
 })
-    .refine(data => {
-    // At least one LLM provider should be set as default
-    const providers = Object.values(data.llm);
-    const hasDefault = providers.some(provider => {
-        return (provider && typeof provider === 'object' && provider.default === true);
-    });
-    return hasDefault;
-}, {
+    .refine(data => hasDefaultLLMProvider(data.llm), {
+    message: 'At least one LLM provider must be set as default',
+    path: ['llm'],
+});
+/**
+ * Global configuration schema (LLM settings only).
+ * No transport, mcp_url, or script fields.
+ */
+export const GlobalConfigSchema = z
+    .object({
+    version: z.string().min(1, 'Version is required'),
+    project_name: z.literal('GlobalSyrin'),
+    agent_name: z.string().min(1, 'Agent name is required'),
+    llm: z
+        .record(z.string(), LLMProviderSchema)
+        .refine(obj => Object.keys(obj).length > 0, {
+        message: 'At least one LLM provider is required',
+    }),
+})
+    .refine(data => hasDefaultLLMProvider(data.llm), {
     message: 'At least one LLM provider must be set as default',
     path: ['llm'],
 });
@@ -178,4 +204,43 @@ export function validateConfig(config) {
         throw error;
     }
 }
+/**
+ * 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 function validateGlobalConfig(config) {
+    try {
+        const parsed = GlobalConfigSchema.parse(config);
+        // Transform to opaque types
+        // Note: project_name must be literal 'GlobalSyrin' for global config
+        const validated = {
+            version: makeSyrinVersion(parsed.version),
+            project_name: 'GlobalSyrin',
+            agent_name: makeAgentName(parsed.agent_name),
+            llm: Object.fromEntries(Object.entries(parsed.llm).map(([key, provider]) => [
+                key,
+                {
+                    API_KEY: provider.API_KEY
+                        ? makeAPIKey(provider.API_KEY)
+                        : undefined,
+                    MODEL_NAME: provider.MODEL_NAME
+                        ? makeModelName(provider.MODEL_NAME)
+                        : undefined,
+                    default: provider.default,
+                },
+            ])),
+        };
+        return validated;
+    }
+    catch (error) {
+        if (error instanceof z.ZodError) {
+            throw new ConfigurationError(formatValidationError(error), {
+                context: { errors: error.issues },
+            });
+        }
+        throw error;
+    }
+}
 //# sourceMappingURL=schema.js.map

package/dist/config/types.d.ts

@@ -50,6 +50,25 @@ export interface SyrinConfig {
     /** Tool testing configuration (v1.3.0) */
     check?: CheckConfig;
 }
+/**
+ * Global Syrin configuration (LLM settings only).
+ * Stored at ~/.syrin/syrin.yaml
+ */
+export interface GlobalSyrinConfig {
+    /** Configuration version */
+    version: SyrinVersion;
+    /** Project name (always "GlobalSyrin") */
+    project_name: 'GlobalSyrin';
+    /** Agent name (defaults to system username, can be customized) */
+    agent_name: AgentName;
+    /** LLM provider configurations */
+    llm: Record<string, LLMProviderConfig>;
+}
+/**
+ * Get default agent name from system.
+ * Tries: process.env.USER -> process.env.USERNAME -> os.userInfo().username -> 'Syrin'
+ */
+export declare function getDefaultAgentName(): string;
 /**
  * Options for initializing a new Syrin project.
  */

package/dist/config/types.js

@@ -2,5 +2,30 @@
  * Configuration type definitions for Syrin.
  * These types represent the structure of the syrin.yaml file.
  */
-export {};
+import * as os from 'os';
+/**
+ * Get default agent name from system.
+ * Tries: process.env.USER -> process.env.USERNAME -> os.userInfo().username -> 'Syrin'
+ */
+export function getDefaultAgentName() {
+    // Try process.env first (safest)
+    if (process.env.USER) {
+        return process.env.USER;
+    }
+    if (process.env.USERNAME) {
+        return process.env.USERNAME;
+    }
+    // Try os.userInfo() with error handling (can throw on some platforms)
+    try {
+        const username = os.userInfo().username;
+        if (username) {
+            return username;
+        }
+    }
+    catch {
+        // Swallow any exceptions from os.userInfo()
+    }
+    // Fallback to default
+    return 'Syrin';
+}
 //# sourceMappingURL=types.js.map

package/dist/constants/messages.d.ts

@@ -17,6 +17,13 @@ export declare const Messages: {
     readonly INIT_SETUP_ENV_VARS: "Set up your environment variables (API keys, etc.)";
     readonly INIT_RUN_DOCTOR: (doctorCommand: string) => string;
     readonly INIT_RUN_DEV: (devCommand: string) => string;
+    readonly GLOBAL_INIT_ALREADY_INITIALIZED: "Global Syrin configuration already exists!";
+    readonly GLOBAL_INIT_CONFIG_FILE: (configPath: string) => string;
+    readonly GLOBAL_INIT_SUCCESS: "Global Syrin configuration created successfully!";
+    readonly GLOBAL_INIT_EDIT_CONFIG: "Run `syrin config edit --global` to edit the configuration";
+    readonly GLOBAL_INIT_EDIT_ENV: "Run `syrin config edit-env --global` to set API keys";
+    readonly GLOBAL_INIT_REINITIALIZE_TIP: "Want to re-initialize?";
+    readonly GLOBAL_INIT_REINITIALIZE_INSTRUCTION: "Delete ~/.syrin/syrin.yaml and run `syrin init --global` again.";
     readonly ERROR_UNEXPECTED: "An unexpected error occurred";
     readonly ERROR_LOADING_CONFIG: "Failed to load configuration file";
     readonly ERROR_VALIDATION_FAILED: "Configuration validation failed";

package/dist/constants/messages.js

@@ -19,6 +19,14 @@ export const Messages = {
     INIT_SETUP_ENV_VARS: 'Set up your environment variables (API keys, etc.)',
     INIT_RUN_DOCTOR: (doctorCommand) => `Run \`${doctorCommand}\` to verify your Syrin setup`,
     INIT_RUN_DEV: (devCommand) => `Run \`${devCommand}\` to start development mode`,
+    // Global Init Command Messages
+    GLOBAL_INIT_ALREADY_INITIALIZED: 'Global Syrin configuration already exists!',
+    GLOBAL_INIT_CONFIG_FILE: (configPath) => `Configuration file: ${configPath}`,
+    GLOBAL_INIT_SUCCESS: 'Global Syrin configuration created successfully!',
+    GLOBAL_INIT_EDIT_CONFIG: 'Run `syrin config edit --global` to edit the configuration',
+    GLOBAL_INIT_EDIT_ENV: 'Run `syrin config edit-env --global` to set API keys',
+    GLOBAL_INIT_REINITIALIZE_TIP: 'Want to re-initialize?',
+    GLOBAL_INIT_REINITIALIZE_INSTRUCTION: 'Delete ~/.syrin/syrin.yaml and run `syrin init --global` again.',
     // Error Messages
     ERROR_UNEXPECTED: 'An unexpected error occurred',
     ERROR_LOADING_CONFIG: 'Failed to load configuration file',

package/dist/constants/paths.d.ts

@@ -19,6 +19,12 @@ export declare const Paths: {
     readonly DEV_HISTORY_FILE: ".syrin/.dev-history";
     /** Data directory for JSON exports (relative to project root) */
     readonly DATA_DIR: ".syrin/data";
+    /** Global Syrin configuration directory (absolute path) */
+    readonly GLOBAL_SYRIN_DIR: string;
+    /** Global configuration file (absolute path) - derived from GLOBAL_SYRIN_DIR */
+    readonly GLOBAL_CONFIG_FILE: string;
+    /** Global environment file (absolute path) - derived from GLOBAL_SYRIN_DIR */
+    readonly GLOBAL_ENV_FILE: string;
 };
 /**
  * File extension constants.

package/dist/constants/paths.js

@@ -2,6 +2,10 @@
  * File and directory path constants.
  * Centralized paths used throughout the application.
  */
+import * as os from 'os';
+import * as path from 'path';
+// Compute global directory once
+const GLOBAL_SYRIN_DIR = path.join(os.homedir(), '.syrin');
 export const Paths = {
     /** Syrin configuration directory name */
     SYRIN_DIR: '.syrin',
@@ -19,6 +23,12 @@ export const Paths = {
     DEV_HISTORY_FILE: '.syrin/.dev-history',
     /** Data directory for JSON exports (relative to project root) */
     DATA_DIR: '.syrin/data',
+    /** Global Syrin configuration directory (absolute path) */
+    GLOBAL_SYRIN_DIR,
+    /** Global configuration file (absolute path) - derived from GLOBAL_SYRIN_DIR */
+    GLOBAL_CONFIG_FILE: path.join(GLOBAL_SYRIN_DIR, 'syrin.yaml'),
+    /** Global environment file (absolute path) - derived from GLOBAL_SYRIN_DIR */
+    GLOBAL_ENV_FILE: path.join(GLOBAL_SYRIN_DIR, '.env'),
 };
 /**
  * File extension constants.

package/dist/events/emitter.js

@@ -1,5 +1,5 @@
 import { makeEventID, makeTimestamp } from '../types/factories.js';
-import { logger } from '../utils/logger.js';
+import { log } from '../utils/logger.js';
 import { EventStoreError } from '../utils/errors.js';
 /**
  * Runtime event emitter implementation.
@@ -37,7 +37,7 @@ export class RuntimeEventEmitter {
             if (appendResult instanceof Promise) {
                 return appendResult
                     .then(() => {
-                    logger.debug(`Event emitted: ${eventType}`, {
+                    log.debug(`Event emitted: ${eventType}`, {
                         event_id: event.event_id,
                         sequence: event.sequence,
                     });
@@ -47,7 +47,7 @@ export class RuntimeEventEmitter {
                 })
                     .catch((error) => {
                     const err = error instanceof Error ? error : new Error(String(error));
-                    logger.error('Failed to persist event', err, {
+                    log.error(`Error: ${err.message}`, err, {
                         event_id: event.event_id,
                         event_type: eventType,
                     });
@@ -59,7 +59,7 @@ export class RuntimeEventEmitter {
                 });
             }
             // Sync store
-            logger.debug(`Event emitted: ${eventType}`, {
+            log.debug(`Event emitted: ${eventType}`, {
                 event_id: event.event_id,
                 sequence: event.sequence,
             });
@@ -69,7 +69,7 @@ export class RuntimeEventEmitter {
         }
         catch (error) {
             const err = error instanceof Error ? error : new Error(String(error));
-            logger.error('Failed to emit event', err, {
+            log.error(`Error: ${err.message}`, err, {
                 event_id: event.event_id,
                 event_type: eventType,
             });
@@ -119,7 +119,7 @@ export class RuntimeEventEmitter {
                 if (result instanceof Promise) {
                     result.catch((error) => {
                         const err = error instanceof Error ? error : new Error(String(error));
-                        logger.error('Error in event subscriber', err, {
+                        log.error(`Error: ${err.message}`, err, {
                             event_id: event.event_id,
                             event_type: event.event_type,
                         });
@@ -128,7 +128,7 @@ export class RuntimeEventEmitter {
             }
             catch (error) {
                 const err = error instanceof Error ? error : new Error(String(error));
-                logger.error('Error in event subscriber', err, {
+                log.error(`Error: ${err.message}`, err, {
                     event_id: event.event_id,
                     event_type: event.event_type,
                 });

package/dist/presentation/config-ui.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Presentation layer for config command UI.
+ * Separates display logic from business logic.
+ */
+import type { SyrinConfig, GlobalSyrinConfig } from '../config/types.js';
+/**
+ * Display configuration list/show output.
+ */
+export declare function displayConfigList(config: SyrinConfig | GlobalSyrinConfig, context: 'local' | 'global', configPath: string): void;
+/**
+ * Display success message for config update.
+ */
+export declare function displayConfigUpdated(key: string, value: string, context: 'local' | 'global', configPath: string): void;
+/**
+ * Display message for opening editor.
+ */
+export declare function displayEditorOpening(context: 'local' | 'global', filePath: string, editorName: string): void;
+/**
+ * Display message after editor closes.
+ */
+export declare function displayEditorClosed(fileType: 'config' | 'env'): void;
+/**
+ * Display setup completion message.
+ */
+export declare function displaySetupComplete(isGlobal: boolean): void;
+/**
+ * Display default provider set message.
+ */
+export declare function displayDefaultProviderSet(provider: string, context: 'local' | 'global'): void;
+/**
+ * Display provider removed message.
+ */
+export declare function displayProviderRemoved(provider: string, context: 'local' | 'global'): void;
+//# sourceMappingURL=config-ui.d.ts.map

package/dist/presentation/config-ui.js

@@ -0,0 +1,139 @@
+/**
+ * Presentation layer for config command UI.
+ * Separates display logic from business logic.
+ */
+import { log } from '../utils/logger.js';
+import { Icons } from '../constants/index.js';
+import { getGlobalConfigPath } from '../config/global-loader.js';
+/**
+ * Mask an API key to show only first 4 and last 4 characters.
+ */
+function maskApiKey(apiKey) {
+    if (!apiKey || apiKey.length <= 8) {
+        return '****';
+    }
+    // If it looks like an env var reference (e.g., OPENAI_API_KEY), don't mask
+    if (/^[A-Z][A-Z0-9_]*$/.test(apiKey)) {
+        return apiKey;
+    }
+    return `${apiKey.slice(0, 4)}...${apiKey.slice(-4)}`;
+}
+/**
+ * Display configuration list/show output.
+ */
+export function displayConfigList(config, context, configPath) {
+    log.blank();
+    log.heading(`${context === 'local' ? 'Local' : 'Global'} Configuration`);
+    log.blank();
+    log.labelValue(`${Icons.FOLDER} Path`, configPath);
+    log.blank();
+    if (context === 'local' && 'transport' in config) {
+        log.heading('Project Settings');
+        log.labelValue('  project_name', String(config.project_name));
+        log.labelValue('  agent_name', String(config.agent_name));
+        log.labelValue('  transport', config.transport);
+        if (config.mcp_url) {
+            log.labelValue('  mcp_url', String(config.mcp_url));
+        }
+        if (config.script) {
+            log.labelValue('  script', String(config.script));
+        }
+        log.blank();
+    }
+    log.heading('LLM Providers');
+    const providers = Object.entries(config.llm);
+    if (providers.length === 0) {
+        log.plain('  No providers configured');
+    }
+    else {
+        for (const [provider, settings] of providers) {
+            const isDefault = settings.default || false;
+            const defaultMarker = isDefault ? ' (default)' : '';
+            log.label(`  ${provider}${defaultMarker}`);
+            if (settings.API_KEY) {
+                log.labelValue('    API_KEY', maskApiKey(String(settings.API_KEY)));
+            }
+            if (settings.MODEL_NAME) {
+                log.labelValue('    MODEL_NAME', String(settings.MODEL_NAME));
+            }
+        }
+    }
+    log.blank();
+}
+/**
+ * Display success message for config update.
+ */
+export function displayConfigUpdated(key, value, context, configPath) {
+    log.blank();
+    log.success(`${Icons.CHECK} Configuration updated successfully`);
+    log.blank();
+    log.labelValue('  Key', key);
+    log.labelValue('  Value', value);
+    log.labelValue('  Config', `${context} (${configPath})`);
+    log.blank();
+}
+/**
+ * Display message for opening editor.
+ */
+export function displayEditorOpening(context, filePath, editorName) {
+    log.blank();
+    log.info(`Opening ${context} config in editor...`);
+    log.labelValue(`  ${Icons.FOLDER} File`, filePath);
+    log.labelValue(`  ${Icons.DOCUMENT} Editor`, editorName);
+    log.blank();
+}
+/**
+ * Display message after editor closes.
+ */
+export function displayEditorClosed(fileType) {
+    log.blank();
+    if (fileType === 'config') {
+        log.success(`Config file updated`);
+        log.blank();
+        log.info(`Run \`syrin doctor\` to validate your changes`);
+    }
+    else {
+        log.success(`${Icons.CHECK} Environment file updated`);
+    }
+    log.blank();
+}
+/**
+ * Display setup completion message.
+ */
+export function displaySetupComplete(isGlobal) {
+    log.blank();
+    if (isGlobal) {
+        log.success(`${Icons.CHECK} Global configuration created`);
+        log.blank();
+        log.labelValue(`  ${Icons.FOLDER} Config`, getGlobalConfigPath());
+        log.blank();
+        log.info(`${Icons.DOCUMENT} Next steps:`);
+        log.plain('  1. Set your API keys in ~/.syrin/.env or as environment variables');
+        log.plain('  2. Run `syrin config edit-env --global` to edit the environment file');
+        log.plain('  3. Run `syrin doctor` to validate your setup');
+    }
+    log.blank();
+}
+/**
+ * Display default provider set message.
+ */
+export function displayDefaultProviderSet(provider, context) {
+    log.blank();
+    log.success(`${Icons.CHECK} Default provider updated`);
+    log.blank();
+    log.labelValue('  Provider', provider);
+    log.labelValue('  Config', context);
+    log.blank();
+}
+/**
+ * Display provider removed message.
+ */
+export function displayProviderRemoved(provider, context) {
+    log.blank();
+    log.success(`${Icons.CHECK} Provider removed`);
+    log.blank();
+    log.labelValue('  Provider', provider);
+    log.labelValue('  Config', context);
+    log.blank();
+}
+//# sourceMappingURL=config-ui.js.map

package/dist/presentation/doctor-ui.d.ts

@@ -17,6 +17,9 @@ interface DoctorReport {
         mcp_url?: unknown;
         script?: unknown;
     };
+    configSource?: 'local' | 'global';
+    configPath?: string;
+    envSource?: 'local.env' | 'global.env' | 'process.env';
     transportCheck: CheckResult;
     scriptCheck: CheckResult | null;
     llmChecks: Array<{
@@ -31,6 +34,14 @@ interface DoctorReport {
         modelName?: string;
     }>;
 }
+/**
+ * Display global config validation results.
+ */
+export declare function displayGlobalConfigValidation(globalConfigPath: string, globalEnvPath: string, globalEnvExists: boolean, llmChecks: Array<{
+    provider: string;
+    apiKeyCheck: CheckResult;
+    modelCheck: CheckResult;
+}>): void;
 /**
  * Display doctor report using plain console output.
  * This avoids Ink taking control of stdin, which disables terminal history.

package/dist/presentation/doctor-ui.js

@@ -1,11 +1,49 @@
 import { getVersionDisplayString } from '../utils/version-display.js';
 import { log } from '../utils/logger.js';
+/**
+ * Display global config validation results.
+ */
+export function displayGlobalConfigValidation(globalConfigPath, globalEnvPath, globalEnvExists, llmChecks) {
+    log.blank();
+    log.heading('Validating Syrin configuration...');
+    log.blank();
+    log.label('No local config found at ./syrin.yaml');
+    log.label('Using global configuration...');
+    log.blank();
+    log.labelValue('Global Config:', globalConfigPath);
+    if (globalEnvExists) {
+        log.labelValue('Global Environment:', globalEnvPath);
+    }
+    else {
+        log.labelValue('Global Environment:', `${globalEnvPath} (not found)`);
+    }
+    log.blank();
+    const hasErrors = llmChecks.some(check => !check.apiKeyCheck.isValid || !check.modelCheck.isValid);
+    if (hasErrors) {
+        log.heading('Global configuration has issues:');
+        log.blank();
+        for (const check of llmChecks) {
+            if (!check.apiKeyCheck.isValid) {
+                log.plain(`  • ${check.provider} API Key: ${check.apiKeyCheck.fix || 'Missing'}`);
+            }
+            if (!check.modelCheck.isValid) {
+                log.plain(`  • ${check.provider} Model: ${check.modelCheck.fix || 'Missing'}`);
+            }
+        }
+        log.blank();
+    }
+    else {
+        log.success('Global configuration is valid!');
+        log.label('To create a local config, run: syrin init');
+        log.blank();
+    }
+}
 /**
  * Display doctor report using plain console output.
  * This avoids Ink taking control of stdin, which disables terminal history.
  */
 export async function displayDoctorReport(report) {
-    const { config, transportCheck, scriptCheck, llmChecks, localLlmChecks } = report;
+    const { config, configSource, configPath, envSource, transportCheck, scriptCheck, llmChecks, localLlmChecks, } = report;
     const allValid = transportCheck.isValid &&
         (scriptCheck === null || scriptCheck.isValid) &&
         llmChecks.every(l => l.apiKeyCheck.isValid && l.modelCheck.isValid) &&
@@ -19,6 +57,19 @@ export async function displayDoctorReport(report) {
     log.label('═══════════════════');
     log.labelValue('Version:', versionDisplayString);
     log.blank();
+    // Config Source Info
+    if (configSource && configPath) {
+        log.labelValue(`${configSource === 'local' ? 'Local' : 'Global'} Config:`, configPath);
+        if (envSource) {
+            const envSourceLabel = envSource === 'local.env'
+                ? 'Local project .env file'
+                : envSource === 'global.env'
+                    ? 'Global .env file'
+                    : 'process.env';
+            log.labelValue('Environment Source:', envSourceLabel);
+        }
+        log.blank();
+    }
     // Project Info
     log.labelValue('Project:', String(config.project_name));
     log.labelValue('Agent:', String(config.agent_name));

package/dist/presentation/init-ui.d.ts

@@ -11,4 +11,13 @@ export declare function displayAlreadyInitialized(): void;
  * @param configPath - Path to the created config file
  */
 export declare function displayInitSuccess(configPath: string): void;
+/**
+ * Display the "global already initialized" message.
+ */
+export declare function displayGlobalAlreadyInitialized(): void;
+/**
+ * Display the global initialization success message.
+ * @param configPath - Path to the created global config file
+ */
+export declare function displayGlobalInitSuccess(configPath: string): void;
 //# sourceMappingURL=init-ui.d.ts.map

package/dist/presentation/init-ui.js

@@ -38,4 +38,37 @@ export function displayInitSuccess(configPath) {
     log.plain(`   4. ${Messages.INIT_RUN_DEV(ToolCommands.DEV)}`);
     log.blank();
 }
+/**
+ * Display the "global already initialized" message.
+ */
+export function displayGlobalAlreadyInitialized() {
+    log.blank();
+    log.warning(`  ${Messages.GLOBAL_INIT_ALREADY_INITIALIZED}`);
+    log.blank();
+    log.plain(`${Icons.FOLDER} ${Messages.GLOBAL_INIT_CONFIG_FILE(Paths.GLOBAL_CONFIG_FILE)}`);
+    log.blank();
+    log.plain(`${Icons.DOCUMENT} ${Messages.INIT_NEXT_STEPS_HEADER}`);
+    log.plain(`   ${Messages.GLOBAL_INIT_EDIT_CONFIG}`);
+    log.plain(`   ${Messages.GLOBAL_INIT_EDIT_ENV}`);
+    log.blank();
+    log.info(Messages.GLOBAL_INIT_REINITIALIZE_TIP);
+    log.plain(`   ${Messages.GLOBAL_INIT_REINITIALIZE_INSTRUCTION}`);
+    log.blank();
+}
+/**
+ * Display the global initialization success message.
+ * @param configPath - Path to the created global config file
+ */
+export function displayGlobalInitSuccess(configPath) {
+    log.blank();
+    log.success(`${Icons.CHECK} ${Messages.GLOBAL_INIT_SUCCESS}`);
+    log.blank();
+    log.plain(`${Icons.FOLDER} Configuration file: ${configPath}`);
+    log.blank();
+    log.plain(`${Icons.DOCUMENT} ${Messages.INIT_NEXT_STEPS_HEADER}`);
+    log.plain(`   1. Set your API keys in ~/.syrin/.env or as environment variables`);
+    log.plain(`   2. Run \`syrin config edit-env --global\` to edit the environment file`);
+    log.plain(`   3. ${Messages.INIT_RUN_DOCTOR(ToolCommands.DOCTOR)}`);
+    log.blank();
+}
 //# sourceMappingURL=init-ui.js.map

package/dist/runtime/analysis/analyser.js

@@ -7,7 +7,7 @@ import { normalizeTools } from './normalizer.js';
 import { buildIndexes } from './indexer.js';
 import { inferDependencies } from './dependencies.js';
 import { ALL_RULES } from './rules/index.js';
-import { logger } from '../../utils/logger.js';
+import { log } from '../../utils/logger.js';
 /**
  * Analyze MCP tools and return diagnostics.
  * Executes all registered rules.
@@ -32,7 +32,7 @@ function runRules(tools, dependencies, indexes) {
         }
         catch (error) {
             // If a rule fails, log error but don't crash the analysis
-            logger.error(`Rule ${rule.id} failed`, error instanceof Error ? error : new Error(String(error)), {
+            log.error(`Rule ${rule.id} failed`, error instanceof Error ? error : new Error(String(error)), {
                 ruleId: rule.id,
                 ruleName: rule.ruleName,
             });

package/dist/runtime/analysis/rules/warnings/w104-generic-description.d.ts

@@ -42,7 +42,7 @@ declare class W104GenericDescriptionRule extends BaseRule {
  *
  * @example
  * ```ts
- * import { createW104Rule, DEFAULT_CONCRETE_NOUNS } from './w005-generic-description.js';
+ * import { createW104Rule, DEFAULT_CONCRETE_NOUNS } from './w005-generic-description';
  * const customNouns = [...DEFAULT_CONCRETE_NOUNS, 'invoice', 'report'];
  * const customRule = createW104Rule(customNouns);
  * ```

package/dist/runtime/analysis/rules/warnings/w104-generic-description.js

@@ -96,7 +96,7 @@ class W104GenericDescriptionRule extends BaseRule {
  *
  * @example
  * ```ts
- * import { createW104Rule, DEFAULT_CONCRETE_NOUNS } from './w005-generic-description.js';
+ * import { createW104Rule, DEFAULT_CONCRETE_NOUNS } from './w005-generic-description';
  * const customNouns = [...DEFAULT_CONCRETE_NOUNS, 'invoice', 'report'];
  * const customRule = createW104Rule(customNouns);
  * ```