fraim-framework 2.0.47 → 2.0.48

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

@@ -43,10 +43,10 @@ const cors_1 = __importDefault(require("cors"));
 const fs_1 = require("fs");
 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 template_processor_1 = require("./fraim/template-processor");
 const crypto_1 = require("crypto");
 const dotenv = __importStar(require("dotenv"));
 // Load environment variables
@@ -170,8 +170,6 @@ class FraimMCPServer {
         // Initialize database service
         this.dbService = new db_service_1.FraimDbService();
         this.sessionManager = new SessionManager(this.dbService);
-        // Load FRAIM configuration
-        this.config = (0, config_loader_1.loadFraimConfig)();
         // Find registry directory (check dist first for production, then source)
         this.registryPath = this.findRegistryPath();
         // Build file index from filesystem (includes registry and .fraim)
@@ -238,7 +236,7 @@ class FraimMCPServer {
         const clientVersion = this.getClientVersion();
         if (clientVersion && clientVersion !== this.serverVersion) {
             // Add a notice header for agents/developers to see
-            res.setHeader('X-FRAIM-Version-Notice', `Version mismatch: Project has ${clientVersion}, Server has ${this.serverVersion}. Run 'npm install @fraim/framework@latest'`);
+            res.setHeader('X-FRAIM-Version-Notice', `Update available: Project has ${clientVersion}, Server has ${this.serverVersion}. Run 'fraim sync' to get latest workflows and features. This will not cause issues, but you're missing all the latest capabilities of FRAIM :)`);
             // If it's an /mcp request, we can inject it into the response later in the handler
             // For now, storing it in the request object
             req.versionMismatch = {
@@ -283,11 +281,20 @@ class FraimMCPServer {
         if (req.path === '/health' || req.path.startsWith('/admin')) {
             return next();
         }
-        // Skip auth in test mode
+        const apiKey = req.headers['x-api-key'] || req.query['api-key'];
+        // In test mode, still extract API key if provided but don't validate it
         if (process.env.NODE_ENV === 'test') {
+            if (apiKey) {
+                // Set mock API key data for testing
+                req.apiKeyData = {
+                    key: apiKey,
+                    userId: 'test-user',
+                    orgId: 'test-org',
+                    isActive: true
+                };
+            }
             return next();
         }
-        const apiKey = req.headers['x-api-key'] || req.query['api-key'];
         if (!apiKey) {
             console.error(`[FRAIM AUTH] Missing API key for ${req.method} ${req.path}`);
             res.status(401).json({ error: 'Unauthorized', message: 'Missing API key' });
@@ -412,8 +419,12 @@ class FraimMCPServer {
     buildFileIndex() {
         this.fileIndex.clear();
         // 1. Index Global registry (packaged with the server)
-        // __dirname is src/ (dev) or dist/src/ (prod)
-        const globalRegistryPath = (0, path_1.join)(__dirname, '..', 'registry');
+        // In development, prefer source registry over dist registry
+        let globalRegistryPath = (0, path_1.join)(__dirname, '..', 'registry');
+        if (!(0, fs_1.existsSync)(globalRegistryPath)) {
+            // Fallback to dist registry for production
+            globalRegistryPath = (0, path_1.join)(__dirname, '..', '..', 'registry');
+        }
         if ((0, fs_1.existsSync)(globalRegistryPath)) {
             console.log(`🌍 Indexing global registry from ${globalRegistryPath}`);
             this.indexDirectory(globalRegistryPath, '');
@@ -428,15 +439,13 @@ class FraimMCPServer {
         const fraimBasePath = (0, path_1.join)(process.cwd(), '.fraim');
         if ((0, fs_1.existsSync)(fraimBasePath)) {
             console.log(`🎨 Indexing project-specific .fraim customizations`);
-            const customizations = this.config.customizations || {};
             // Index custom rules
             const rulesPath = (0, path_1.join)(process.cwd(), '.fraim/rules');
             if ((0, fs_1.existsSync)(rulesPath)) {
                 this.indexDirectory(rulesPath, 'fraim/rules');
             }
-            // Index custom workflows
-            const workflowsPathStr = customizations.workflowsPath || '.fraim/workflows';
-            const workflowsPath = (0, path_1.join)(process.cwd(), workflowsPathStr);
+            // Index custom workflows (use default path)
+            const workflowsPath = (0, path_1.join)(process.cwd(), '.fraim/workflows');
             if ((0, fs_1.existsSync)(workflowsPath)) {
                 this.indexDirectory(workflowsPath, 'fraim/workflows');
             }
@@ -797,7 +806,7 @@ class FraimMCPServer {
                 }
                 if (req.versionMismatch) {
                     const { client, server } = req.versionMismatch;
-                    const notice = `⚠️ [FRAIM VERSION MISMATCH] Project uses @fraim/framework@${client}, but the server is at ${server}.\n👉 Action: Run 'npm install @fraim/framework@latest' and 'fraim sync' to stay in sync.`;
+                    const notice = `ℹ️ **FRAIM Update Available**\n\nYour project is using FRAIM ${client}, but version ${server} is available with new features and improvements.\n\n**To update:** Run \`fraim sync\` to get the latest workflows and templates.\n\n---\n\n`;
                     if (result && Array.isArray(result.content)) {
                         result.content.unshift({
                             type: 'text',
@@ -860,23 +869,87 @@ Call this before fetching any workflow or file to understand the system.`,
                 {
                     name: 'fraim_connect',
                     description: `Handshake to start a FRAIM session. MUST be called at the start of every session.
-Registers your environment (machine/repo) for telemetry and unlocks other tools.`,
+Registers your environment (machine/repo/agent) for telemetry and unlocks other tools.
+
+**Agent Information**: REQUIRED - Provide your actual agent name and model (validated against known agents).
+**Machine Information**: Use os.hostname() and process.platform - required for telemetry.
+**Repository Information**: FRAIM will auto-detect from .fraim/config.json if available, or provide git remote URL.`,
                     inputSchema: {
                         type: 'object',
                         properties: {
+                            agent: {
+                                type: 'object',
+                                description: 'Agent identification and capabilities',
+                                properties: {
+                                    name: {
+                                        type: 'string',
+                                        description: 'Agent name (e.g., "Claude", "Cursor", "Kiro", "Windsurf", "Antigravity")',
+                                        examples: ['Claude', 'Cursor', 'Kiro', 'Windsurf', 'Antigravity']
+                                    },
+                                    model: {
+                                        type: 'string',
+                                        description: 'Model name/version (e.g., "claude-3.5-sonnet", "gpt-4", "cursor-small")',
+                                        examples: ['claude-3.5-sonnet', 'gpt-4', 'cursor-small', 'kiro-agent']
+                                    },
+                                    version: {
+                                        type: 'string',
+                                        description: 'Agent version if available',
+                                        examples: ['1.0.0', '2024.12.1']
+                                    }
+                                },
+                                required: ['name', 'model'],
+                                additionalProperties: true
+                            },
                             machine: {
                                 type: 'object',
-                                description: 'Machine specs (hostname, platform, memory, cpus)',
+                                description: 'Machine specs - use os.hostname(), process.platform, os.totalmem(), os.cpus().length',
+                                properties: {
+                                    hostname: {
+                                        type: 'string',
+                                        description: 'Machine hostname from os.hostname()'
+                                    },
+                                    platform: {
+                                        type: 'string',
+                                        description: 'Platform from process.platform (win32, darwin, linux)'
+                                    },
+                                    memory: {
+                                        type: 'number',
+                                        description: 'Total memory in bytes from os.totalmem()'
+                                    },
+                                    cpus: {
+                                        type: 'number',
+                                        description: 'CPU count from os.cpus().length'
+                                    }
+                                },
+                                required: ['hostname', 'platform'],
                                 additionalProperties: true
                             },
                             repo: {
                                 type: 'object',
-                                description: 'Repository context (owner, name, url)',
+                                description: 'Repository context - use git remote -v or check .git/config for URL',
+                                properties: {
+                                    url: {
+                                        type: 'string',
+                                        description: 'Git repository URL from git remote -v'
+                                    },
+                                    owner: {
+                                        type: 'string',
+                                        description: 'Repository owner (extracted from URL)'
+                                    },
+                                    name: {
+                                        type: 'string',
+                                        description: 'Repository name (extracted from URL)'
+                                    },
+                                    branch: {
+                                        type: 'string',
+                                        description: 'Current branch from git branch --show-current'
+                                    }
+                                },
                                 required: ['url'],
                                 additionalProperties: true
                             }
                         },
-                        required: ['machine', 'repo']
+                        required: ['agent', 'machine', 'repo']
                     }
                 },
                 {
@@ -1054,13 +1127,14 @@ This is your single point of contact for workflow guidance with evidence validat
     }
     async handleToolCall(params, context = {}) {
         const { name: toolName, arguments: toolArgs } = params;
+        console.log(`🔧 MCP Server: handleToolCall called with tool: ${toolName}, args:`, JSON.stringify(toolArgs, null, 2));
         switch (toolName) {
             case 'get_fraim_init':
                 return await this.handleGetInit();
             case 'get_fraim_file':
                 return await this.handleGetFile(toolArgs.path);
             case 'get_fraim_workflow':
-                return await this.handleGetWorkflow(toolArgs.workflow);
+                return await this.handleGetWorkflow(toolArgs.workflow, context.apiKey);
             case 'list_fraim_workflows':
                 return await this.handleListWorkflows();
             case 'fraim_get_local_config':
@@ -1246,20 +1320,30 @@ This is your single point of contact for workflow guidance with evidence validat
             throw new Error(`Failed to read file: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
-    async handleGetWorkflow(workflowName) {
+    async handleGetWorkflow(workflowName, apiKey) {
         // Normalize workflow name (remove .md if present)
         const normalizedName = workflowName.replace(/\.md$/, '');
         // Try to find the workflow file
         const workflowPath = `workflows/${normalizedName}.md`;
         const metadata = this.fileIndex.get(workflowPath);
         if (!metadata) {
-            // Try alternative category paths
-            const categories = ['product-building', 'customer-development', 'business-development', 'marketing', 'performance', 'quality-assurance', 'reviewer', 'startup-credits', 'bootstrap', 'deploy'];
-            for (const cat of categories) {
+            // Try alternative category paths - dynamically discover categories from file index
+            const workflowCategories = new Set();
+            // Extract all unique workflow categories from the file index
+            for (const [path, fileMetadata] of this.fileIndex) {
+                if (fileMetadata.type === 'workflow' && path.startsWith('workflows/') && path.includes('/')) {
+                    const pathParts = path.split('/');
+                    if (pathParts.length >= 3) { // workflows/category/file.md
+                        workflowCategories.add(pathParts[1]);
+                    }
+                }
+            }
+            // Search through all discovered categories
+            for (const cat of workflowCategories) {
                 const altPath = `workflows/${cat}/${normalizedName}.md`;
                 const altMetadata = this.fileIndex.get(altPath);
                 if (altMetadata) {
-                    return this.returnWorkflowFile(altMetadata);
+                    return this.returnWorkflowFile(altMetadata, apiKey);
                 }
             }
             // Workflow not found
@@ -1273,22 +1357,48 @@ This is your single point of contact for workflow guidance with evidence validat
                     }]
             };
         }
-        return this.returnWorkflowFile(metadata);
+        return this.returnWorkflowFile(metadata, apiKey);
     }
     /**
      * Return a workflow file with its content
      */
-    async returnWorkflowFile(metadata) {
+    async returnWorkflowFile(metadata, apiKey) {
         try {
-            const content = (0, fs_1.readFileSync)(metadata.fullPath, 'utf-8');
+            const rawContent = (0, fs_1.readFileSync)(metadata.fullPath, 'utf-8');
+            // Get repository info from session if available
+            let repositoryInfo = null;
+            if (apiKey) {
+                try {
+                    const session = await this.dbService.getActiveSessionByApiKey(apiKey);
+                    if (session?.repo) {
+                        repositoryInfo = {
+                            owner: session.repo.owner,
+                            name: session.repo.name,
+                            organization: session.repo.organization,
+                            project: session.repo.project,
+                            url: session.repo.url,
+                            provider: this.detectProviderFromUrl(session.repo.url)
+                        };
+                    }
+                }
+                catch (e) {
+                    // Ignore session lookup errors, continue without repository info
+                }
+            }
+            // Process templates with provider-specific actions
+            const templateEngine = (0, template_processor_1.getTemplateEngine)(this.registryPath);
+            const processedContent = templateEngine.processWorkflow(rawContent, repositoryInfo);
             // Build response
             let response = `# Workflow: ${metadata.name.replace('.md', '')}\n\n`;
             response += `**Path:** \`${metadata.path}\`\n`;
             if (metadata.category) {
                 response += `**Category:** ${metadata.category}\n`;
             }
+            // Add provider info if available
+            const provider = repositoryInfo?.provider || 'GITHUB';
+            response += `**Platform:** ${provider.toUpperCase()}\n`;
             response += `\n---\n\n`;
-            response += content;
+            response += processedContent;
             return {
                 content: [{
                         type: 'text',
@@ -1484,16 +1594,41 @@ If \`.fraim/config.json\` doesn't exist:
         if (!apiKey) {
             throw new Error('No API Key found in context for fraim_connect');
         }
+        // Validate required agent information
+        if (!args.agent?.name || !args.agent?.model) {
+            throw new Error('Agent information is required. Please provide agent.name and agent.model in your fraim_connect call.');
+        }
+        // Validate agent information to prevent BS
+        const validAgentNames = ['Claude', 'Cursor', 'Kiro', 'Windsurf', 'Antigravity', 'ChatGPT', 'Copilot'];
+        if (!validAgentNames.some(valid => args.agent.name.toLowerCase().includes(valid.toLowerCase()))) {
+            throw new Error(`Invalid agent name "${args.agent.name}". Please use one of: ${validAgentNames.join(', ')}`);
+        }
+        // Validate machine information
+        if (!args.machine?.hostname || !args.machine?.platform) {
+            throw new Error('Machine information is required. Please provide machine.hostname and machine.platform. Use os.hostname() and process.platform.');
+        }
+        // Validate repo information - check if .fraim/config.json exists and use it
+        let repoInfo = args.repo || {};
+        // Note: MCP server cannot access client-side .fraim/config.json
+        // Repository info must be provided by the client in the fraim_connect call
+        if (!repoInfo.url) {
+            throw new Error('Repository information is required. Please provide repo.url in the fraim_connect call.');
+        }
         // 1. Generate Session ID
         const sessionId = (0, crypto_1.randomUUID)();
         // userId passed from context
         const finalUserId = userId || 'unknown';
-        // 2. Create Session in DB
+        // 2. Create Session in DB with enhanced information
         const session = {
             sessionId,
             userId: finalUserId,
-            machine: args.machine || {},
-            repo: args.repo || {},
+            agent: {
+                name: args.agent.name,
+                model: args.agent.model,
+                version: args.agent.version
+            },
+            machine: args.machine,
+            repo: repoInfo,
             startTime: new Date(),
             lastActive: new Date()
         };
@@ -1503,15 +1638,32 @@ If \`.fraim/config.json\` doesn't exist:
         await this.dbService.createSession(session);
         // 3. Register in SessionManager
         this.sessionManager.registerSession(apiKey, sessionId);
+        // 4. Generate informative response
+        const agentInfo = `${args.agent.name}${args.agent.model ? ` (${args.agent.model})` : ''}${args.agent.version ? ` v${args.agent.version}` : ''}`;
+        const machineInfo = `${args.machine.hostname || 'unknown'} (${args.machine.platform || 'unknown'})`;
+        const repoInfoDisplay = repoInfo.name || repoInfo.url || 'unknown';
         return {
             content: [{
                     type: 'text',
-                    text: `✅ Connected! Session ID: ${sessionId}. Telemetry active.`
+                    text: `✅ **FRAIM Session Connected!**
+
+**Session ID**: ${sessionId}
+**Agent**: ${agentInfo}
+**Machine**: ${machineInfo}
+**Repository**: ${repoInfoDisplay}
+
+🔄 Telemetry active. All FRAIM tools are now unlocked.
+
+**Next Steps**: 
+- Use \`get_fraim_init\` to see available workflows
+- Use \`list_fraim_workflows\` to browse by category
+- Use \`get_fraim_workflow({ workflow: "name" })\` to start working`
                 }],
             sessionId: sessionId
         };
     }
     async handleSeekCoachingOnNextStep(args) {
+        console.log('🔧 MCP Server: handleSeekCoachingOnNextStep called with args:', JSON.stringify(args, null, 2));
         try {
             const response = await this.aiCoach.handleCoachingRequest({
                 workflowType: args.workflowType,
@@ -1521,6 +1673,7 @@ If \`.fraim/config.json\` doesn't exist:
                 evidence: args.evidence,
                 findings: args.findings
             });
+            console.log('✅ MCP Server: AI Coach returned response, length:', response.length);
             return {
                 content: [{
                         type: 'text',
@@ -1557,6 +1710,14 @@ If \`.fraim/config.json\` doesn't exist:
             throw error;
         }
     }
+    detectProviderFromUrl(url) {
+        if (!url)
+            return 'github';
+        if (url.includes('dev.azure.com') || url.includes('visualstudio.com')) {
+            return 'ado';
+        }
+        return 'github';
+    }
 }
 exports.FraimMCPServer = FraimMCPServer;
 // Start the server if this file is run directly

package/dist/src/utils/git-utils.js

@@ -4,6 +4,7 @@ exports.getPort = getPort;
 exports.determineDatabaseName = determineDatabaseName;
 exports.getCurrentGitBranch = getCurrentGitBranch;
 exports.determineSchema = determineSchema;
+exports.getDefaultBranch = getDefaultBranch;
 exports.getGitRemoteInfo = getGitRemoteInfo;
 const child_process_1 = require("child_process");
 /**
@@ -47,7 +48,10 @@ function determineDatabaseName() {
  */
 function getCurrentGitBranch() {
     try {
-        return (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD').toString().trim();
+        return (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD', {
+            timeout: 2000, // 2 second timeout
+            stdio: 'pipe'
+        }).toString().trim();
     }
     catch (e) {
         return 'master';
@@ -63,12 +67,42 @@ function determineSchema(branchName) {
     }
     return 'prod';
 }
+/**
+ * Gets the default branch name from git remote
+ */
+function getDefaultBranch() {
+    try {
+        // Try to get the default branch from remote HEAD
+        const remoteHead = (0, child_process_1.execSync)('git symbolic-ref refs/remotes/origin/HEAD', {
+            timeout: 2000, // 2 second timeout
+            stdio: 'pipe'
+        }).toString().trim();
+        const match = remoteHead.match(/refs\/remotes\/origin\/(.+)$/);
+        if (match) {
+            return match[1];
+        }
+    }
+    catch (e) {
+        // If that fails, try to get it from the current branch
+        try {
+            return getCurrentGitBranch();
+        }
+        catch (e2) {
+            // Fall back to common defaults
+        }
+    }
+    // Default fallback
+    return 'main';
+}
 /**
  * Gets the GitHub remote info (owner and repo name)
  */
 function getGitRemoteInfo() {
     try {
-        const remoteUrl = (0, child_process_1.execSync)('git remote get-url origin').toString().trim();
+        const remoteUrl = (0, child_process_1.execSync)('git remote get-url origin', {
+            timeout: 2000, // 2 second timeout
+            stdio: 'pipe'
+        }).toString().trim();
         // Match both HTTPS and SSH formats
         // HTTPS: https://github.com/owner/repo.git OR https://github.com/owner/repo
         // SSH: git@github.com:owner/repo.git OR git@github.com:owner/repo
@@ -76,7 +110,8 @@ function getGitRemoteInfo() {
         if (match) {
             return {
                 owner: match[1],
-                repo: match[2]
+                repo: match[2],
+                defaultBranch: getDefaultBranch()
             };
         }
     }

package/dist/src/utils/platform-detection.js

@@ -0,0 +1,213 @@
+"use strict";
+/**
+ * Platform Detection Utilities
+ *
+ * Detects development platform (GitHub, ADO) from git remote URLs
+ * and provides repository information extraction.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectPlatformFromGit = detectPlatformFromGit;
+exports.getGitRemoteUrl = getGitRemoteUrl;
+exports.detectPlatformFromUrl = detectPlatformFromUrl;
+exports.validateRepositoryConfig = validateRepositoryConfig;
+exports.getCurrentBranch = getCurrentBranch;
+exports.isGitRepository = isGitRepository;
+const child_process_1 = require("child_process");
+/**
+ * Detect platform from git remote URL
+ */
+function detectPlatformFromGit() {
+    try {
+        const remoteUrl = getGitRemoteUrl();
+        if (!remoteUrl) {
+            return { provider: 'unknown', confidence: 'low' };
+        }
+        return detectPlatformFromUrl(remoteUrl);
+    }
+    catch (error) {
+        console.warn('⚠️ Failed to detect platform from git:', error);
+        return { provider: 'unknown', confidence: 'low' };
+    }
+}
+/**
+ * Get git remote URL
+ */
+function getGitRemoteUrl() {
+    try {
+        // Try origin first
+        const originUrl = (0, child_process_1.execSync)('git remote get-url origin', {
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore']
+        }).trim();
+        if (originUrl)
+            return originUrl;
+    }
+    catch (e) {
+        // Ignore error, try alternative methods
+    }
+    try {
+        // Try any remote
+        const remotes = (0, child_process_1.execSync)('git remote', {
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore']
+        }).trim().split('\n');
+        if (remotes.length > 0 && remotes[0]) {
+            const firstRemoteUrl = (0, child_process_1.execSync)(`git remote get-url ${remotes[0]}`, {
+                encoding: 'utf-8',
+                stdio: ['ignore', 'pipe', 'ignore']
+            }).trim();
+            return firstRemoteUrl;
+        }
+    }
+    catch (e) {
+        // Ignore error
+    }
+    return null;
+}
+/**
+ * Detect platform from URL
+ */
+function detectPlatformFromUrl(url) {
+    const normalizedUrl = url.toLowerCase();
+    // GitHub detection
+    if (normalizedUrl.includes('github.com')) {
+        const repository = extractGitHubInfo(url);
+        return {
+            provider: 'github',
+            repository,
+            confidence: 'high'
+        };
+    }
+    // ADO detection
+    if (normalizedUrl.includes('dev.azure.com') ||
+        normalizedUrl.includes('visualstudio.com') ||
+        normalizedUrl.includes('azure.com')) {
+        const repository = extractAdoInfo(url);
+        return {
+            provider: 'ado',
+            repository,
+            confidence: 'high'
+        };
+    }
+    return { provider: 'unknown', confidence: 'low' };
+}
+/**
+ * Extract GitHub repository information from URL
+ */
+function extractGitHubInfo(url) {
+    // Handle both HTTPS and SSH URLs
+    // HTTPS: https://github.com/owner/repo.git
+    // SSH: git@github.com:owner/repo.git
+    let match;
+    // HTTPS format
+    match = url.match(/github\.com[\/:]([^\/]+)\/([^\/\.]+)/i);
+    if (match) {
+        return {
+            provider: 'github',
+            owner: match[1],
+            name: match[2],
+            url: url,
+            defaultBranch: 'main'
+        };
+    }
+    // Fallback - just mark as GitHub
+    return {
+        provider: 'github',
+        url: url,
+        defaultBranch: 'main'
+    };
+}
+/**
+ * Extract ADO repository information from URL
+ */
+function extractAdoInfo(url) {
+    // ADO URL formats:
+    // https://dev.azure.com/organization/project/_git/repository
+    // https://organization.visualstudio.com/project/_git/repository
+    let match;
+    // dev.azure.com format
+    match = url.match(/dev\.azure\.com\/([^\/]+)\/([^\/]+)\/_git\/([^\/\.]+)/i);
+    if (match) {
+        return {
+            provider: 'ado',
+            organization: match[1],
+            project: match[2],
+            name: match[3],
+            url: url,
+            defaultBranch: 'main'
+        };
+    }
+    // visualstudio.com format
+    match = url.match(/([^\.]+)\.visualstudio\.com\/([^\/]+)\/_git\/([^\/\.]+)/i);
+    if (match) {
+        return {
+            provider: 'ado',
+            organization: match[1],
+            project: match[2],
+            name: match[3],
+            url: url,
+            defaultBranch: 'main'
+        };
+    }
+    // Fallback - just mark as ADO
+    return {
+        provider: 'ado',
+        url: url,
+        defaultBranch: 'main'
+    };
+}
+/**
+ * Validate repository configuration
+ */
+function validateRepositoryConfig(config) {
+    const errors = [];
+    if (!config.provider) {
+        errors.push('Provider is required');
+    }
+    if (config.provider === 'github') {
+        if (!config.owner)
+            errors.push('GitHub owner is required');
+        if (!config.name)
+            errors.push('GitHub repository name is required');
+    }
+    if (config.provider === 'ado') {
+        if (!config.organization)
+            errors.push('ADO organization is required');
+        if (!config.project)
+            errors.push('ADO project is required');
+        if (!config.name)
+            errors.push('ADO repository name is required');
+    }
+    return {
+        valid: errors.length === 0,
+        errors
+    };
+}
+/**
+ * Get current git branch
+ */
+function getCurrentBranch() {
+    try {
+        return (0, child_process_1.execSync)('git branch --show-current', {
+            encoding: 'utf-8',
+            stdio: ['ignore', 'pipe', 'ignore']
+        }).trim();
+    }
+    catch (e) {
+        return null;
+    }
+}
+/**
+ * Check if we're in a git repository
+ */
+function isGitRepository() {
+    try {
+        (0, child_process_1.execSync)('git rev-parse --git-dir', {
+            stdio: ['ignore', 'ignore', 'ignore']
+        });
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}