fraim-framework 2.0.38 → 2.0.41

package/README.md

@@ -255,6 +255,14 @@ FRAIM/
 
 ## 🚀 **Get Started in 60 Seconds**
 
+### **⚠️ Prerequisites**
+
+**Shell Requirements:**
+- **Windows**: Must use Git Bash (install from https://git-scm.com/download/win)
+- **macOS/Linux**: Default terminal works fine
+
+**Why Git Bash on Windows?** All FRAIM scripts use Unix-style paths and Bash commands. Git Bash ensures consistent behavior across platforms.
+
 ### **Install & Initialize**
 ```bash
 npm install -g fraim-framework

package/dist/src/ai-manager/ai-manager.js

@@ -0,0 +1,162 @@
+"use strict";
+/**
+ * Simplified AI Manager
+ *
+ * Single AI manager integrated into fraim-mcp-server that reads validation rules
+ * from pre-defined JSON files and provides structured review instructions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIManager = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+class AIManager {
+    constructor(rulesPath) {
+        // Default to rules directory - server-side only, not sent to client
+        this.rulesPath = rulesPath || (0, path_1.join)(__dirname, '..', '..', 'registry', 'ai-manager-rules');
+    }
+    /**
+     * Generate review instructions for a workflow phase
+     */
+    generateReviewInstructions(context) {
+        console.log(`🤖 AI Manager: Generating review instructions for ${context.workflowType} phase`);
+        const rules = this.loadWorkflowRules(context.workflowType);
+        if (!rules) {
+            throw new Error(`No rules found for workflow type: ${context.workflowType}`);
+        }
+        return this.formatReviewInstructions(rules, context);
+    }
+    /**
+     * Evaluate agent's review report and provide decision
+     */
+    evaluateReport(report, context) {
+        console.log(`🤖 AI Manager: Evaluating review report for ${context.workflowType} phase`);
+        const iterationCount = report.iterationCount || 1;
+        const maxIterations = 3;
+        if (report.pass) {
+            return {
+                action: 'PROCEED',
+                message: 'Review passed. Ready to submit PR to human for review.',
+                nextSteps: [
+                    'Update issue status to "status:needs-review"',
+                    'Remove "status:wip" label',
+                    'Include complete review results in evidence document',
+                    'Submit PR for human review with evidence'
+                ],
+                iterationCount
+            };
+        }
+        else {
+            // Check if max iterations reached
+            if (iterationCount >= maxIterations) {
+                return {
+                    action: 'ESCALATE',
+                    message: `Maximum iterations (${maxIterations}) reached. Escalating to human review despite failing validation.`,
+                    nextSteps: [
+                        'Update issue status to "status:needs-review"',
+                        'Add "ai-manager:max-iterations" label to indicate escalation reason',
+                        'Include all iteration attempts and failure reasons in evidence document',
+                        'Submit PR for human review with detailed iteration history',
+                        'Human reviewer should focus on the recurring validation failures'
+                    ],
+                    iterationCount,
+                    maxIterationsReached: true
+                };
+            }
+            else {
+                return {
+                    action: 'ITERATE',
+                    message: `Review failed. Address the identified issues before proceeding. (Iteration ${iterationCount}/${maxIterations})`,
+                    nextSteps: [
+                        'Fix all issues identified in the failure reasons',
+                        'Re-run validation steps to verify fixes',
+                        `Request new review instructions with iterationCount: ${iterationCount + 1}`,
+                        'Do not submit PR until review passes or max iterations reached'
+                    ],
+                    iterationCount
+                };
+            }
+        }
+    }
+    /**
+     * Load workflow rules from JSON file (server-side only)
+     */
+    loadWorkflowRules(workflowType) {
+        const rulesFile = (0, path_1.join)(this.rulesPath, `${workflowType}.json`);
+        if (!(0, fs_1.existsSync)(rulesFile)) {
+            console.warn(`⚠️ No rules file found for workflow: ${workflowType} at ${rulesFile}`);
+            return null;
+        }
+        try {
+            const content = (0, fs_1.readFileSync)(rulesFile, 'utf8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            console.error(`❌ Error loading rules for ${workflowType}:`, error);
+            return null;
+        }
+    }
+    /**
+     * Format review instructions with proper template structure
+     */
+    formatReviewInstructions(rules, context) {
+        const instructions = `# AI Manager Review Instructions
+
+## Workflow: ${rules.workflowType.toUpperCase()}
+**Issue:** #${context.issueNumber}
+**Phase:** ${context.phase}
+
+## Description
+${rules.description}
+
+## Iteration Tracking
+**IMPORTANT**: You must track your iteration count for this phase. This is your attempt number for this specific workflow phase (spec, implement, test, etc.).
+
+- **First attempt**: Use iterationCount: 1
+- **After first failure**: Use iterationCount: 2  
+- **After second failure**: Use iterationCount: 3
+- **Maximum iterations**: 3 (after 3rd failure, work will be escalated to human review)
+
+## Validation Steps
+Complete each step below and evaluate whether you meet the pass criteria:
+
+${rules.validationRules.map(rule => `
+### Step ${rule.step}: ${rule.description}
+${rule.command ? `**Command:** \`${rule.command.replace('{issue_number}', context.issueNumber)}\`` : ''}
+**Pass Criteria:** ${rule.passCriteria}
+**Weight:** ${rule.weight.toUpperCase()}${rule.weight === 'blocking' ? ' (Must pass to proceed)' : ' (Should pass for quality)'}
+**Category:** ${rule.category}
+`).join('')}
+
+## Grading Criteria
+
+### Pass Requirements
+${rules.gradingCriteria.passRequirements.map(req => `- ${req}`).join('\n')}
+
+### Fail Requirements  
+${rules.gradingCriteria.failRequirements.map(req => `- ${req}`).join('\n')}
+
+## Reporting Format
+${rules.reportingFormat.instructions}
+
+**Required Response Format:**
+\`\`\`json
+{
+  "pass": true/false,
+  "reasons": ["reason1", "reason2"], // Only required if pass=false
+  "iterationCount": 1 // REQUIRED: Your current iteration number for this phase
+}
+\`\`\`
+
+## Iteration Limits
+- **Maximum 3 iterations** per workflow phase
+- After 3 failed attempts, work will be **automatically escalated** to human review
+- Track your attempts carefully - include iterationCount in every report
+- Each workflow phase (spec, implement, test) has its own iteration counter
+
+## Next Steps
+After completing your review, report back with the JSON response above including your iteration count. The AI Manager will evaluate your report and provide next steps based on your progress and iteration count.
+`;
+        return instructions;
+    }
+}
+exports.AIManager = AIManager;

package/dist/src/cli/setup/auto-mcp-setup.js

@@ -286,7 +286,7 @@ const autoConfigureMCP = async (fraimKey, githubToken, selectedIDEs) => {
     const detectedIDEs = (0, ide_detector_1.detectInstalledIDEs)();
     if (detectedIDEs.length === 0) {
         console.log(chalk_1.default.yellow('⚠️ No supported IDEs detected.'));
-        console.log(chalk_1.default.gray('Supported IDEs: Claude Desktop, Antigravity, Kiro, Cursor, VSCode, Codex, Windsurf'));
+        console.log(chalk_1.default.gray('Supported IDEs: Claude, Antigravity, Kiro, Cursor, VSCode, Codex, Windsurf'));
         console.log(chalk_1.default.blue('\n💡 You can install an IDE and run setup again later.'));
         console.log(chalk_1.default.gray('   Or continue with manual MCP configuration.'));
         const continueAnyway = await (0, prompts_1.default)({

package/dist/src/cli/setup/ide-detector.js

@@ -19,6 +19,7 @@ const checkMultiplePaths = (paths) => {
 };
 const detectClaude = () => {
     const paths = [
+        '~/.claude.json',
         '~/.claude',
         '~/Library/Application Support/Claude',
         '~/AppData/Roaming/Claude'
@@ -54,16 +55,17 @@ const detectWindsurf = () => {
 };
 exports.IDE_CONFIGS = [
     {
-        name: 'Claude Desktop',
-        configPath: '~/.claude/settings.json',
+        name: 'Claude',
+        configPath: '~/.claude.json',
         configFormat: 'json',
-        configType: 'standard',
+        configType: 'claude',
         detectMethod: detectClaude,
         alternativePaths: [
+            '~/.claude/settings.json',
             '~/Library/Application Support/Claude/settings.json',
             '~/AppData/Roaming/Claude/settings.json'
         ],
-        description: 'Anthropic Claude Desktop application'
+        description: 'Anthropic Claude application'
     },
     {
         name: 'Antigravity',

package/dist/src/cli/setup/mcp-config-generator.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateMCPConfig = exports.generateWindsurfMCPServers = exports.generateCodexMCPServers = exports.generateKiroMCPServers = exports.generateStandardMCPServers = void 0;
+exports.generateMCPConfig = exports.generateWindsurfMCPServers = exports.generateCodexMCPServers = exports.generateKiroMCPServers = exports.generateClaudeMCPServers = exports.generateStandardMCPServers = void 0;
 const generateStandardMCPServers = (fraimKey, githubToken) => ({
     mcpServers: {
         git: {
@@ -26,6 +26,33 @@ const generateStandardMCPServers = (fraimKey, githubToken) => ({
     }
 });
 exports.generateStandardMCPServers = generateStandardMCPServers;
+const generateClaudeMCPServers = (fraimKey, githubToken) => ({
+    mcpServers: {
+        git: {
+            command: "npx",
+            args: ["-y", "@cyanheads/git-mcp-server"]
+        },
+        github: {
+            type: "http",
+            url: "https://api.githubcopilot.com/mcp/",
+            headers: {
+                Authorization: `Bearer ${githubToken}`
+            }
+        },
+        playwright: {
+            command: "npx",
+            args: ["-y", "@playwright/mcp"]
+        },
+        fraim: {
+            type: "http",
+            url: "https://fraim.wellnessatwork.me",
+            headers: {
+                "x-api-key": fraimKey
+            }
+        }
+    }
+});
+exports.generateClaudeMCPServers = generateClaudeMCPServers;
 const generateKiroMCPServers = (fraimKey, githubToken) => ({
     mcpServers: {
         git: {
@@ -102,6 +129,8 @@ const generateMCPConfig = (configType, fraimKey, githubToken) => {
     switch (configType) {
         case 'standard':
             return (0, exports.generateStandardMCPServers)(fraimKey, githubToken);
+        case 'claude':
+            return (0, exports.generateClaudeMCPServers)(fraimKey, githubToken);
         case 'kiro':
             return (0, exports.generateKiroMCPServers)(fraimKey, githubToken);
         case 'codex':

package/dist/src/fraim-mcp-server.js

@@ -45,6 +45,7 @@ const path_1 = require("path");
 const git_utils_1 = require("./utils/git-utils");
 const config_loader_1 = require("./fraim/config-loader");
 const db_service_1 = require("./fraim/db-service");
+const ai_manager_1 = require("./ai-manager/ai-manager");
 const issues_1 = require("./fraim/issues");
 const crypto_1 = require("crypto");
 const dotenv = __importStar(require("dotenv"));
@@ -169,6 +170,7 @@ class FraimMCPServer {
         // Initialize database service
         this.dbService = new db_service_1.FraimDbService();
         this.sessionManager = new SessionManager(this.dbService);
+        this.aiManager = new ai_manager_1.AIManager();
         // Load FRAIM configuration
         this.config = (0, config_loader_1.loadFraimConfig)();
         // Find registry directory (check dist first for production, then source)
@@ -979,6 +981,98 @@ Supports dry-run mode to preview the operation.`,
                         },
                         required: ['title', 'body']
                     }
+                },
+                {
+                    name: 'ai_manager_request_review',
+                    description: `Request self-review instructions from AI Manager after completing workflow phase.
+
+The AI Manager provides detailed review instructions including:
+- Step-by-step validation criteria
+- Pass/fail criteria for each step
+- Commands to run for verification
+- Grading guidelines and reporting format
+
+Use this when you believe your work is complete and ready for review.
+Currently supports: spec phase (more phases coming soon).`,
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            workflowType: {
+                                type: 'string',
+                                description: 'Type of workflow phase completed',
+                                enum: ['spec', 'design', 'implement', 'test']
+                            },
+                            issueNumber: {
+                                type: 'string',
+                                description: 'Issue number being worked on'
+                            },
+                            phase: {
+                                type: 'string',
+                                description: 'Specific phase name (e.g., "specification", "implementation")'
+                            }
+                        },
+                        required: ['workflowType', 'issueNumber', 'phase']
+                    }
+                },
+                {
+                    name: 'ai_manager_report_grade',
+                    description: `Report your self-assessment to AI Manager after completing self-review.
+
+Provide results from review in JSON format:
+- pass: true/false based on review assessment
+- reasons: array of failure reasons (only if pass=false)
+- iterationCount: REQUIRED - your current iteration number for this phase
+
+AI Manager will evaluate your report and provide next steps:
+- PROCEED: Ready to submit PR for human review
+- ITERATE: Fix issues and retry (max 3 iterations)
+- ESCALATE: Max iterations reached, escalate to human review
+
+IMPORTANT: Track your iteration count per workflow phase. Each phase (spec, implement, test) has its own counter.
+Maximum 3 iterations per phase before automatic escalation to human review.`,
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            workflowType: {
+                                type: 'string',
+                                description: 'Type of workflow phase',
+                                enum: ['spec', 'design', 'implement', 'test']
+                            },
+                            issueNumber: {
+                                type: 'string',
+                                description: 'Issue number being worked on'
+                            },
+                            phase: {
+                                type: 'string',
+                                description: 'Specific phase name'
+                            },
+                            report: {
+                                type: 'object',
+                                description: 'Your self-assessment report in JSON format',
+                                properties: {
+                                    pass: {
+                                        type: 'boolean',
+                                        description: 'Whether your work passes all validation criteria'
+                                    },
+                                    reasons: {
+                                        type: 'array',
+                                        description: 'Array of specific reasons for failure (only required if pass=false)',
+                                        items: {
+                                            type: 'string'
+                                        }
+                                    },
+                                    iterationCount: {
+                                        type: 'number',
+                                        description: 'REQUIRED: Your current iteration number for this workflow phase (1, 2, or 3)',
+                                        minimum: 1,
+                                        maximum: 3
+                                    }
+                                },
+                                required: ['pass', 'iterationCount']
+                            }
+                        },
+                        required: ['workflowType', 'issueNumber', 'phase', 'report']
+                    }
                 }
             ]
         };
@@ -1016,6 +1110,10 @@ Supports dry-run mode to preview the operation.`,
                 };
             case 'fraim_connect':
                 return await this.handleFraimConnect(toolArgs, context.apiKey, context.userId);
+            case 'ai_manager_request_review':
+                return await this.handleAIManagerRequestReview(toolArgs);
+            case 'ai_manager_report_grade':
+                return await this.handleAIManagerReportGrade(toolArgs);
             default:
                 throw new Error(`Unknown tool: ${toolName} `);
         }
@@ -1450,6 +1548,106 @@ If \`.fraim/config.json\` doesn't exist:
             sessionId: sessionId
         };
     }
+    async handleAIManagerRequestReview(args) {
+        try {
+            console.log(`🤖 AI Manager: Generating review instructions for ${args.workflowType} phase`);
+            const instructions = this.aiManager.generateReviewInstructions({
+                workflowType: args.workflowType,
+                issueNumber: args.issueNumber,
+                phase: args.phase
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: instructions
+                    }]
+            };
+        }
+        catch (error) {
+            console.error('❌ AI Manager request review failed:', error);
+            return {
+                content: [{
+                        type: 'text',
+                        text: `# ❌ AI Manager Request Failed\n\n**Error**: ${error instanceof Error ? error.message : 'Unknown error'}\n\nPlease check your request parameters and try again.`
+                    }],
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+    async handleAIManagerReportGrade(args) {
+        try {
+            console.log(`🤖 AI Manager: Evaluating review report for ${args.workflowType} phase`);
+            const decision = this.aiManager.evaluateReport(args.report, {
+                workflowType: args.workflowType,
+                issueNumber: args.issueNumber,
+                phase: args.phase
+            });
+            // Format response for agent
+            let response = `# 🤖 AI Manager Evaluation Result\n\n`;
+            const actionEmoji = decision.action === 'PROCEED' ? '✅' :
+                decision.action === 'ESCALATE' ? '⚠️' : '🔄';
+            response += `## Decision: ${actionEmoji} ${decision.action}\n\n`;
+            response += `**Message**: ${decision.message}\n\n`;
+            if (decision.iterationCount) {
+                response += `**Iteration Count**: ${decision.iterationCount}/3\n\n`;
+            }
+            response += `## Next Steps\n\n`;
+            decision.nextSteps.forEach((step, index) => {
+                response += `${index + 1}. ${step}\n`;
+            });
+            response += `\n`;
+            if (decision.action === 'PROCEED') {
+                response += `## 🎉 Ready for Human Review!\n\n`;
+                response += `Your work has passed AI Manager validation. You should now:\n\n`;
+                response += `1. **Submit PR** with complete evidence document\n`;
+                response += `2. **Update issue labels** to status:needs-review\n`;
+                response += `3. **Include this AI Manager validation** in your evidence\n\n`;
+            }
+            else if (decision.action === 'ESCALATE') {
+                response += `## ⚠️ Escalated to Human Review\n\n`;
+                response += `Maximum iterations reached. Your work will be reviewed by a human despite validation failures:\n\n`;
+                response += `1. **Submit PR** with detailed iteration history\n`;
+                response += `2. **Add escalation label** (ai-manager:max-iterations)\n`;
+                response += `3. **Document all attempts** and failure reasons in evidence\n`;
+                response += `4. **Human reviewer** will focus on recurring validation issues\n\n`;
+            }
+            else {
+                response += `## 🔧 Work Required\n\n`;
+                response += `Your work needs improvement. You should:\n\n`;
+                response += `1. **Address all failure reasons** listed below\n`;
+                response += `2. **Re-run validation steps** to verify fixes\n`;
+                response += `3. **Request new review** using ai_manager_request_review\n`;
+                response += `4. **Include iterationCount: ${(decision.iterationCount || 1) + 1}** in next report\n`;
+                response += `5. **Do NOT submit PR** until review passes or escalates\n\n`;
+            }
+            response += `## Your Report Summary\n\n`;
+            response += `**Pass**: ${args.report.pass}\n`;
+            response += `**Iteration**: ${args.report.iterationCount || 1}/3\n`;
+            if (args.report.reasons && args.report.reasons.length > 0) {
+                response += `**Failure Reasons**:\n`;
+                args.report.reasons.forEach((reason) => {
+                    response += `- ${reason}\n`;
+                });
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: response
+                    }],
+                decision: decision
+            };
+        }
+        catch (error) {
+            console.error('❌ AI Manager report evaluation failed:', error);
+            return {
+                content: [{
+                        type: 'text',
+                        text: `# ❌ AI Manager Evaluation Failed\n\n**Error**: ${error instanceof Error ? error.message : 'Unknown error'}\n\nPlease check your report format and try again.`
+                    }],
+                error: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
     async start(port = 3002) {
         try {
             // Connect to database before starting server

package/dist/tests/test-ai-manager.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * Tests for AI Manager - Simplified Review System
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const node_assert_1 = __importDefault(require("node:assert"));
+const ai_manager_1 = require("../src/ai-manager/ai-manager");
+(0, node_test_1.describe)('AI Manager', () => {
+    let aiManager;
+    (0, node_test_1.beforeEach)(() => {
+        aiManager = new ai_manager_1.AIManager();
+    });
+    (0, node_test_1.describe)('generateReviewInstructions', () => {
+        (0, node_test_1.test)('should generate spec workflow instructions', () => {
+            const context = {
+                workflowType: 'spec',
+                issueNumber: '123',
+                phase: 'specification'
+            };
+            const instructions = aiManager.generateReviewInstructions(context);
+            (0, node_assert_1.default)(typeof instructions === 'string');
+            (0, node_assert_1.default)(instructions.includes('AI Manager Review Instructions'));
+            (0, node_assert_1.default)(instructions.includes('spec'));
+            (0, node_assert_1.default)(instructions.includes('123'));
+            (0, node_assert_1.default)(instructions.includes('iterationCount'));
+            (0, node_assert_1.default)(instructions.includes('Maximum 3 iterations'));
+        });
+        (0, node_test_1.test)('should throw error for unknown workflow type', () => {
+            const context = {
+                workflowType: 'unknown',
+                issueNumber: '123',
+                phase: 'test'
+            };
+            node_assert_1.default.throws(() => {
+                aiManager.generateReviewInstructions(context);
+            }, /No rules found for workflow type: unknown/);
+        });
+    });
+    (0, node_test_1.describe)('evaluateReport', () => {
+        (0, node_test_1.test)('should return PROCEED for passing report', () => {
+            const report = {
+                pass: true,
+                iterationCount: 1
+            };
+            const context = {
+                workflowType: 'spec',
+                issueNumber: '123',
+                phase: 'specification'
+            };
+            const decision = aiManager.evaluateReport(report, context);
+            node_assert_1.default.strictEqual(decision.action, 'PROCEED');
+            (0, node_assert_1.default)(decision.message.includes('Ready to submit PR'));
+            (0, node_assert_1.default)(decision.nextSteps.length > 0);
+            node_assert_1.default.strictEqual(decision.iterationCount, 1);
+        });
+        (0, node_test_1.test)('should return ITERATE for failing report within iteration limit', () => {
+            const report = {
+                pass: false,
+                reasons: ['Missing spec document', 'Template not followed'],
+                iterationCount: 2
+            };
+            const context = {
+                workflowType: 'spec',
+                issueNumber: '123',
+                phase: 'specification'
+            };
+            const decision = aiManager.evaluateReport(report, context);
+            node_assert_1.default.strictEqual(decision.action, 'ITERATE');
+            (0, node_assert_1.default)(decision.message.includes('Address the identified issues'));
+            (0, node_assert_1.default)(decision.message.includes('Iteration 2/3'));
+            (0, node_assert_1.default)(decision.nextSteps.length > 0);
+            node_assert_1.default.strictEqual(decision.iterationCount, 2);
+        });
+        (0, node_test_1.test)('should return ESCALATE when max iterations reached', () => {
+            const report = {
+                pass: false,
+                reasons: ['Still missing spec document', 'Template still not followed'],
+                iterationCount: 3
+            };
+            const context = {
+                workflowType: 'spec',
+                issueNumber: '123',
+                phase: 'specification'
+            };
+            const decision = aiManager.evaluateReport(report, context);
+            node_assert_1.default.strictEqual(decision.action, 'ESCALATE');
+            (0, node_assert_1.default)(decision.message.includes('Maximum iterations'));
+            (0, node_assert_1.default)(decision.message.includes('Escalating to human review'));
+            (0, node_assert_1.default)(decision.nextSteps.length > 0);
+            node_assert_1.default.strictEqual(decision.iterationCount, 3);
+            node_assert_1.default.strictEqual(decision.maxIterationsReached, true);
+        });
+        (0, node_test_1.test)('should default to iteration 1 if not provided', () => {
+            const report = {
+                pass: false,
+                reasons: ['Missing spec document']
+                // iterationCount not provided
+            };
+            const context = {
+                workflowType: 'spec',
+                issueNumber: '123',
+                phase: 'specification'
+            };
+            const decision = aiManager.evaluateReport(report, context);
+            node_assert_1.default.strictEqual(decision.action, 'ITERATE');
+            node_assert_1.default.strictEqual(decision.iterationCount, 1);
+        });
+    });
+});

package/dist/tests/test-complete-setup-flow.js

@@ -95,7 +95,7 @@ const token_validator_1 = require("../src/cli/setup/token-validator");
 (0, node_test_1.test)('Path expansion works correctly across platforms', () => {
     const testPaths = [
         '~/.fraim/config.json',
-        '~/.claude/settings.json',
+        '~/.claude.json',
         '~/.kiro/settings/mcp.json'
     ];
     testPaths.forEach(testPath => {

package/dist/tests/test-ide-detector.js

@@ -19,14 +19,14 @@ const os_1 = __importDefault(require("os"));
     node_assert_1.default.strictEqual(result, absolutePath);
 });
 (0, node_test_1.test)('IDE_CONFIGS should contain all expected IDEs', () => {
-    const expectedIDEs = ['Claude Desktop', 'Antigravity', 'Kiro', 'Cursor', 'VSCode', 'Codex', 'Windsurf'];
+    const expectedIDEs = ['Claude', 'Antigravity', 'Kiro', 'Cursor', 'VSCode', 'Codex', 'Windsurf'];
     const actualIDEs = ide_detector_1.IDE_CONFIGS.map(ide => ide.name);
     expectedIDEs.forEach(expectedIDE => {
         (0, node_assert_1.default)(actualIDEs.includes(expectedIDE), `Missing IDE: ${expectedIDE}`);
     });
 });
 (0, node_test_1.test)('IDE_CONFIGS should have valid config types', () => {
-    const validConfigTypes = ['standard', 'kiro', 'codex', 'windsurf'];
+    const validConfigTypes = ['standard', 'kiro', 'codex', 'windsurf', 'claude'];
     ide_detector_1.IDE_CONFIGS.forEach(ide => {
         (0, node_assert_1.default)(validConfigTypes.includes(ide.configType), `Invalid config type for ${ide.name}: ${ide.configType}`);
     });

package/dist/tests/test-improved-setup.js

@@ -30,12 +30,12 @@ const mcp_config_generator_1 = require("../src/cli/setup/mcp-config-generator");
         const claude = (0, ide_detector_1.findIDEByName)('claude');
         const cursor = (0, ide_detector_1.findIDEByName)('cursor');
         const vscode = (0, ide_detector_1.findIDEByName)('vscode');
-        (0, node_assert_1.default)(claude?.name === 'Claude Desktop', 'Should find Claude Desktop');
+        (0, node_assert_1.default)(claude?.name === 'Claude', 'Should find Claude');
         (0, node_assert_1.default)(cursor?.name === 'Cursor', 'Should find Cursor');
         (0, node_assert_1.default)(vscode?.name === 'VSCode', 'Should find VSCode');
         // Test partial matching
         const claudePartial = (0, ide_detector_1.findIDEByName)('clau');
-        (0, node_assert_1.default)(claudePartial?.name === 'Claude Desktop', 'Should find Claude with partial name');
+        (0, node_assert_1.default)(claudePartial?.name === 'Claude', 'Should find Claude with partial name');
         console.log('✅ IDE name matching works correctly');
     });
     (0, node_test_1.it)('should expand paths correctly across platforms', () => {