fraim-framework 2.0.81 → 2.0.82

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

@@ -0,0 +1,282 @@
+"use strict";
+/**
+ * Project setup checks for FRAIM doctor command
+ * Validates project configuration and initialization
+ * 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.getProjectSetupChecks = getProjectSetupChecks;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+/**
+ * Check if project is initialized
+ */
+function checkProjectInitialized() {
+    return {
+        name: 'Project initialized',
+        category: 'projectSetup',
+        critical: true,
+        run: async () => {
+            const fraimDir = path_1.default.join(process.cwd(), '.fraim');
+            if (fs_1.default.existsSync(fraimDir)) {
+                return {
+                    status: 'passed',
+                    message: 'Project initialized',
+                    details: { path: fraimDir }
+                };
+            }
+            return {
+                status: 'error',
+                message: 'Project not initialized',
+                suggestion: 'Initialize project with fraim init-project',
+                command: 'fraim init-project'
+            };
+        }
+    };
+}
+/**
+ * Check if project config is valid
+ */
+function checkProjectConfigValid() {
+    return {
+        name: 'Project config valid',
+        category: 'projectSetup',
+        critical: true,
+        run: async () => {
+            const configPath = path_1.default.join(process.cwd(), '.fraim', 'config.json');
+            if (!fs_1.default.existsSync(configPath)) {
+                return {
+                    status: 'error',
+                    message: 'Project config missing',
+                    suggestion: 'Initialize project with fraim init-project',
+                    command: 'fraim init-project'
+                };
+            }
+            try {
+                const config = JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+                if (!config.project || !config.project.name) {
+                    return {
+                        status: 'warning',
+                        message: 'Project config incomplete',
+                        suggestion: 'Add project name to .fraim/config.json'
+                    };
+                }
+                return {
+                    status: 'passed',
+                    message: 'Project config valid',
+                    details: { projectName: config.project.name }
+                };
+            }
+            catch (error) {
+                return {
+                    status: 'error',
+                    message: 'Project config corrupted',
+                    suggestion: 'Fix JSON syntax in .fraim/config.json',
+                    details: { error: error.message }
+                };
+            }
+        }
+    };
+}
+/**
+ * Check if git remote is detected
+ */
+function checkGitRemoteDetected() {
+    return {
+        name: 'Git remote detected',
+        category: 'projectSetup',
+        critical: false,
+        run: async () => {
+            try {
+                const remote = (0, child_process_1.execSync)('git remote get-url origin', {
+                    encoding: 'utf8',
+                    stdio: ['pipe', 'pipe', 'pipe']
+                }).trim();
+                if (remote) {
+                    return {
+                        status: 'passed',
+                        message: `Git remote: ${remote}`,
+                        details: { remote }
+                    };
+                }
+                return {
+                    status: 'warning',
+                    message: 'No git remote configured',
+                    suggestion: 'Add git remote with: git remote add origin <url>'
+                };
+            }
+            catch (error) {
+                return {
+                    status: 'warning',
+                    message: 'Not a git repository',
+                    suggestion: 'Initialize git with: git init',
+                    details: { error: error.message }
+                };
+            }
+        }
+    };
+}
+/**
+ * Check if repository provider matches config
+ */
+function checkProviderMatches() {
+    return {
+        name: 'Repository provider matches',
+        category: 'projectSetup',
+        critical: false,
+        run: async () => {
+            const configPath = path_1.default.join(process.cwd(), '.fraim', 'config.json');
+            if (!fs_1.default.existsSync(configPath)) {
+                return {
+                    status: 'error',
+                    message: 'Cannot check provider - config missing'
+                };
+            }
+            try {
+                const config = JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+                if (!config.repository?.provider) {
+                    return {
+                        status: 'passed',
+                        message: 'No repository provider configured (conversational mode)',
+                        details: { mode: config.mode || 'conversational' }
+                    };
+                }
+                // Try to get git remote
+                try {
+                    const remote = (0, child_process_1.execSync)('git remote get-url origin', {
+                        encoding: 'utf8',
+                        stdio: ['pipe', 'pipe', 'pipe']
+                    }).trim();
+                    const provider = config.repository.provider;
+                    const remoteMatches = remote.includes(provider);
+                    if (remoteMatches) {
+                        return {
+                            status: 'passed',
+                            message: `Repository provider: ${provider}`,
+                            details: { provider, remote }
+                        };
+                    }
+                    return {
+                        status: 'warning',
+                        message: `Provider mismatch: config says ${provider} but remote is ${remote}`,
+                        suggestion: 'Update repository.provider in .fraim/config.json'
+                    };
+                }
+                catch {
+                    return {
+                        status: 'warning',
+                        message: 'Cannot verify provider - no git remote',
+                        details: { configuredProvider: config.repository.provider }
+                    };
+                }
+            }
+            catch (error) {
+                return {
+                    status: 'error',
+                    message: 'Failed to check provider',
+                    details: { error: error.message }
+                };
+            }
+        }
+    };
+}
+/**
+ * Check if config matches mode
+ */
+function checkConfigMatchesMode() {
+    return {
+        name: 'Config matches mode',
+        category: 'projectSetup',
+        critical: false,
+        run: async () => {
+            const configPath = path_1.default.join(process.cwd(), '.fraim', 'config.json');
+            if (!fs_1.default.existsSync(configPath)) {
+                return {
+                    status: 'error',
+                    message: 'Cannot check mode - config missing'
+                };
+            }
+            try {
+                const config = JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+                const mode = config.mode || 'conversational';
+                if (mode === 'conversational') {
+                    // No repository or issue tracking required
+                    return {
+                        status: 'passed',
+                        message: 'Conversational mode (no platform required)',
+                        details: { mode }
+                    };
+                }
+                if (mode === 'integrated') {
+                    // Repository required, issue tracking should match
+                    if (!config.repository?.provider) {
+                        return {
+                            status: 'error',
+                            message: 'Integrated mode requires repository configuration',
+                            suggestion: 'Add repository config to .fraim/config.json'
+                        };
+                    }
+                    return {
+                        status: 'passed',
+                        message: 'Integrated mode configured',
+                        details: { mode, provider: config.repository.provider }
+                    };
+                }
+                if (mode === 'split') {
+                    // Both repository and issue tracking required
+                    if (!config.repository?.provider) {
+                        return {
+                            status: 'error',
+                            message: 'Split mode requires repository configuration',
+                            suggestion: 'Add repository config to .fraim/config.json'
+                        };
+                    }
+                    if (!config.issueTracking?.provider) {
+                        return {
+                            status: 'error',
+                            message: 'Split mode requires issue tracking configuration',
+                            suggestion: 'Add issueTracking config to .fraim/config.json'
+                        };
+                    }
+                    return {
+                        status: 'passed',
+                        message: 'Split mode configured',
+                        details: {
+                            mode,
+                            repository: config.repository.provider,
+                            issueTracking: config.issueTracking.provider
+                        }
+                    };
+                }
+                return {
+                    status: 'error',
+                    message: `Unknown mode: ${mode}`,
+                    suggestion: 'Mode must be conversational, integrated, or split'
+                };
+            }
+            catch (error) {
+                return {
+                    status: 'error',
+                    message: 'Failed to check mode configuration',
+                    details: { error: error.message }
+                };
+            }
+        }
+    };
+}
+/**
+ * Get all project setup checks
+ */
+function getProjectSetupChecks() {
+    return [
+        checkProjectInitialized(),
+        checkProjectConfigValid(),
+        checkGitRemoteDetected(),
+        checkProviderMatches(),
+        checkConfigMatchesMode()
+    ];
+}

package/dist/src/cli/doctor/checks/scripts-checks.js

@@ -0,0 +1,157 @@
+"use strict";
+/**
+ * Scripts checks for FRAIM doctor command
+ * Validates user scripts directory and sync status
+ * 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.getScriptsChecks = getScriptsChecks;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const SCRIPTS_DIR = path_1.default.join(os_1.default.homedir(), '.fraim', 'scripts');
+/**
+ * Check if scripts directory exists
+ */
+function checkScriptsDirectoryExists() {
+    return {
+        name: 'Scripts directory exists',
+        category: 'scripts',
+        critical: false,
+        run: async () => {
+            if (fs_1.default.existsSync(SCRIPTS_DIR)) {
+                return {
+                    status: 'passed',
+                    message: 'Scripts directory exists',
+                    details: { path: SCRIPTS_DIR }
+                };
+            }
+            return {
+                status: 'warning',
+                message: 'Scripts directory missing',
+                suggestion: 'Run fraim sync to create scripts directory',
+                command: 'fraim sync'
+            };
+        }
+    };
+}
+/**
+ * Check if scripts are synced
+ */
+function checkScriptsSynced() {
+    return {
+        name: 'Scripts synced',
+        category: 'scripts',
+        critical: false,
+        run: async () => {
+            if (!fs_1.default.existsSync(SCRIPTS_DIR)) {
+                return {
+                    status: 'warning',
+                    message: 'Cannot check scripts - directory missing'
+                };
+            }
+            try {
+                const scripts = fs_1.default.readdirSync(SCRIPTS_DIR).filter(f => f.endsWith('.js') || f.endsWith('.ts') || f.endsWith('.sh'));
+                if (scripts.length > 0) {
+                    return {
+                        status: 'passed',
+                        message: `${scripts.length} scripts synced`,
+                        details: { scriptCount: scripts.length }
+                    };
+                }
+                return {
+                    status: 'warning',
+                    message: 'No scripts found',
+                    suggestion: 'Run fraim sync to fetch scripts',
+                    command: 'fraim sync'
+                };
+            }
+            catch (error) {
+                return {
+                    status: 'error',
+                    message: 'Failed to check scripts',
+                    details: { error: error.message }
+                };
+            }
+        }
+    };
+}
+/**
+ * Check if scripts are executable (Unix/Linux/macOS only)
+ */
+function checkScriptsExecutable() {
+    return {
+        name: 'Scripts executable',
+        category: 'scripts',
+        critical: false,
+        run: async () => {
+            // Skip on Windows
+            if (process.platform === 'win32') {
+                return {
+                    status: 'passed',
+                    message: 'Script permissions not applicable on Windows',
+                    details: { platform: 'win32' }
+                };
+            }
+            if (!fs_1.default.existsSync(SCRIPTS_DIR)) {
+                return {
+                    status: 'warning',
+                    message: 'Cannot check permissions - directory missing'
+                };
+            }
+            try {
+                const scripts = fs_1.default.readdirSync(SCRIPTS_DIR).filter(f => f.endsWith('.sh'));
+                if (scripts.length === 0) {
+                    return {
+                        status: 'passed',
+                        message: 'No shell scripts to check',
+                        details: { scriptCount: 0 }
+                    };
+                }
+                let nonExecutable = 0;
+                for (const script of scripts) {
+                    const scriptPath = path_1.default.join(SCRIPTS_DIR, script);
+                    const stats = fs_1.default.statSync(scriptPath);
+                    // Check if executable bit is set (mode & 0o111)
+                    if ((stats.mode & 0o111) === 0) {
+                        nonExecutable++;
+                    }
+                }
+                if (nonExecutable === 0) {
+                    return {
+                        status: 'passed',
+                        message: `All ${scripts.length} shell scripts executable`,
+                        details: { scriptCount: scripts.length }
+                    };
+                }
+                return {
+                    status: 'warning',
+                    message: `${nonExecutable} scripts not executable`,
+                    suggestion: `Run: chmod +x ${SCRIPTS_DIR}/*.sh`,
+                    command: `chmod +x ${SCRIPTS_DIR}/*.sh`,
+                    details: { nonExecutable, total: scripts.length }
+                };
+            }
+            catch (error) {
+                return {
+                    status: 'error',
+                    message: 'Failed to check script permissions',
+                    details: { error: error.message }
+                };
+            }
+        }
+    };
+}
+/**
+ * Get all scripts checks
+ */
+function getScriptsChecks() {
+    return [
+        checkScriptsDirectoryExists(),
+        checkScriptsSynced(),
+        checkScriptsExecutable()
+    ];
+}

package/dist/src/cli/doctor/checks/workflow-checks.js

@@ -0,0 +1,247 @@
+"use strict";
+/**
+ * Workflow checks for FRAIM doctor command
+ * Validates workflow installation and versions
+ * 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.getWorkflowChecks = getWorkflowChecks;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const inheritance_parser_1 = require("../../../core/utils/inheritance-parser");
+/**
+ * Check if workflows directory exists
+ */
+function checkWorkflowsDirectoryExists() {
+    return {
+        name: 'Workflows directory exists',
+        category: 'workflows',
+        critical: true,
+        run: async () => {
+            const workflowsDir = path_1.default.join(process.cwd(), '.fraim', 'workflows');
+            if (fs_1.default.existsSync(workflowsDir)) {
+                return {
+                    status: 'passed',
+                    message: 'Workflows directory exists',
+                    details: { path: workflowsDir }
+                };
+            }
+            return {
+                status: 'error',
+                message: 'Workflows directory missing',
+                suggestion: 'Run fraim sync to fetch workflows',
+                command: 'fraim sync'
+            };
+        }
+    };
+}
+/**
+ * Check if workflow stubs are present
+ */
+function checkWorkflowStubsPresent() {
+    return {
+        name: 'Workflow stubs present',
+        category: 'workflows',
+        critical: false,
+        run: async () => {
+            const workflowsDir = path_1.default.join(process.cwd(), '.fraim', 'workflows');
+            if (!fs_1.default.existsSync(workflowsDir)) {
+                return {
+                    status: 'error',
+                    message: 'Cannot check stubs - workflows directory missing'
+                };
+            }
+            try {
+                // Count all .md files recursively
+                let stubCount = 0;
+                const countStubs = (dir) => {
+                    const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+                    for (const entry of entries) {
+                        if (entry.isDirectory()) {
+                            countStubs(path_1.default.join(dir, entry.name));
+                        }
+                        else if (entry.name.endsWith('.md')) {
+                            stubCount++;
+                        }
+                    }
+                };
+                countStubs(workflowsDir);
+                if (stubCount > 0) {
+                    return {
+                        status: 'passed',
+                        message: `${stubCount} workflow stubs found`,
+                        details: { stubCount }
+                    };
+                }
+                return {
+                    status: 'warning',
+                    message: 'No workflow stubs found',
+                    suggestion: 'Run fraim sync to fetch workflows',
+                    command: 'fraim sync'
+                };
+            }
+            catch (error) {
+                return {
+                    status: 'error',
+                    message: 'Failed to count workflow stubs',
+                    details: { error: error.message }
+                };
+            }
+        }
+    };
+}
+/**
+ * Check if workflows are up to date
+ */
+function checkWorkflowsUpToDate() {
+    return {
+        name: 'Workflows up to date',
+        category: 'workflows',
+        critical: false,
+        run: async () => {
+            const configPath = path_1.default.join(process.cwd(), '.fraim', 'config.json');
+            if (!fs_1.default.existsSync(configPath)) {
+                return {
+                    status: 'warning',
+                    message: 'Cannot check workflow version - config missing'
+                };
+            }
+            try {
+                const config = JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+                // Try multiple paths to find package.json
+                const possiblePaths = [
+                    path_1.default.join(__dirname, '../../../../package.json'), // From dist/src/cli/doctor/checks
+                    path_1.default.join(__dirname, '../../../package.json'), // From src/cli/doctor/checks
+                    path_1.default.join(process.cwd(), 'package.json') // From project root
+                ];
+                let packageJson = null;
+                for (const pkgPath of possiblePaths) {
+                    if (fs_1.default.existsSync(pkgPath)) {
+                        packageJson = JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf8'));
+                        break;
+                    }
+                }
+                if (!packageJson) {
+                    return {
+                        status: 'warning',
+                        message: 'Cannot determine package version'
+                    };
+                }
+                const currentVersion = packageJson.version;
+                const configVersion = config.version;
+                if (configVersion === currentVersion) {
+                    return {
+                        status: 'passed',
+                        message: `Workflows up to date (v${currentVersion})`,
+                        details: { version: currentVersion }
+                    };
+                }
+                return {
+                    status: 'warning',
+                    message: `Workflows outdated (v${configVersion} → v${currentVersion})`,
+                    suggestion: 'Update workflows with fraim sync',
+                    command: 'fraim sync',
+                    details: { configVersion, currentVersion }
+                };
+            }
+            catch (error) {
+                return {
+                    status: 'error',
+                    message: 'Failed to check workflow version',
+                    details: { error: error.message }
+                };
+            }
+        }
+    };
+}
+/**
+ * Check if override syntax is valid
+ */
+function checkOverrideSyntaxValid() {
+    return {
+        name: 'Override syntax valid',
+        category: 'workflows',
+        critical: false,
+        run: async () => {
+            const overridesDir = path_1.default.join(process.cwd(), '.fraim', 'overrides');
+            if (!fs_1.default.existsSync(overridesDir)) {
+                return {
+                    status: 'passed',
+                    message: 'No overrides (not required)',
+                    details: { overrideCount: 0 }
+                };
+            }
+            try {
+                const parser = new inheritance_parser_1.InheritanceParser();
+                const overrides = [];
+                let invalidCount = 0;
+                const errors = [];
+                // Scan for all override files
+                const scanDir = (dir, base = '') => {
+                    const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+                    for (const entry of entries) {
+                        const relativePath = path_1.default.join(base, entry.name);
+                        if (entry.isDirectory()) {
+                            scanDir(path_1.default.join(dir, entry.name), relativePath);
+                        }
+                        else if (entry.name.endsWith('.md')) {
+                            overrides.push(relativePath);
+                        }
+                    }
+                };
+                scanDir(overridesDir);
+                // Validate each override
+                for (const override of overrides) {
+                    const overridePath = path_1.default.join(overridesDir, override);
+                    const content = fs_1.default.readFileSync(overridePath, 'utf-8');
+                    const parseResult = parser.parse(content);
+                    if (parseResult.hasImports) {
+                        for (const importPath of parseResult.imports) {
+                            try {
+                                parser.sanitizePath(importPath);
+                            }
+                            catch (error) {
+                                invalidCount++;
+                                errors.push(`${override}: ${error.message}`);
+                            }
+                        }
+                    }
+                }
+                if (invalidCount === 0) {
+                    return {
+                        status: 'passed',
+                        message: `${overrides.length} overrides valid`,
+                        details: { overrideCount: overrides.length }
+                    };
+                }
+                return {
+                    status: 'error',
+                    message: `${invalidCount} invalid overrides found`,
+                    suggestion: 'Fix override import syntax',
+                    details: { errors }
+                };
+            }
+            catch (error) {
+                return {
+                    status: 'error',
+                    message: 'Failed to validate overrides',
+                    details: { error: error.message }
+                };
+            }
+        }
+    };
+}
+/**
+ * Get all workflow checks
+ */
+function getWorkflowChecks() {
+    return [
+        checkWorkflowsDirectoryExists(),
+        checkWorkflowStubsPresent(),
+        checkWorkflowsUpToDate(),
+        checkOverrideSyntaxValid()
+    ];
+}