fraim-framework 2.0.37 → 2.0.41

package/dist/src/cli/setup/token-validator.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidTokenFormat = exports.validateGitHubToken = exports.validateFraimKey = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const validateFraimKey = async (key) => {
+    // Basic format validation
+    if (!key || !key.startsWith('fraim_')) {
+        return false;
+    }
+    // TODO: Add actual API validation when FRAIM server is available
+    // For now, just validate format
+    return key.length > 15; // More reasonable minimum length
+};
+exports.validateFraimKey = validateFraimKey;
+const validateGitHubToken = async (token) => {
+    if (!token)
+        return false;
+    // Validate token format
+    if (!token.startsWith('ghp_') && !token.startsWith('github_pat_')) {
+        return false;
+    }
+    try {
+        const response = await fetch('https://api.github.com/user', {
+            headers: {
+                Authorization: `Bearer ${token}`,
+                'User-Agent': 'FRAIM-Setup/1.0'
+            }
+        });
+        return response.ok;
+    }
+    catch (error) {
+        console.log(chalk_1.default.yellow('⚠️ Could not validate GitHub token (network issue), proceeding anyway'));
+        return true; // Assume valid if network issues
+    }
+};
+exports.validateGitHubToken = validateGitHubToken;
+const isValidTokenFormat = (token, type) => {
+    if (type === 'fraim') {
+        return token.startsWith('fraim_') && token.length > 15; // More reasonable minimum length
+    }
+    if (type === 'github') {
+        return token.startsWith('ghp_') || token.startsWith('github_pat_');
+    }
+    return false;
+};
+exports.isValidTokenFormat = isValidTokenFormat;

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/debug-tools.js

@@ -8,7 +8,7 @@ const axios_1 = __importDefault(require("axios"));
 const db_service_js_1 = require("../src/fraim/db-service.js");
 const test_utils_1 = require("./test-utils");
 const tree_kill_1 = __importDefault(require("tree-kill"));
-const path_1 = __importDefault(require("path"));
+const test_server_utils_1 = require("./test-server-utils");
 async function debugListTools() {
     console.log('   🔍 Debugging Available Tools...');
     let fraimProcess;
@@ -24,7 +24,7 @@ async function debugListTools() {
         await db.collection('fraim_api_keys').updateOne({ key: TEST_API_KEY }, { $set: { userId: 'debug@test.com', orgId: 'debug-org', isActive: true, createdAt: new Date() } }, { upsert: true });
         // 2. Start server
         const npxCommand = process.platform === 'win32' ? 'npx.cmd' : 'npx';
-        const serverScript = path_1.default.resolve(__dirname, '../dist/src/fraim-mcp-server.js');
+        const serverScript = (0, test_server_utils_1.getServerScriptPath)();
         fraimProcess = (0, node_child_process_1.spawn)(npxCommand, ['node', `"${serverScript}"`], {
             env: { ...process.env, FRAIM_MCP_PORT: PORT.toString(), FRAIM_SKIP_INDEX_ON_START: 'true' },
             shell: true

package/dist/tests/shared-server-utils.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * Shared server utilities for tests
+ * All tests should use these utilities instead of starting their own servers
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTestServerUrl = getTestServerUrl;
+exports.getTestServerPort = getTestServerPort;
+exports.getMcpEndpoint = getMcpEndpoint;
+exports.getHealthEndpoint = getHealthEndpoint;
+exports.isServerRunning = isServerRunning;
+exports.waitForServer = waitForServer;
+const SERVER_URL = process.env.FRAIM_TEST_SERVER_URL || 'http://localhost:12999';
+const SERVER_PORT = parseInt(process.env.FRAIM_TEST_SERVER_PORT || '12999');
+function getTestServerUrl() {
+    return SERVER_URL;
+}
+function getTestServerPort() {
+    return SERVER_PORT;
+}
+function getMcpEndpoint() {
+    return `${SERVER_URL}/mcp`;
+}
+function getHealthEndpoint() {
+    return `${SERVER_URL}/health`;
+}
+/**
+ * Check if the shared test server is running
+ */
+async function isServerRunning() {
+    try {
+        const axios = require('axios');
+        await axios.get(getHealthEndpoint(), { timeout: 1000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Wait for the shared server to be ready
+ * This is useful for tests that run early in the suite
+ */
+async function waitForServer(timeoutMs = 10000) {
+    const axios = require('axios');
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+        try {
+            await axios.get(getHealthEndpoint(), { timeout: 1000 });
+            return;
+        }
+        catch {
+            await new Promise(resolve => setTimeout(resolve, 500));
+        }
+    }
+    throw new Error(`Shared test server not ready after ${timeoutMs}ms`);
+}

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-client-scripts-validation.js

@@ -8,10 +8,28 @@ const child_process_1 = require("child_process");
 const fs_1 = require("fs");
 const path_1 = require("path");
 const node_assert_1 = __importDefault(require("node:assert"));
+const path_2 = __importDefault(require("path"));
+/**
+ * Client-side script validation tests
+ * Ensures scripts can run without FRAIM internal imports
+ * Following the project's standard test structure from test-utils.ts
+ */
+// Find project root by looking for package.json
+function findProjectRoot() {
+    let currentDir = __dirname;
+    while (currentDir !== path_2.default.dirname(currentDir)) {
+        if ((0, fs_1.existsSync)(path_2.default.join(currentDir, 'package.json'))) {
+            return currentDir;
+        }
+        currentDir = path_2.default.dirname(currentDir);
+    }
+    throw new Error('Could not find project root (package.json not found)');
+}
 async function testNoFraimInternalImports() {
     console.log('   🧪 Testing registry scripts do not import FRAIM internals...');
     try {
-        const scriptsDir = (0, path_1.join)(process.cwd(), 'registry', 'scripts');
+        const projectRoot = findProjectRoot();
+        const scriptsDir = (0, path_1.join)(projectRoot, 'registry', 'scripts');
         const scriptFiles = ['cleanup-branch.ts', 'generate-engagement-emails.ts', 'newsletter-helpers.ts'];
         for (const scriptFile of scriptFiles) {
             const scriptPath = (0, path_1.join)(scriptsDir, scriptFile);
@@ -35,7 +53,8 @@ async function testNoFraimInternalImports() {
 async function testInlineUtilityFunctions() {
     console.log('   🧪 Testing scripts have inline utility functions...');
     try {
-        const scriptsDir = (0, path_1.join)(process.cwd(), 'registry', 'scripts');
+        const projectRoot = findProjectRoot();
+        const scriptsDir = (0, path_1.join)(projectRoot, 'registry', 'scripts');
         const scriptPath = (0, path_1.join)(scriptsDir, 'cleanup-branch.ts');
         if ((0, fs_1.existsSync)(scriptPath)) {
             const content = (0, fs_1.readFileSync)(scriptPath, 'utf-8');
@@ -54,7 +73,8 @@ async function testInlineUtilityFunctions() {
 async function testConfigLoadingFromJson() {
     console.log('   🧪 Testing scripts load config from .fraim/config.json...');
     try {
-        const scriptsDir = (0, path_1.join)(process.cwd(), 'registry', 'scripts');
+        const projectRoot = findProjectRoot();
+        const scriptsDir = (0, path_1.join)(projectRoot, 'registry', 'scripts');
         const scriptPath = (0, path_1.join)(scriptsDir, 'generate-engagement-emails.ts');
         if ((0, fs_1.existsSync)(scriptPath)) {
             const content = (0, fs_1.readFileSync)(scriptPath, 'utf-8');
@@ -73,7 +93,8 @@ async function testConfigLoadingFromJson() {
 async function testRegistryPathValidator() {
     console.log('   🧪 Testing registry path validator passes...');
     try {
-        (0, child_process_1.execSync)('npm run validate:registry', { stdio: 'pipe' });
+        const projectRoot = findProjectRoot();
+        (0, child_process_1.execSync)('npm run validate:registry', { stdio: 'pipe', cwd: projectRoot });
         return true;
     }
     catch (error) {
@@ -84,7 +105,8 @@ async function testRegistryPathValidator() {
 async function testScriptExecutability() {
     console.log('   🧪 Testing scripts are executable without import errors...');
     try {
-        const scriptsDir = (0, path_1.join)(process.cwd(), 'registry', 'scripts');
+        const projectRoot = findProjectRoot();
+        const scriptsDir = (0, path_1.join)(projectRoot, 'registry', 'scripts');
         const scriptPath = (0, path_1.join)(scriptsDir, 'cleanup-branch.ts');
         if ((0, fs_1.existsSync)(scriptPath)) {
             // Test that the script can be parsed without import errors

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

@@ -0,0 +1,110 @@
+"use strict";
+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 fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const ide_detector_1 = require("../src/cli/setup/ide-detector");
+const mcp_config_generator_1 = require("../src/cli/setup/mcp-config-generator");
+const token_validator_1 = require("../src/cli/setup/token-validator");
+(0, node_test_1.test)('Complete setup flow - end to end simulation', async () => {
+    const testFraimKey = 'fraim_test123456789012345';
+    const testGithubToken = 'ghp_test123456789012345';
+    // Step 1: Validate tokens (as setup command would)
+    (0, node_assert_1.default)((0, token_validator_1.isValidTokenFormat)(testFraimKey, 'fraim'), 'FRAIM key should be valid format');
+    (0, node_assert_1.default)((0, token_validator_1.isValidTokenFormat)(testGithubToken, 'github'), 'GitHub token should be valid format');
+    (0, node_assert_1.default)(await (0, token_validator_1.validateFraimKey)(testFraimKey), 'FRAIM key should validate');
+    // Step 2: Detect IDEs (as setup command would)
+    const detectedIDEs = (0, ide_detector_1.detectInstalledIDEs)();
+    console.log(`Detected ${detectedIDEs.length} IDEs in test environment`);
+    // Step 3: Generate configs for each detected IDE type
+    const configTypes = ['standard', 'kiro', 'codex', 'windsurf'];
+    for (const configType of configTypes) {
+        const config = (0, mcp_config_generator_1.generateMCPConfig)(configType, testFraimKey, testGithubToken);
+        if (configType === 'codex') {
+            // TOML config
+            (0, node_assert_1.default)(typeof config === 'string', `${configType} should return string`);
+            (0, node_assert_1.default)(config.includes(testFraimKey), `${configType} should contain FRAIM key`);
+        }
+        else {
+            // JSON configs
+            (0, node_assert_1.default)(typeof config === 'object', `${configType} should return object`);
+            (0, node_assert_1.default)(config.mcpServers, `${configType} should have mcpServers`);
+            (0, node_assert_1.default)(config.mcpServers.fraim, `${configType} should have fraim server`);
+        }
+    }
+    // Step 4: Simulate global config creation
+    const testGlobalDir = path_1.default.join(os_1.default.tmpdir(), 'fraim-global-test-' + Date.now());
+    fs_1.default.mkdirSync(testGlobalDir, { recursive: true });
+    const globalConfig = {
+        version: '2.0.37',
+        apiKey: testFraimKey,
+        configuredAt: new Date().toISOString(),
+        userPreferences: {
+            autoSync: true,
+            backupConfigs: true
+        }
+    };
+    const globalConfigPath = path_1.default.join(testGlobalDir, 'config.json');
+    fs_1.default.writeFileSync(globalConfigPath, JSON.stringify(globalConfig, null, 2));
+    (0, node_assert_1.default)(fs_1.default.existsSync(globalConfigPath), 'Global config should be created');
+    // Step 5: Simulate project config creation (as init-project would)
+    const testProjectDir = path_1.default.join(os_1.default.tmpdir(), 'fraim-project-test-' + Date.now());
+    fs_1.default.mkdirSync(testProjectDir, { recursive: true });
+    const fraimProjectDir = path_1.default.join(testProjectDir, '.fraim');
+    fs_1.default.mkdirSync(fraimProjectDir, { recursive: true });
+    const projectConfig = {
+        version: '2.0.37',
+        project: {
+            name: 'test-project'
+        },
+        git: {
+            defaultBranch: 'master',
+            repoOwner: 'test-owner',
+            repoName: 'test-project'
+        }
+    };
+    const projectConfigPath = path_1.default.join(fraimProjectDir, 'config.json');
+    fs_1.default.writeFileSync(projectConfigPath, JSON.stringify(projectConfig, null, 2));
+    (0, node_assert_1.default)(fs_1.default.existsSync(projectConfigPath), 'Project config should be created');
+    // Step 6: Verify configs can be read back correctly
+    const savedGlobalConfig = JSON.parse(fs_1.default.readFileSync(globalConfigPath, 'utf8'));
+    const savedProjectConfig = JSON.parse(fs_1.default.readFileSync(projectConfigPath, 'utf8'));
+    (0, node_assert_1.default)(savedGlobalConfig.apiKey === testFraimKey, 'Global config should contain API key');
+    (0, node_assert_1.default)(savedProjectConfig.project.name === 'test-project', 'Project config should contain project name');
+    // Cleanup
+    fs_1.default.rmSync(testGlobalDir, { recursive: true, force: true });
+    fs_1.default.rmSync(testProjectDir, { recursive: true, force: true });
+    console.log('✅ Complete setup flow simulation passed');
+});
+(0, node_test_1.test)('Error handling - invalid tokens should be rejected', async () => {
+    const invalidFraimKey = 'invalid_key';
+    const invalidGithubToken = 'invalid_token';
+    const shortFraimKey = 'fraim_short';
+    (0, node_assert_1.default)(!(0, token_validator_1.isValidTokenFormat)(invalidFraimKey, 'fraim'), 'Invalid FRAIM key should be rejected');
+    (0, node_assert_1.default)(!(0, token_validator_1.isValidTokenFormat)(invalidGithubToken, 'github'), 'Invalid GitHub token should be rejected');
+    (0, node_assert_1.default)(!(0, token_validator_1.isValidTokenFormat)(shortFraimKey, 'fraim'), 'Short FRAIM key should be rejected');
+    (0, node_assert_1.default)(!await (0, token_validator_1.validateFraimKey)(invalidFraimKey), 'Invalid FRAIM key should not validate');
+    (0, node_assert_1.default)(!await (0, token_validator_1.validateFraimKey)(shortFraimKey), 'Short FRAIM key should not validate');
+    console.log('✅ Error handling tests passed');
+});
+(0, node_test_1.test)('Path expansion works correctly across platforms', () => {
+    const testPaths = [
+        '~/.fraim/config.json',
+        '~/.claude.json',
+        '~/.kiro/settings/mcp.json'
+    ];
+    testPaths.forEach(testPath => {
+        const expanded = (0, ide_detector_1.expandPath)(testPath);
+        (0, node_assert_1.default)(expanded.includes(os_1.default.homedir()), `${testPath} should expand to include home directory`);
+        (0, node_assert_1.default)(!expanded.includes('~'), `${testPath} should not contain tilde after expansion`);
+    });
+    // Test absolute paths remain unchanged
+    const absolutePath = '/usr/local/bin/fraim';
+    (0, node_assert_1.default)((0, ide_detector_1.expandPath)(absolutePath) === absolutePath, 'Absolute paths should remain unchanged');
+    console.log('✅ Path expansion tests passed');
+});