fraim-framework 2.0.80 → 2.0.82

package/dist/src/cli/commands/init-project.js

@@ -9,11 +9,36 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const chalk_1 = __importDefault(require("chalk"));
+const prompts_1 = __importDefault(require("prompts"));
 const sync_1 = require("./sync");
 const platform_detection_1 = require("../utils/platform-detection");
 const version_utils_1 = require("../utils/version-utils");
 const ide_detector_1 = require("../setup/ide-detector");
 const codex_local_config_1 = require("../setup/codex-local-config");
+const promptForJiraProjectKey = async (jiraBaseUrl) => {
+    console.log(chalk_1.default.blue('\n🎫 Jira Project Configuration'));
+    console.log(chalk_1.default.gray(`Jira instance: ${jiraBaseUrl}`));
+    console.log(chalk_1.default.gray('Enter the Jira project key for this repository (e.g., TEAM, PROJ, DEV)\n'));
+    const response = await (0, prompts_1.default)({
+        type: 'text',
+        name: 'projectKey',
+        message: 'Jira Project Key:',
+        validate: (value) => {
+            if (!value || value.trim().length === 0) {
+                return 'Project key is required';
+            }
+            if (!/^[A-Z][A-Z0-9]*$/.test(value.trim())) {
+                return 'Project key must start with a letter and contain only uppercase letters and numbers';
+            }
+            return true;
+        }
+    });
+    if (!response.projectKey) {
+        console.log(chalk_1.default.red('\n❌ Jira project key is required for split mode'));
+        process.exit(1);
+    }
+    return response.projectKey.trim().toUpperCase();
+};
 const checkGlobalSetup = () => {
     const fraimUserDir = process.env.FRAIM_USER_DIR || path_1.default.join(os_1.default.homedir(), '.fraim');
     const globalConfigPath = path_1.default.join(fraimUserDir, 'config.json');
@@ -25,7 +50,8 @@ const checkGlobalSetup = () => {
         return {
             exists: true,
             mode: config.mode || 'integrated',
-            tokens: config.tokens || {}
+            tokens: config.tokens || {},
+            jiraConfig: config.jiraConfig
         };
     }
     catch {
@@ -69,25 +95,45 @@ const runInitProject = async () => {
         else {
             const detection = (0, platform_detection_1.detectPlatformFromGit)();
             if (detection.provider !== 'unknown' && detection.repository) {
-                const issueTracking = detection.provider === 'github'
-                    ? {
-                        provider: 'github',
-                        owner: detection.repository.owner,
-                        name: detection.repository.name
-                    }
-                    : detection.provider === 'ado'
+                // Determine issue tracking configuration
+                let issueTracking;
+                // In split mode with Jira configured, use Jira for issue tracking
+                if (preferredMode === 'split' && globalSetup.tokens?.jira && globalSetup.jiraConfig?.baseUrl) {
+                    // Prompt for Jira project key (project-specific)
+                    const projectKey = process.env.FRAIM_JIRA_PROJECT_KEY ||
+                        await promptForJiraProjectKey(globalSetup.jiraConfig.baseUrl);
+                    issueTracking = {
+                        provider: 'jira',
+                        baseUrl: globalSetup.jiraConfig.baseUrl,
+                        projectKey: projectKey,
+                        email: globalSetup.jiraConfig.email
+                    };
+                    console.log(chalk_1.default.blue(`   Code Repository: ${detection.provider.toUpperCase()}`));
+                    console.log(chalk_1.default.blue(`   Issue Tracking: JIRA (${projectKey})`));
+                }
+                else {
+                    // Integrated mode: use same provider for both code and issues
+                    issueTracking = detection.provider === 'github'
                         ? {
-                            provider: 'ado',
-                            organization: detection.repository.organization,
-                            project: detection.repository.project,
+                            provider: 'github',
+                            owner: detection.repository.owner,
                             name: detection.repository.name
                         }
-                        : {
-                            provider: 'gitlab',
-                            namespace: detection.repository.namespace,
-                            name: detection.repository.name,
-                            projectPath: detection.repository.projectPath
-                        };
+                        : detection.provider === 'ado'
+                            ? {
+                                provider: 'ado',
+                                organization: detection.repository.organization,
+                                project: detection.repository.project,
+                                name: detection.repository.name
+                            }
+                            : {
+                                provider: 'gitlab',
+                                namespace: detection.repository.namespace,
+                                name: detection.repository.name,
+                                projectPath: detection.repository.projectPath
+                            };
+                    console.log(chalk_1.default.blue(`   Platform: ${detection.provider.toUpperCase()}`));
+                }
                 config = {
                     version: (0, version_utils_1.getFraimVersion)(),
                     project: {
@@ -97,7 +143,6 @@ const runInitProject = async () => {
                     issueTracking,
                     customizations: {}
                 };
-                console.log(chalk_1.default.blue(`   Platform: ${detection.provider.toUpperCase()}`));
                 if (detection.provider === 'github') {
                     console.log(chalk_1.default.gray(`   Repository: ${detection.repository.owner}/${detection.repository.name}`));
                 }
@@ -132,7 +177,9 @@ const runInitProject = async () => {
             console.log(chalk_1.default.green(`Created .fraim/${dir}`));
         }
     });
-    await (0, sync_1.runSync)({});
+    if (!process.env.FRAIM_SKIP_SYNC) {
+        await (0, sync_1.runSync)({});
+    }
     const codexAvailable = (0, ide_detector_1.detectInstalledIDEs)().some((ide) => ide.configType === 'codex');
     if (codexAvailable) {
         const codexLocalResult = (0, codex_local_config_1.ensureCodexLocalConfig)(projectRoot);

package/dist/src/cli/commands/sync.js

@@ -88,7 +88,7 @@ const runSync = async (options) => {
             skipUpdates: true
         });
         if (result.success) {
-            console.log(chalk_1.default.green(`✅ Successfully synced ${result.workflowsSynced} workflows, ${result.scriptsSynced} scripts, and ${result.coachingSynced} coaching files from local server`));
+            console.log(chalk_1.default.green(`✅ Successfully synced ${result.workflowsSynced} workflows, ${result.scriptsSynced} scripts, ${result.coachingSynced} coaching files, and ${result.docsSynced} docs from local server`));
             return;
         }
         console.error(chalk_1.default.red(`❌ Local sync failed: ${result.error}`));
@@ -119,7 +119,7 @@ const runSync = async (options) => {
         }
         process.exit(1);
     }
-    console.log(chalk_1.default.green(`✅ Successfully synced ${result.workflowsSynced} workflows, ${result.scriptsSynced} scripts, and ${result.coachingSynced} coaching files from remote`));
+    console.log(chalk_1.default.green(`✅ Successfully synced ${result.workflowsSynced} workflows, ${result.scriptsSynced} scripts, ${result.coachingSynced} coaching files, and ${result.docsSynced} docs from remote`));
     // Update version in config.json
     const configPath = path_1.default.join(fraimDir, 'config.json');
     if (fs_1.default.existsSync(configPath)) {

package/dist/src/cli/doctor/check-runner.js

@@ -0,0 +1,196 @@
+"use strict";
+/**
+ * Check runner for FRAIM doctor command
+ * Handles parallel execution, timeouts, and error handling
+ * Issue #144: Enhanced doctor command
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runChecks = runChecks;
+const CHECK_TIMEOUT = 2000; // 2 seconds per check
+const TOTAL_TIMEOUT = 10000; // 10 seconds total
+// Simple logger for doctor command (optional, falls back to no-op)
+const logger = {
+    debug: (...args) => {
+        if (process.env.DEBUG)
+            console.debug('[DOCTOR]', ...args);
+    },
+    info: (...args) => {
+        if (process.env.VERBOSE)
+            console.log('[DOCTOR]', ...args);
+    },
+    warn: (...args) => {
+        console.warn('[DOCTOR]', ...args);
+    },
+    error: (...args) => {
+        console.error('[DOCTOR]', ...args);
+    }
+};
+// Simple metric tracker (no-op for now, can be enhanced later)
+const trackMetric = (name, value) => {
+    if (process.env.DEBUG) {
+        console.debug(`[METRIC] ${name}: ${value}`);
+    }
+};
+/**
+ * Run a single check with timeout
+ */
+async function runCheckWithTimeout(check, timeout = CHECK_TIMEOUT) {
+    const checkStartTime = Date.now();
+    try {
+        logger.debug(`Running check: ${check.name}`, { category: check.category });
+        const result = await Promise.race([
+            check.run(),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout')), timeout))
+        ]);
+        const checkDuration = Date.now() - checkStartTime;
+        logger.debug(`Check completed: ${check.name}`, {
+            status: result.status,
+            duration: checkDuration
+        });
+        return result;
+    }
+    catch (error) {
+        const checkDuration = Date.now() - checkStartTime;
+        if (error.message === 'Timeout') {
+            logger.warn(`Check timed out: ${check.name}`, { duration: checkDuration });
+            return {
+                status: 'warning',
+                message: `${check.name} timed out`,
+                suggestion: 'Check may be slow or unresponsive'
+            };
+        }
+        logger.error(`Check failed: ${check.name}`, { error: error.message, duration: checkDuration });
+        return {
+            status: 'error',
+            message: `${check.name} failed: ${error.message}`,
+            suggestion: 'See error details above',
+            details: { error: error.message }
+        };
+    }
+}
+/**
+ * Filter checks based on command options
+ */
+function filterChecks(checks, options) {
+    // If no specific flags, run all checks
+    if (!options.testMcp && !options.testConfig && !options.testWorkflows) {
+        return checks;
+    }
+    return checks.filter(check => {
+        if (options.testMcp && check.category === 'mcpConnectivity')
+            return true;
+        if (options.testConfig && (check.category === 'globalSetup' || check.category === 'projectSetup' || check.category === 'ideConfiguration'))
+            return true;
+        if (options.testWorkflows && check.category === 'workflows')
+            return true;
+        return false;
+    });
+}
+/**
+ * Run all checks with parallel execution and timeout
+ */
+async function runChecks(checks, options, version) {
+    const startTime = Date.now();
+    // Filter checks based on options
+    const filteredChecks = filterChecks(checks, options);
+    logger.info(`Running ${filteredChecks.length} checks`, {
+        total: checks.length,
+        filtered: filteredChecks.length,
+        options
+    });
+    // Group checks by category for logging
+    const categoryCounts = {};
+    for (const check of filteredChecks) {
+        categoryCounts[check.category] = (categoryCounts[check.category] || 0) + 1;
+    }
+    for (const [category, count] of Object.entries(categoryCounts)) {
+        logger.info(`Category: ${category}`, { checkCount: count });
+    }
+    // Run checks in parallel with overall timeout
+    const checkPromises = filteredChecks.map(check => runCheckWithTimeout(check).then(result => ({ check, result })));
+    let checkResults;
+    try {
+        checkResults = await Promise.race([
+            Promise.all(checkPromises),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('Total timeout exceeded')), TOTAL_TIMEOUT))
+        ]);
+    }
+    catch (error) {
+        logger.error('Total timeout exceeded for all checks');
+        // If total timeout exceeded, return partial results
+        checkResults = [];
+    }
+    // Group results by category
+    const categories = {
+        globalSetup: { checks: [] },
+        projectSetup: { checks: [] },
+        workflows: { checks: [] },
+        ideConfiguration: { checks: [] },
+        mcpConnectivity: { checks: [] },
+        scripts: { checks: [] }
+    };
+    let passed = 0;
+    let warnings = 0;
+    let errors = 0;
+    for (const { check, result } of checkResults) {
+        const categoryResult = {
+            name: check.name,
+            status: result.status,
+            message: result.message,
+            suggestion: result.suggestion,
+            command: result.command,
+            details: result.details,
+            latency: result.latency
+        };
+        categories[check.category].checks.push(categoryResult);
+        if (result.status === 'passed')
+            passed++;
+        else if (result.status === 'warning')
+            warnings++;
+        else if (result.status === 'error')
+            errors++;
+    }
+    const duration = Date.now() - startTime;
+    // Track category durations
+    for (const [category, categoryResult] of Object.entries(categories)) {
+        if (categoryResult.checks.length > 0) {
+            trackMetric(`doctor.category.${category}.duration`, duration);
+            trackMetric(`doctor.category.${category}.checks`, categoryResult.checks.length);
+        }
+    }
+    // Track MCP latencies
+    for (const { result } of checkResults) {
+        if (result.latency !== undefined) {
+            trackMetric('doctor.mcp.latency', result.latency);
+        }
+    }
+    logger.info('All checks completed', {
+        duration,
+        passed,
+        warnings,
+        errors,
+        total: checkResults.length
+    });
+    // Generate suggestions from errors and warnings
+    const suggestions = checkResults
+        .filter(({ result }) => result.status !== 'passed' && result.suggestion)
+        .map(({ result }, index) => ({
+        priority: result.status === 'error' ? index + 1 : index + 100,
+        message: result.suggestion,
+        command: result.command,
+        reason: result.message
+    }))
+        .sort((a, b) => a.priority - b.priority);
+    return {
+        timestamp: new Date().toISOString(),
+        version,
+        summary: {
+            passed,
+            warnings,
+            errors,
+            total: checkResults.length
+        },
+        categories: categories,
+        suggestions: suggestions.length > 0 ? suggestions : undefined
+    };
+}

package/dist/src/cli/doctor/checks/global-setup-checks.js

@@ -0,0 +1,221 @@
+"use strict";
+/**
+ * Global setup checks for FRAIM doctor command
+ * Validates global configuration and API keys
+ * Issue #144: Enhanced doctor command
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGlobalSetupChecks = getGlobalSetupChecks;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const GLOBAL_CONFIG_PATH = path_1.default.join(os_1.default.homedir(), '.fraim', 'config.json');
+/**
+ * Check if global config exists
+ */
+function checkGlobalConfigExists() {
+    return {
+        name: 'Global config exists',
+        category: 'globalSetup',
+        critical: true,
+        run: async () => {
+            if (fs_1.default.existsSync(GLOBAL_CONFIG_PATH)) {
+                return {
+                    status: 'passed',
+                    message: 'Global config exists',
+                    details: { path: GLOBAL_CONFIG_PATH }
+                };
+            }
+            return {
+                status: 'error',
+                message: 'Global config missing',
+                suggestion: 'Run fraim setup to create global configuration',
+                command: 'fraim setup'
+            };
+        }
+    };
+}
+/**
+ * Check if mode is valid
+ */
+function checkModeValid() {
+    return {
+        name: 'Mode valid',
+        category: 'globalSetup',
+        critical: false,
+        run: async () => {
+            try {
+                if (!fs_1.default.existsSync(GLOBAL_CONFIG_PATH)) {
+                    return {
+                        status: 'error',
+                        message: 'Cannot check mode - global config missing'
+                    };
+                }
+                const config = JSON.parse(fs_1.default.readFileSync(GLOBAL_CONFIG_PATH, 'utf8'));
+                const mode = config.mode || 'conversational';
+                const validModes = ['conversational', 'integrated', 'split'];
+                if (validModes.includes(mode)) {
+                    return {
+                        status: 'passed',
+                        message: `Mode: ${mode}`,
+                        details: { mode }
+                    };
+                }
+                return {
+                    status: 'error',
+                    message: `Invalid mode: ${mode}`,
+                    suggestion: 'Mode must be conversational, integrated, or split',
+                    details: { mode, validModes }
+                };
+            }
+            catch (error) {
+                return {
+                    status: 'error',
+                    message: 'Failed to read mode from config',
+                    details: { error: error.message }
+                };
+            }
+        }
+    };
+}
+/**
+ * Check if API key is configured
+ */
+function checkApiKeyConfigured() {
+    return {
+        name: 'API key configured',
+        category: 'globalSetup',
+        critical: false,
+        run: async () => {
+            try {
+                if (!fs_1.default.existsSync(GLOBAL_CONFIG_PATH)) {
+                    return {
+                        status: 'error',
+                        message: 'Cannot check API key - global config missing'
+                    };
+                }
+                const config = JSON.parse(fs_1.default.readFileSync(GLOBAL_CONFIG_PATH, 'utf8'));
+                if (config.apiKey) {
+                    const maskedKey = config.apiKey.substring(0, 10) + '...';
+                    return {
+                        status: 'passed',
+                        message: `API key configured (${maskedKey})`,
+                        details: { keyPrefix: config.apiKey.substring(0, 10) }
+                    };
+                }
+                return {
+                    status: 'warning',
+                    message: 'API key not configured',
+                    suggestion: 'Add apiKey to global config for remote features',
+                    details: { configPath: GLOBAL_CONFIG_PATH }
+                };
+            }
+            catch (error) {
+                return {
+                    status: 'error',
+                    message: 'Failed to read API key from config',
+                    details: { error: error.message }
+                };
+            }
+        }
+    };
+}
+/**
+ * Check if GitHub token is configured
+ */
+function checkGitHubTokenConfigured() {
+    return {
+        name: 'GitHub token configured',
+        category: 'globalSetup',
+        critical: false,
+        run: async () => {
+            try {
+                if (!fs_1.default.existsSync(GLOBAL_CONFIG_PATH)) {
+                    return {
+                        status: 'error',
+                        message: 'Cannot check GitHub token - global config missing'
+                    };
+                }
+                const config = JSON.parse(fs_1.default.readFileSync(GLOBAL_CONFIG_PATH, 'utf8'));
+                // Check if repository provider is GitHub
+                if (config.repository?.provider === 'github') {
+                    // Token would be in IDE MCP configs, not global config
+                    return {
+                        status: 'passed',
+                        message: 'GitHub provider configured',
+                        details: { provider: 'github' }
+                    };
+                }
+                return {
+                    status: 'passed',
+                    message: 'GitHub not configured (not required)',
+                    details: { provider: config.repository?.provider || 'none' }
+                };
+            }
+            catch (error) {
+                return {
+                    status: 'error',
+                    message: 'Failed to check GitHub configuration',
+                    details: { error: error.message }
+                };
+            }
+        }
+    };
+}
+/**
+ * Check if remote URL is configured
+ */
+function checkRemoteUrlConfigured() {
+    return {
+        name: 'Remote URL configured',
+        category: 'globalSetup',
+        critical: false,
+        run: async () => {
+            try {
+                if (!fs_1.default.existsSync(GLOBAL_CONFIG_PATH)) {
+                    return {
+                        status: 'error',
+                        message: 'Cannot check remote URL - global config missing'
+                    };
+                }
+                const config = JSON.parse(fs_1.default.readFileSync(GLOBAL_CONFIG_PATH, 'utf8'));
+                if (config.remoteUrl) {
+                    return {
+                        status: 'passed',
+                        message: `Remote URL: ${config.remoteUrl}`,
+                        details: { remoteUrl: config.remoteUrl }
+                    };
+                }
+                return {
+                    status: 'warning',
+                    message: 'Remote URL not configured',
+                    suggestion: 'Add remoteUrl to global config for remote sync',
+                    command: 'fraim sync',
+                    details: { configPath: GLOBAL_CONFIG_PATH }
+                };
+            }
+            catch (error) {
+                return {
+                    status: 'error',
+                    message: 'Failed to read remote URL from config',
+                    details: { error: error.message }
+                };
+            }
+        }
+    };
+}
+/**
+ * Get all global setup checks
+ */
+function getGlobalSetupChecks() {
+    return [
+        checkGlobalConfigExists(),
+        checkModeValid(),
+        checkApiKeyConfigured(),
+        checkGitHubTokenConfigured(),
+        checkRemoteUrlConfigured()
+    ];
+}