git-devflow 1.0.0

package/dist/services/copilot.js

@@ -0,0 +1,456 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CopilotService = void 0;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("./config");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+/** Models that are included with paid plans and don't consume premium requests. */
+const FREE_MODELS = ['gpt-4.1', 'gpt-5-mini'];
+const FREE_FALLBACK_MODEL = FREE_MODELS[0];
+/** Patterns that indicate the user has exceeded their premium request quota. */
+const QUOTA_ERROR_PATTERNS = [
+    /premium request/i,
+    /rate limit/i,
+    /quota/i,
+    /exceeded.*allowance/i,
+    /budget.*reached/i,
+    /limit.*reached/i,
+    /too many requests/i,
+    /429/,
+];
+const MODEL_CATALOG = {
+    // Free / included models
+    'gpt-4.1': { tag: 'Free', description: 'Included with your plan, no extra cost', multiplier: 0 },
+    'gpt-5-mini': { tag: 'Free', description: 'Included with your plan, fast and lightweight', multiplier: 0 },
+    // Cheap & fast
+    'claude-haiku-4.5': { tag: 'Cheap', description: 'Fastest responses, very low cost', multiplier: 0.33 },
+    'gpt-5.1-codex-mini': { tag: 'Cheap', description: 'Fast code generation, very low cost', multiplier: 0.33 },
+    // Balanced
+    'claude-sonnet-4': { tag: 'Balanced', description: 'Good quality, standard cost', multiplier: 1 },
+    'claude-sonnet-4.5': { tag: 'Balanced', description: 'Great quality and speed, recommended', multiplier: 1 },
+    'gpt-5': { tag: 'Balanced', description: 'Solid all-rounder, standard cost', multiplier: 1 },
+    'gpt-5.1': { tag: 'Balanced', description: 'Latest GPT, good quality, standard cost', multiplier: 1 },
+    'gpt-5.1-codex': { tag: 'Balanced', description: 'Optimized for code, standard cost', multiplier: 1 },
+    'gpt-5.1-codex-max': { tag: 'Balanced', description: 'Max context for code, standard cost', multiplier: 1 },
+    'gpt-5.2': { tag: 'Balanced', description: 'Newest GPT, standard cost', multiplier: 1 },
+    'gpt-5.2-codex': { tag: 'Balanced', description: 'Newest GPT for code, standard cost', multiplier: 1 },
+    'gemini-3-pro-preview': { tag: 'Balanced', description: 'Google model, good for general tasks', multiplier: 1 },
+    // Expensive / highest quality
+    'claude-opus-4.5': { tag: 'Expensive', description: 'Best quality, slowest, costs 3x per prompt', multiplier: 3 },
+};
+class CopilotService {
+    /**
+     * Fetches available models from the Copilot CLI by parsing `copilot --help` output,
+     * enriched with cost/multiplier metadata from GitHub's published rates.
+     * Falls back to a minimal hardcoded list if the CLI is unavailable or parsing fails.
+     */
+    async fetchAvailableModels() {
+        let modelIds;
+        try {
+            const { stdout } = await execAsync('copilot --help', {
+                timeout: 10000,
+                shell: '/bin/bash'
+            });
+            // Extract model choices from the --model flag description
+            // Format: --model <model>  Set the AI model to use (choices: "model1", "model2", ...)
+            const modelSection = stdout.match(/--model\s+<model>\s+[\s\S]*?\(choices:\s*([\s\S]*?)\)/);
+            if (modelSection) {
+                const parsed = modelSection[1]
+                    .match(/"([^"]+)"/g)
+                    ?.map(m => m.replace(/"/g, ''));
+                modelIds = parsed && parsed.length > 0 ? parsed : this.getFallbackModelIds();
+            }
+            else {
+                modelIds = this.getFallbackModelIds();
+            }
+        }
+        catch {
+            modelIds = this.getFallbackModelIds();
+        }
+        return modelIds.map(id => {
+            const info = MODEL_CATALOG[id];
+            return {
+                id,
+                tag: info?.tag ?? 'New',
+                description: info?.description ?? 'Recently added model',
+            };
+        });
+    }
+    getFallbackModelIds() {
+        return [
+            'claude-sonnet-4.5',
+            'claude-haiku-4.5',
+            'gpt-4.1'
+        ];
+    }
+    /**
+     * Prints the model name and its cost before a Copilot call.
+     */
+    printModelCost(model) {
+        const meta = MODEL_CATALOG[model];
+        const tag = meta?.tag ?? 'Unknown';
+        const multiplier = meta?.multiplier;
+        let costStr;
+        if (multiplier === 0)
+            costStr = chalk_1.default.green('free, no premium requests used');
+        else if (multiplier !== undefined)
+            costStr = chalk_1.default.yellow(`${multiplier} premium request(s) per prompt`);
+        else
+            costStr = chalk_1.default.dim('unknown cost');
+        const tagColor = tag === 'Free' ? chalk_1.default.green(tag) :
+            tag === 'Cheap' ? chalk_1.default.cyan(tag) :
+                tag === 'Balanced' ? chalk_1.default.yellow(tag) :
+                    tag === 'Expensive' ? chalk_1.default.red(tag) :
+                        chalk_1.default.dim(tag);
+        console.log(`🤖 Model: ${chalk_1.default.bold(model)}  ${tagColor}  ·  ${costStr}`);
+    }
+    /**
+     * Checks whether an error from the Copilot CLI looks like a quota/rate-limit issue.
+     */
+    isQuotaError(error) {
+        const msg = error.message || '';
+        return QUOTA_ERROR_PATTERNS.some(p => p.test(msg));
+    }
+    /**
+     * Prints a user-friendly warning when quota is exceeded and we're retrying
+     * with a free model.
+     */
+    printQuotaWarning(currentModel) {
+        console.log('');
+        console.log(chalk_1.default.yellow('⚠️  Premium request limit reached for ') + chalk_1.default.bold(currentModel));
+        console.log(chalk_1.default.dim('   Your monthly quota may be exhausted or the model is rate-limited.'));
+        console.log(chalk_1.default.cyan(`   Retrying with ${FREE_FALLBACK_MODEL} (free, no premium requests)...\n`));
+        this.printModelCost(FREE_FALLBACK_MODEL);
+    }
+    /**
+     * Prints a tip after a successful free-model retry so the user knows
+     * how to permanently switch.
+     */
+    printSwitchTip() {
+        console.log(chalk_1.default.dim(`\n   Tip: To avoid this, switch your default model:`));
+        console.log(chalk_1.default.dim(`   Run: `) + chalk_1.default.cyan('devflow config setup') + chalk_1.default.dim(' and pick a Free model.\n'));
+    }
+    /**
+     * Runs a prompt against the Copilot CLI with the given model.
+     * Returns stdout on success, or throws on failure.
+     */
+    async execCopilotPrompt(prompt, model) {
+        try {
+            // Build args array — passed directly to the binary, no shell interpretation.
+            // This avoids issues with $, backticks, quotes etc. in diff content.
+            const args = [];
+            if (model) {
+                args.push('--model', model);
+            }
+            args.push('-s', '--prompt', prompt);
+            const { stdout } = await execFileAsync('copilot', args, {
+                maxBuffer: 1024 * 1024,
+                timeout: 60000,
+            });
+            return stdout;
+        }
+        catch (error) {
+            // Build a safe error message without leaking sensitive data
+            const stderr = (error.stderr || '').trim();
+            const code = error.code;
+            const exitCode = error.status ?? error.code;
+            if (code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER') {
+                throw new Error('Copilot response exceeded buffer size');
+            }
+            if (error.killed) {
+                throw new Error('Copilot request timed out (60s). Try a faster model like gpt-4.1 or claude-haiku-4.5');
+            }
+            // Pass through stderr if it's short and doesn't contain secrets
+            const safeStderr = stderr.length > 0 && stderr.length < 200 && !/token|auth|key|secret|password/i.test(stderr)
+                ? stderr
+                : `exit code ${exitCode || 'unknown'}`;
+            throw new Error(`Copilot CLI error: ${safeStderr}`);
+        }
+    }
+    /**
+     * Runs a prompt with the user's configured model.
+     * Shows cost info before the call.
+     * If a quota/rate-limit error is detected, automatically retries with a free model.
+     */
+    async execWithQuotaRetry(prompt) {
+        const configService = new config_1.ConfigService();
+        const model = configService.getCopilotModel();
+        const isFreeModel = FREE_MODELS.includes(model);
+        // Show model + cost before making the call
+        this.printModelCost(model);
+        console.log('');
+        try {
+            return await this.execCopilotPrompt(prompt, model);
+        }
+        catch (error) {
+            // If already on a free model, no point retrying — just throw
+            if (isFreeModel)
+                throw error;
+            // If it looks like a quota issue, retry with the free model
+            if (this.isQuotaError(error)) {
+                this.printQuotaWarning(model);
+                const result = await this.execCopilotPrompt(prompt, FREE_FALLBACK_MODEL);
+                this.printSwitchTip();
+                return result;
+            }
+            // Some other error — let it bubble up
+            throw error;
+        }
+    }
+    async generateCommitMessage(diff) {
+        try {
+            const prompt = `Generate 3 commit messages for these git changes. Use conventional commits format (feat/fix/chore/etc).
+  
+  Changes:
+  ${diff.substring(0, 2000)}
+  
+  Respond with 3 options:
+  1. [first message]
+  2. [second message]
+  3. [third message]
+  
+  Keep each under 72 characters.`;
+            const stdout = await this.execWithQuotaRetry(prompt);
+            // Parse messages
+            const messages = this.parseCommitMessages(stdout);
+            if (messages.length > 0) {
+                return messages;
+            }
+            return this.generateFallbackMessages(diff);
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : 'unknown error';
+            console.log(chalk_1.default.yellow(`⚠️  ${reason}`));
+            console.log(chalk_1.default.dim('   Using fallback suggestions\n'));
+            return this.generateFallbackMessages(diff);
+        }
+    }
+    stripMarkdown(text) {
+        return text
+            .replace(/\*\*/g, '') // Remove bold **
+            .replace(/\*/g, '') // Remove italic *
+            .replace(/`/g, '') // Remove code `
+            .replace(/^[-•]\s+/, '') // Remove list markers
+            .trim();
+    }
+    parseCommitMessages(response) {
+        const messages = [];
+        // Split by lines
+        const lines = response
+            .split('\n')
+            .map(l => l.trim())
+            .filter(l => l.length > 0);
+        for (const line of lines) {
+            // Try multiple patterns
+            // Pattern 1: "1. message" or "1) message"
+            let match = line.match(/^\d+[\.)]\s*(.+)$/);
+            if (match) {
+                messages.push(this.stripMarkdown(match[1].trim()));
+                continue;
+            }
+            // Pattern 2: Direct conventional commit format
+            match = line.match(/^(feat|fix|docs|style|refactor|test|chore|perf|ci|build)(\(.+?\))?: .+/i);
+            if (match) {
+                messages.push(this.stripMarkdown(line));
+                continue;
+            }
+            // Pattern 3: "- message" (markdown list)
+            match = line.match(/^[-*]\s+(.+)$/);
+            if (match && match[1].match(/^(feat|fix|docs|style|refactor|test|chore)/i)) {
+                messages.push(this.stripMarkdown(match[1].trim()));
+                continue;
+            }
+        }
+        return messages.slice(0, 3);
+    }
+    generateFallbackMessages(diff) {
+        const lines = diff.split('\n');
+        const added = lines.filter(l => l.startsWith('+')).length;
+        const removed = lines.filter(l => l.startsWith('-')).length;
+        return [
+            `feat: update files (+${added} -${removed})`,
+            `fix: improve code quality`,
+            `chore: update documentation`
+        ];
+    }
+    async generatePRDescription(commits, issueContext = '') {
+        try {
+            const commitList = commits.map(c => `- ${c.message}`).join('\n');
+            const prompt = `Generate a PR title and description for these commits:\n${commitList}\n\nFormat:\nTITLE: [title]\nBODY:\n[description]`;
+            const stdout = await this.execWithQuotaRetry(prompt);
+            // Parse response
+            const parsed = this.parsePRDescription(stdout);
+            if (parsed.title && parsed.body && parsed.body.length > 50) {
+                return parsed;
+            }
+            // If parsing gave weak results, use fallback
+            console.log('⚠️ Weak response, using fallback\n');
+            return this.generateSmartFallback(commits, issueContext);
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : 'unknown error';
+            console.log(chalk_1.default.yellow(`⚠️  ${reason}`));
+            console.log(chalk_1.default.dim('   Using fallback PR description\n'));
+            return this.generateSmartFallback(commits, issueContext);
+        }
+    }
+    generateSmartFallback(commits, issueContext) {
+        // Use first commit as title if it's good
+        const title = commits[0]?.message || 'Update';
+        // Group commits by type
+        const features = commits.filter(c => c.message.startsWith('feat'));
+        const fixes = commits.filter(c => c.message.startsWith('fix'));
+        const chores = commits.filter(c => c.message.startsWith('chore'));
+        const others = commits.filter(c => !c.message.match(/^(feat|fix|chore)/));
+        let body = '## Summary\n\n';
+        if (commits.length === 1) {
+            body += commits[0].message;
+        }
+        else {
+            body += `This PR includes ${commits.length} commits with `;
+            const types = [];
+            if (features.length)
+                types.push(`${features.length} feature(s)`);
+            if (fixes.length)
+                types.push(`${fixes.length} fix(es)`);
+            if (chores.length)
+                types.push(`${chores.length} chore(s)`);
+            body += types.join(', ') || 'various changes';
+            body += '.';
+        }
+        body += '\n\n## Changes\n\n';
+        if (features.length) {
+            body += '### Features\n';
+            features.forEach(c => body += `- ${c.message}\n`);
+            body += '\n';
+        }
+        if (fixes.length) {
+            body += '### Fixes\n';
+            fixes.forEach(c => body += `- ${c.message}\n`);
+            body += '\n';
+        }
+        if (chores.length) {
+            body += '### Chores\n';
+            chores.forEach(c => body += `- ${c.message}\n`);
+            body += '\n';
+        }
+        if (others.length) {
+            body += '### Other Changes\n';
+            others.forEach(c => body += `- ${c.message}\n`);
+            body += '\n';
+        }
+        if (issueContext) {
+            body += `\n${issueContext}\n`;
+        }
+        body += '\n## Testing\n\nPlease test these changes in your environment.\n';
+        return { title, body };
+    }
+    parsePRDescription(response) {
+        // Try to extract title and body
+        const titleMatch = response.match(/TITLE:\s*(.+)/i);
+        const bodyMatch = response.match(/BODY:\s*([\s\S]+)/i);
+        if (titleMatch && bodyMatch) {
+            return {
+                title: this.stripMarkdown(titleMatch[1].trim()),
+                body: bodyMatch[1].trim()
+            };
+        }
+        // If parsing fails, use first line as title, rest as body
+        const lines = response.split('\n').filter(l => l.trim().length > 0);
+        return {
+            title: this.stripMarkdown(lines[0] || 'Update'),
+            body: lines.slice(1).join('\n') || 'Pull request description'
+        };
+    }
+    generateFallbackPR(commits, issueContext) {
+        const title = commits[0]?.message || 'Update code';
+        const body = `## Summary
+This PR includes ${commits.length} commit(s).
+
+## Changes
+${commits.map(c => `- ${c.message}`).join('\n')}
+
+${issueContext ? `## Related Issues\n${issueContext}` : ''}
+
+## Testing
+Please test the changes thoroughly.`;
+        return { title, body };
+    }
+    async generateBranchName(description, type = 'feature', issueNumber) {
+        try {
+            const issuePrefix = issueNumber ? `${issueNumber}-` : '';
+            const prompt = `Generate a git branch name from this description: "${description}"
+  
+  Branch type: ${type}
+  ${issueNumber ? `Issue number: ${issueNumber}` : ''}
+  
+  Rules:
+  - Use format: ${type}/${issuePrefix}[descriptive-name]
+  - Use kebab-case (lowercase with hyphens)
+  - Keep it concise (max 50 chars)
+  - Be descriptive but brief
+  - Only alphanumeric and hyphens
+  
+  Example: feature/123-add-user-auth
+  
+  Respond with ONLY the branch name, nothing else.`;
+            const stdout = await this.execWithQuotaRetry(prompt);
+            // Parse the branch name from response
+            let branchName = stdout.trim().split('\n')[0].trim();
+            // Remove any markdown formatting
+            branchName = branchName.replace(/```/g, '').replace(/`/g, '').trim();
+            // Remove quotes if present
+            branchName = branchName.replace(/^["']|["']$/g, '');
+            // Validate and sanitize
+            branchName = this.sanitizeBranchName(branchName, type, issuePrefix);
+            return branchName;
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : 'unknown error';
+            console.log(chalk_1.default.yellow(`⚠️  ${reason}`));
+            console.log(chalk_1.default.dim('   Using fallback branch name\n'));
+            return this.generateFallbackBranchName(description, type, issueNumber);
+        }
+    }
+    // Sanitize branch name
+    sanitizeBranchName(name, type, issuePrefix) {
+        // Remove type prefix if Copilot added it
+        name = name.replace(new RegExp(`^${type}/`, 'i'), '');
+        // Convert to lowercase and replace spaces/special chars with hyphens
+        name = name
+            .toLowerCase()
+            .replace(/[^a-z0-9-]/g, '-')
+            .replace(/-+/g, '-')
+            .replace(/^-|-$/g, '');
+        // Limit length
+        const maxLength = 50 - type.length - issuePrefix.length - 1;
+        if (name.length > maxLength) {
+            name = name.substring(0, maxLength).replace(/-$/, '');
+        }
+        return `${type}/${issuePrefix}${name}`;
+    }
+    // Fallback branch name generation
+    generateFallbackBranchName(description, type, issueNumber) {
+        const issuePrefix = issueNumber ? `${issueNumber}-` : '';
+        // Convert description to kebab-case
+        let name = description
+            .toLowerCase()
+            .replace(/[^a-z0-9\s-]/g, '')
+            .replace(/\s+/g, '-')
+            .replace(/-+/g, '-')
+            .replace(/^-|-$/g, '');
+        // Limit length
+        const maxLength = 50 - type.length - issuePrefix.length - 1;
+        if (name.length > maxLength) {
+            name = name.substring(0, maxLength).replace(/-$/, '');
+        }
+        return `${type}/${issuePrefix}${name}`;
+    }
+}
+exports.CopilotService = CopilotService;

package/dist/services/git.js

@@ -0,0 +1,133 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitService = void 0;
+const simple_git_1 = __importDefault(require("simple-git"));
+class GitService {
+    constructor() {
+        this.git = (0, simple_git_1.default)();
+    }
+    // Check if we're in a git repository
+    async isGitRepo() {
+        try {
+            await this.git.status();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    // Get staged changes (git diff --cached)
+    async getStagedDiff() {
+        try {
+            const diff = await this.git.diff(['--cached']);
+            return diff;
+        }
+        catch (error) {
+            throw new Error('Failed to get staged changes');
+        }
+    }
+    // Get status
+    async getStatus() {
+        return await this.git.status();
+    }
+    // Stage all changes
+    async stageAll() {
+        await this.git.add('.');
+    }
+    // Create commit
+    async commit(message) {
+        await this.git.commit(message);
+    }
+    // Check if there are staged changes
+    async hasStagedChanges() {
+        const status = await this.getStatus();
+        return status.staged.length > 0;
+    }
+    // Get current branch name
+    async getCurrentBranch() {
+        const status = await this.git.status();
+        return status.current || 'main';
+    }
+    // Get base branch (usually main or master)
+    async getBaseBranch() {
+        try {
+            // Try to find main first
+            await this.git.raw(['rev-parse', '--verify', 'main']);
+            return 'main';
+        }
+        catch {
+            try {
+                // Fall back to master
+                await this.git.raw(['rev-parse', '--verify', 'master']);
+                return 'master';
+            }
+            catch {
+                return 'main'; // Default to main
+            }
+        }
+    }
+    // Get commits in current branch (not in base branch)
+    async getCommitsSinceBase() {
+        const currentBranch = await this.getCurrentBranch();
+        const baseBranch = await this.getBaseBranch();
+        try {
+            const log = await this.git.log({
+                from: baseBranch,
+                to: currentBranch
+            });
+            return log.all.map(commit => ({
+                hash: commit.hash.substring(0, 7),
+                message: commit.message,
+                author: commit.author_name,
+                date: commit.date
+            }));
+        }
+        catch (error) {
+            throw new Error('Failed to get commit history');
+        }
+    }
+    // Extract issue number from branch name or commits
+    extractIssueNumber() {
+        // Try to extract from branch name (e.g., feature/add-auth-123)
+        const branchMatch = this.git.branch().then(b => b.current?.match(/-(\d+)$/));
+        // For now, return null (we'll enhance this later)
+        return null;
+    }
+    // Check if current branch exists on remote
+    async isBranchPushed(branchName) {
+        try {
+            const result = await this.git.raw(['ls-remote', '--heads', 'origin', branchName]);
+            return result.trim().length > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    // Push current branch to remote
+    async pushBranch(branchName) {
+        await this.git.push('origin', branchName, ['--set-upstream']);
+    }
+    // Create and checkout a new branch
+    async createAndCheckoutBranch(branchName) {
+        try {
+            await this.git.checkoutLocalBranch(branchName);
+        }
+        catch (error) {
+            throw new Error(`Failed to create branch: ${error.message}`);
+        }
+    }
+    // Check if branch already exists
+    async branchExists(branchName) {
+        try {
+            const branches = await this.git.branchLocal();
+            return branches.all.includes(branchName);
+        }
+        catch {
+            return false;
+        }
+    }
+}
+exports.GitService = GitService;