fraim 2.0.100

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

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doctorCommand = void 0;
+exports.getAllChecks = getAllChecks;
+const commander_1 = require("commander");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const check_runner_1 = require("../doctor/check-runner");
+const console_reporter_1 = require("../doctor/reporters/console-reporter");
+const json_reporter_1 = require("../doctor/reporters/json-reporter");
+const global_setup_checks_1 = require("../doctor/checks/global-setup-checks");
+const project_setup_checks_1 = require("../doctor/checks/project-setup-checks");
+const workflow_checks_1 = require("../doctor/checks/workflow-checks");
+const ide_config_checks_1 = require("../doctor/checks/ide-config-checks");
+const mcp_connectivity_checks_1 = require("../doctor/checks/mcp-connectivity-checks");
+const scripts_checks_1 = require("../doctor/checks/scripts-checks");
+// Read version from package.json
+const getFramVersion = () => {
+    try {
+        const packageJsonPath = (0, path_1.join)(__dirname, '../../../package.json');
+        const packageJson = JSON.parse((0, fs_1.readFileSync)(packageJsonPath, 'utf-8'));
+        return packageJson.version;
+    }
+    catch (error) {
+        return 'unknown';
+    }
+};
+const FRAIM_VERSION = getFramVersion();
+// Simple logger for doctor command
+const logger = {
+    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)
+const trackMetric = (name, value) => {
+    if (process.env.DEBUG) {
+        console.debug(`[METRIC] ${name}: ${value}`);
+    }
+};
+/**
+ * Get all checks for doctor command
+ * Exported for testing
+ */
+function getAllChecks() {
+    return [
+        ...(0, global_setup_checks_1.getGlobalSetupChecks)(),
+        ...(0, project_setup_checks_1.getProjectSetupChecks)(),
+        ...(0, workflow_checks_1.getJobChecks)(),
+        ...(0, ide_config_checks_1.getIDEConfigChecks)(),
+        ...(0, mcp_connectivity_checks_1.getMCPConnectivityChecks)(),
+        ...(0, scripts_checks_1.getScriptsChecks)()
+    ];
+}
+exports.doctorCommand = new commander_1.Command('doctor')
+    .description('Validate FRAIM installation and configuration')
+    .option('--test-mcp', 'Test only MCP server connectivity')
+    .option('--test-config', 'Validate only configuration files')
+    .option('--test-jobs', 'Check only job status')
+    .option('--verbose', 'Show detailed output including successful checks')
+    .option('--json', 'Output results as JSON')
+    .action(async (cmdOptions) => {
+    const startTime = Date.now();
+    const options = {
+        testMcp: cmdOptions.testMcp,
+        testConfig: cmdOptions.testConfig,
+        testJobs: cmdOptions.testJobs,
+        verbose: cmdOptions.verbose,
+        json: cmdOptions.json
+    };
+    // Log command start
+    logger.info('Doctor command started', {
+        flags: {
+            testMcp: options.testMcp || false,
+            testConfig: options.testConfig || false,
+            testJobs: options.testJobs || false,
+            verbose: options.verbose || false,
+            json: options.json || false
+        }
+    });
+    // Track execution count
+    trackMetric('doctor.execution.count', 1);
+    // Track flag usage
+    if (options.testMcp)
+        trackMetric('doctor.flags.test_mcp', 1);
+    if (options.testConfig)
+        trackMetric('doctor.flags.test_config', 1);
+    if (options.testJobs)
+        trackMetric('doctor.flags.test_jobs', 1);
+    if (options.verbose)
+        trackMetric('doctor.flags.verbose', 1);
+    if (options.json)
+        trackMetric('doctor.flags.json', 1);
+    try {
+        // Collect all checks
+        const checks = getAllChecks();
+        // Run checks
+        const result = await (0, check_runner_1.runChecks)(checks, options, FRAIM_VERSION);
+        const duration = Date.now() - startTime;
+        // Log results
+        logger.info('Doctor command completed', {
+            duration,
+            summary: result.summary
+        });
+        // Track metrics
+        trackMetric('doctor.execution.duration', duration);
+        trackMetric('doctor.checks.passed', result.summary.passed);
+        trackMetric('doctor.checks.warnings', result.summary.warnings);
+        trackMetric('doctor.checks.errors', result.summary.errors);
+        trackMetric('doctor.checks.total', result.summary.total);
+        // Log warnings and errors
+        if (result.summary.warnings > 0) {
+            logger.warn(`Doctor found ${result.summary.warnings} warning(s)`);
+        }
+        if (result.summary.errors > 0) {
+            logger.error(`Doctor found ${result.summary.errors} error(s)`);
+        }
+        // Output results
+        if (options.json) {
+            console.log((0, json_reporter_1.formatJsonOutput)(result));
+        }
+        else {
+            console.log((0, console_reporter_1.formatConsoleOutput)(result, options));
+        }
+        // Set exit code based on results
+        if (result.summary.errors > 0) {
+            process.exit(2);
+        }
+        else if (result.summary.warnings > 0) {
+            process.exit(1);
+        }
+        else {
+            process.exit(0);
+        }
+    }
+    catch (error) {
+        const duration = Date.now() - startTime;
+        logger.error('Doctor command failed', { error, duration });
+        trackMetric('doctor.execution.errors', 1);
+        throw error;
+    }
+});

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

@@ -0,0 +1,301 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initProjectCommand = exports.runInitProject = void 0;
+const commander_1 = require("commander");
+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 child_process_1 = require("child_process");
+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 provider_registry_1 = require("../providers/provider-registry");
+const fraim_gitignore_1 = require("../utils/fraim-gitignore");
+const config_writer_1 = require("../../core/config-writer");
+const agent_adapters_1 = require("../utils/agent-adapters");
+const project_fraim_paths_1 = require("../../core/utils/project-fraim-paths");
+const project_bootstrap_1 = require("../utils/project-bootstrap");
+const promptForJiraProjectKey = async (jiraBaseUrl) => {
+    console.log(chalk_1.default.blue('\nJira 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'));
+    if (process.env.FRAIM_NON_INTERACTIVE) {
+        const defaultKey = process.env.FRAIM_JIRA_PROJECT_KEY || 'PROJ';
+        console.log(chalk_1.default.yellow(`\nNon-interactive mode: using Jira project key "${defaultKey}"`));
+        return defaultKey;
+    }
+    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('\nJira 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');
+    if (!fs_1.default.existsSync(globalConfigPath)) {
+        return { exists: false };
+    }
+    try {
+        const config = JSON.parse(fs_1.default.readFileSync(globalConfigPath, 'utf8'));
+        return {
+            exists: true,
+            mode: config.mode || 'integrated',
+            tokens: config.tokens || {},
+            providerConfigs: config.providerConfigs || {}
+        };
+    }
+    catch {
+        return { exists: true, mode: 'integrated', tokens: {} };
+    }
+};
+const installGitHubWorkflows = (projectRoot) => {
+    const workflowsDir = path_1.default.join(projectRoot, '.github', 'workflows');
+    const registryDir = fs_1.default.existsSync(path_1.default.join(__dirname, '..', '..', '..', 'registry'))
+        ? path_1.default.join(__dirname, '..', '..', '..', 'registry')
+        : path_1.default.join(__dirname, '..', '..', 'registry');
+    const sourceDir = path_1.default.join(registryDir, 'github', 'workflows');
+    if (!fs_1.default.existsSync(workflowsDir)) {
+        fs_1.default.mkdirSync(workflowsDir, { recursive: true });
+    }
+    const workflowFiles = ['phase-change.yml', 'status-change.yml', 'sync-on-pr-review.yml'];
+    workflowFiles.forEach((file) => {
+        const sourcePath = path_1.default.join(sourceDir, file);
+        const destPath = path_1.default.join(workflowsDir, file);
+        if (fs_1.default.existsSync(sourcePath)) {
+            fs_1.default.copyFileSync(sourcePath, destPath);
+            console.log(chalk_1.default.green(`Installed workflow: .github/workflows/${file}`));
+        }
+        else {
+            console.log(chalk_1.default.yellow(`Warning: Workflow not found in registry: ${file}`));
+        }
+    });
+};
+const createGitHubLabels = (projectRoot) => {
+    try {
+        (0, child_process_1.execSync)('gh --version', { stdio: 'ignore' });
+    }
+    catch {
+        console.log(chalk_1.default.yellow('GitHub CLI (gh) not found. Skipping label creation.'));
+        console.log(chalk_1.default.gray('Install gh CLI to enable automatic label creation: https://cli.github.com/'));
+        return;
+    }
+    const labelsPath = path_1.default.join(__dirname, '..', '..', '..', 'labels.json');
+    if (!fs_1.default.existsSync(labelsPath)) {
+        console.log(chalk_1.default.yellow('labels.json not found. Skipping label creation.'));
+        return;
+    }
+    try {
+        const labels = JSON.parse(fs_1.default.readFileSync(labelsPath, 'utf8'));
+        labels.forEach((label) => {
+            try {
+                (0, child_process_1.execSync)(`gh label create "${label.name}" --color "${label.color}" --description "${label.description}"`, { cwd: projectRoot, stdio: 'ignore' });
+                console.log(chalk_1.default.green(`Created label: ${label.name}`));
+            }
+            catch (error) {
+                if (error.message && error.message.includes('already exists')) {
+                    console.log(chalk_1.default.gray(`Label already exists: ${label.name}`));
+                }
+                else {
+                    console.log(chalk_1.default.yellow(`Could not create label ${label.name}: ${error.message}`));
+                }
+            }
+        });
+    }
+    catch (error) {
+        console.log(chalk_1.default.yellow(`Error reading labels.json: ${error.message}`));
+    }
+};
+const runInitProject = async () => {
+    console.log(chalk_1.default.blue('Initializing FRAIM project...'));
+    const globalSetup = checkGlobalSetup();
+    if (!globalSetup.exists) {
+        console.log(chalk_1.default.red('Global FRAIM setup not found.'));
+        console.log(chalk_1.default.yellow('Please run global setup first:'));
+        console.log(chalk_1.default.cyan('   fraim setup'));
+        process.exit(1);
+    }
+    const projectRoot = process.cwd();
+    const fraimDirDisplayPath = (0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)();
+    const configDisplayPath = (0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)('config.json');
+    const fraimDir = (0, project_fraim_paths_1.getWorkspaceFraimDir)(projectRoot);
+    const configPath = (0, project_fraim_paths_1.getWorkspaceConfigPath)(projectRoot);
+    const projectName = path_1.default.basename(projectRoot);
+    const result = (0, project_bootstrap_1.createInitProjectResult)(projectName, globalSetup.mode || 'integrated');
+    result.bootstrapNeeded = !fs_1.default.existsSync(configPath);
+    if (!fs_1.default.existsSync(fraimDir)) {
+        fs_1.default.mkdirSync(fraimDir, { recursive: true });
+        console.log(chalk_1.default.green(`Created ${fraimDirDisplayPath} directory`));
+        (0, project_bootstrap_1.recordPathStatus)(result, fraimDirDisplayPath, true);
+    }
+    else {
+        console.log(chalk_1.default.yellow(`${fraimDirDisplayPath} directory already exists`));
+        (0, project_bootstrap_1.recordPathStatus)(result, fraimDirDisplayPath, false);
+    }
+    if (!fs_1.default.existsSync(configPath)) {
+        const preferredMode = globalSetup.mode || 'integrated';
+        result.mode = preferredMode;
+        let config;
+        if (preferredMode === 'conversational') {
+            config = {
+                version: (0, version_utils_1.getFraimVersion)(),
+                project: {
+                    name: projectName
+                },
+                customizations: {}
+            };
+            console.log(chalk_1.default.blue('   conversational mode: no platform integration'));
+            console.log(chalk_1.default.gray(`   Project: ${projectName}`));
+        }
+        else {
+            const detection = (0, platform_detection_1.detectPlatformFromGit)();
+            if (detection.provider !== 'unknown' && detection.repository) {
+                result.repositoryDetected = true;
+                let issueTracking;
+                const jiraConfig = globalSetup.providerConfigs?.jiraConfig;
+                if (preferredMode === 'split' && globalSetup.tokens?.jira && jiraConfig?.baseUrl) {
+                    const projectKey = process.env.FRAIM_JIRA_PROJECT_KEY ||
+                        await promptForJiraProjectKey(jiraConfig.baseUrl);
+                    issueTracking = {
+                        provider: 'jira',
+                        baseUrl: jiraConfig.baseUrl,
+                        projectKey,
+                        email: jiraConfig.email
+                    };
+                    result.issueTrackingDetected = true;
+                    console.log(chalk_1.default.blue(`   Code Repository: ${detection.provider.toUpperCase()}`));
+                    console.log(chalk_1.default.blue(`   Issue Tracking: JIRA (${projectKey})`));
+                }
+                else {
+                    issueTracking = {
+                        provider: detection.provider,
+                        ...detection.repository
+                    };
+                    result.issueTrackingDetected = true;
+                    if (preferredMode === 'split') {
+                        result.mode = 'integrated';
+                        result.warnings.push('Split mode is not fully configured for this repo yet, so issue tracking fell back to the repository provider.');
+                    }
+                    const providerDef = await (0, provider_registry_1.getProvider)(detection.provider);
+                    console.log(chalk_1.default.blue(`   Platform: ${providerDef?.displayName || detection.provider.toUpperCase()}`));
+                }
+                config = {
+                    version: (0, version_utils_1.getFraimVersion)(),
+                    project: {
+                        name: detection.repository.name || projectName
+                    },
+                    repository: detection.repository,
+                    issueTracking,
+                    customizations: {}
+                };
+                const repo = detection.repository;
+                if (repo.owner && repo.name) {
+                    console.log(chalk_1.default.gray(`   Repository: ${repo.owner}/${repo.name}`));
+                }
+                else if (repo.organization && repo.project && repo.name) {
+                    console.log(chalk_1.default.gray(`   Organization: ${repo.organization}`));
+                    console.log(chalk_1.default.gray(`   Project: ${repo.project}`));
+                    console.log(chalk_1.default.gray(`   Repository: ${repo.name}`));
+                }
+                else if (repo.namespace && repo.name) {
+                    console.log(chalk_1.default.gray(`   Namespace: ${repo.namespace || '(none)'}`));
+                    console.log(chalk_1.default.gray(`   Repository: ${repo.name}`));
+                }
+            }
+            else {
+                config = {
+                    version: (0, version_utils_1.getFraimVersion)(),
+                    project: {
+                        name: projectName
+                    },
+                    customizations: {}
+                };
+                result.mode = 'conversational';
+                result.warnings.push('No git remote detected. FRAIM fell back to conversational project setup.');
+                console.log(chalk_1.default.yellow('   No git remote detected. Falling back to conversational mode.'));
+            }
+        }
+        (0, config_writer_1.writeFraimConfig)(configPath, config);
+        console.log(chalk_1.default.green(`Created ${configDisplayPath}`));
+        (0, project_bootstrap_1.recordPathStatus)(result, configDisplayPath, true);
+    }
+    else {
+        (0, project_bootstrap_1.recordPathStatus)(result, configDisplayPath, false);
+        try {
+            const existingConfig = JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+            if (existingConfig.mode === 'conversational' || existingConfig.mode === 'integrated' || existingConfig.mode === 'split') {
+                result.mode = existingConfig.mode;
+            }
+            result.repositoryDetected = Boolean(existingConfig.repository?.provider);
+            result.issueTrackingDetected = Boolean(existingConfig.issueTracking?.provider);
+        }
+        catch {
+            result.warnings.push(`Existing ${configDisplayPath} could not be parsed for summary details.`);
+        }
+    }
+    ['jobs', 'ai-employee/jobs', 'ai-employee/skills', 'ai-manager/jobs', 'personalized-employee'].forEach((dir) => {
+        const dirPath = path_1.default.join(fraimDir, dir);
+        if (!fs_1.default.existsSync(dirPath)) {
+            fs_1.default.mkdirSync(dirPath, { recursive: true });
+            const displayPath = (0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)(dir);
+            console.log(chalk_1.default.green(`Created ${displayPath}`));
+            (0, project_bootstrap_1.recordPathStatus)(result, displayPath, true);
+        }
+        else {
+            (0, project_bootstrap_1.recordPathStatus)(result, (0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)(dir), false);
+        }
+    });
+    if ((0, fraim_gitignore_1.ensureFraimSyncedContentIgnored)(projectRoot)) {
+        console.log(chalk_1.default.green('Updated .gitignore FRAIM managed block'));
+    }
+    const detection = (0, platform_detection_1.detectPlatformFromGit)();
+    if (detection.provider === 'github') {
+        console.log(chalk_1.default.blue('\nSetting up GitHub workflows and labels...'));
+        installGitHubWorkflows(projectRoot);
+        createGitHubLabels(projectRoot);
+        result.repositoryDetected = true;
+    }
+    if (!process.env.FRAIM_SKIP_SYNC) {
+        await (0, sync_1.runSync)({});
+        result.syncPerformed = true;
+    }
+    else {
+        result.warnings.push('Sync was skipped for this run.');
+    }
+    const codexAvailable = (0, ide_detector_1.detectInstalledIDEs)().some((ide) => ide.configType === 'codex');
+    if (codexAvailable) {
+        const codexLocalResult = (0, codex_local_config_1.ensureCodexLocalConfig)(projectRoot);
+        const status = codexLocalResult.created ? 'Created' : codexLocalResult.updated ? 'Updated' : 'Verified';
+        console.log(chalk_1.default.green(`${status} project Codex config at ${codexLocalResult.path}`));
+    }
+    const adapterUpdates = (0, agent_adapters_1.ensureAgentAdapterFiles)(projectRoot);
+    if (adapterUpdates.length > 0) {
+        console.log(chalk_1.default.green(`Updated FRAIM agent adapter files: ${adapterUpdates.join(', ')}`));
+    }
+    (0, project_bootstrap_1.printInitProjectSummary)(result);
+};
+exports.runInitProject = runInitProject;
+exports.initProjectCommand = new commander_1.Command('init-project')
+    .description('Initialize FRAIM in the current project (requires global setup)')
+    .action(exports.runInitProject);

package/dist/src/cli/commands/list-overridable.js

@@ -0,0 +1,184 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listOverridableCommand = void 0;
+const commander_1 = require("commander");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const project_fraim_paths_1 = require("../../core/utils/project-fraim-paths");
+exports.listOverridableCommand = new commander_1.Command('list-overridable')
+    .description('List all FRAIM registry paths that can be overridden')
+    .option('--job-category <category>', 'Filter by job category (e.g., product-building, customer-development, marketing)')
+    .option('--rules', 'Show all overridable rules')
+    .action(async (options) => {
+    const projectRoot = process.cwd();
+    const personalizedDir = (0, project_fraim_paths_1.getWorkspaceFraimPath)(projectRoot, 'personalized-employee');
+    if (!(0, project_fraim_paths_1.workspaceFraimExists)(projectRoot)) {
+        console.log(chalk_1.default.red(`${(0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)()} directory not found. Run "fraim setup" or "fraim init-project" first.`));
+        process.exit(1);
+    }
+    let registryRoot = null;
+    const frameworkRoot = path_1.default.join(__dirname, '..', '..', '..');
+    const frameworkRegistry = path_1.default.join(frameworkRoot, 'registry');
+    if (fs_1.default.existsSync(frameworkRegistry)) {
+        registryRoot = frameworkRegistry;
+    }
+    else {
+        const nodeModulesRegistry = path_1.default.join(process.cwd(), 'node_modules', '@fraim', 'framework', 'registry');
+        if (fs_1.default.existsSync(nodeModulesRegistry)) {
+            registryRoot = nodeModulesRegistry;
+        }
+    }
+    if (!registryRoot) {
+        console.log(chalk_1.default.red('Could not find FRAIM registry. Please ensure @fraim/framework is installed.'));
+        process.exit(1);
+    }
+    console.log(chalk_1.default.blue('Overridable FRAIM Registry Paths:\n'));
+    const existingOverrides = new Set();
+    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 {
+                existingOverrides.add(relativePath.replace(/\\/g, '/'));
+            }
+        }
+    };
+    if (fs_1.default.existsSync(personalizedDir)) {
+        scanDir(personalizedDir);
+    }
+    if (options.rules) {
+        const rulesDir = path_1.default.join(registryRoot, 'rules');
+        if (fs_1.default.existsSync(rulesDir)) {
+            console.log(chalk_1.default.bold.cyan('Rules:\n'));
+            const ruleFiles = fs_1.default.readdirSync(rulesDir)
+                .filter(f => f.endsWith('.md'))
+                .sort();
+            for (const file of ruleFiles) {
+                const filePath = `rules/${file}`;
+                const hasOverride = existingOverrides.has(filePath);
+                const status = hasOverride ? chalk_1.default.green('[OVERRIDDEN]') : chalk_1.default.gray('[OVERRIDABLE]');
+                console.log(`  ${status} ${filePath}`);
+            }
+            console.log('');
+        }
+        showTips();
+        return;
+    }
+    if (options.jobCategory) {
+        const category = options.jobCategory;
+        const jobsDir = path_1.default.join(registryRoot, 'jobs', category);
+        const templatesDir = path_1.default.join(registryRoot, 'templates', category);
+        if (!fs_1.default.existsSync(jobsDir)) {
+            console.log(chalk_1.default.red(`Category "${category}" not found.`));
+            console.log(chalk_1.default.gray('\nAvailable categories:'));
+            const categoriesDir = path_1.default.join(registryRoot, 'jobs');
+            const categories = fs_1.default.readdirSync(categoriesDir, { withFileTypes: true })
+                .filter(d => d.isDirectory())
+                .map(d => d.name)
+                .sort();
+            categories.forEach(c => console.log(chalk_1.default.gray(`  - ${c}`)));
+            process.exit(1);
+        }
+        console.log(chalk_1.default.bold.cyan(`Jobs (${category}):\n`));
+        const jobFiles = fs_1.default.readdirSync(jobsDir)
+            .filter(f => f.endsWith('.md'))
+            .sort();
+        for (const file of jobFiles) {
+            const filePath = `jobs/${category}/${file}`;
+            const hasOverride = existingOverrides.has(filePath);
+            const status = hasOverride ? chalk_1.default.green('[OVERRIDDEN]') : chalk_1.default.gray('[OVERRIDABLE]');
+            console.log(`  ${status} ${filePath}`);
+        }
+        console.log('');
+        if (fs_1.default.existsSync(templatesDir)) {
+            console.log(chalk_1.default.bold.cyan(`Templates (${category}):\n`));
+            const templateFiles = fs_1.default.readdirSync(templatesDir)
+                .filter(f => f.endsWith('.md') || f.endsWith('.html') || f.endsWith('.csv') || f.endsWith('.yml'))
+                .sort();
+            for (const file of templateFiles) {
+                const filePath = `templates/${category}/${file}`;
+                const hasOverride = existingOverrides.has(filePath);
+                const status = hasOverride ? chalk_1.default.green('[OVERRIDDEN]') : chalk_1.default.gray('[OVERRIDABLE]');
+                console.log(`  ${status} ${filePath}`);
+            }
+            console.log('');
+        }
+        showTips();
+        return;
+    }
+    console.log(chalk_1.default.bold.cyan('Available Job Categories:\n'));
+    const jobsDir = path_1.default.join(registryRoot, 'jobs');
+    const categories = fs_1.default.readdirSync(jobsDir, { withFileTypes: true })
+        .filter(d => d.isDirectory())
+        .map(d => d.name)
+        .sort();
+    const columns = 3;
+    for (let i = 0; i < categories.length; i += columns) {
+        const row = categories.slice(i, i + columns);
+        const formatted = row.map(cat => chalk_1.default.gray(`  - ${cat.padEnd(30)}`)).join('');
+        console.log(formatted);
+    }
+    console.log('');
+    if (existingOverrides.size > 0) {
+        console.log(chalk_1.default.bold.cyan('Your Active Overrides:\n'));
+        const overridesByType = {
+            jobs: [],
+            templates: [],
+            rules: [],
+            other: []
+        };
+        for (const override of Array.from(existingOverrides).sort()) {
+            if (override.startsWith('jobs/')) {
+                overridesByType.jobs.push(override);
+            }
+            else if (override.startsWith('templates/')) {
+                overridesByType.templates.push(override);
+            }
+            else if (override.startsWith('rules/')) {
+                overridesByType.rules.push(override);
+            }
+            else {
+                overridesByType.other.push(override);
+            }
+        }
+        if (overridesByType.jobs.length > 0) {
+            console.log(chalk_1.default.gray('  Jobs:'));
+            overridesByType.jobs.forEach(o => console.log(`    ${chalk_1.default.green('[OVERRIDDEN]')} ${o}`));
+            console.log('');
+        }
+        if (overridesByType.templates.length > 0) {
+            console.log(chalk_1.default.gray('  Templates:'));
+            overridesByType.templates.forEach(o => console.log(`    ${chalk_1.default.green('[OVERRIDDEN]')} ${o}`));
+            console.log('');
+        }
+        if (overridesByType.rules.length > 0) {
+            console.log(chalk_1.default.gray('  Rules:'));
+            overridesByType.rules.forEach(o => console.log(`    ${chalk_1.default.green('[OVERRIDDEN]')} ${o}`));
+            console.log('');
+        }
+        if (overridesByType.other.length > 0) {
+            console.log(chalk_1.default.gray('  Other:'));
+            overridesByType.other.forEach(o => console.log(`    ${chalk_1.default.green('[OVERRIDDEN]')} ${o}`));
+            console.log('');
+        }
+    }
+    else {
+        console.log(chalk_1.default.gray('No active overrides yet.\n'));
+    }
+    showTips();
+    function showTips() {
+        console.log(chalk_1.default.gray('Tips:'));
+        console.log(chalk_1.default.gray('  - Use "fraim override <path> --inherit" to inherit from global'));
+        console.log(chalk_1.default.gray('  - Use "fraim override <path> --copy" to copy current content'));
+        console.log(chalk_1.default.gray('  - Use --job-category <category> to see category-specific items'));
+        console.log(chalk_1.default.gray('  - Use --rules to see all overridable rules'));
+        console.log(chalk_1.default.gray(`  - Overrides are stored in ${(0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)('personalized-employee')}`));
+    }
+});