@andrebuzeli/git-mcp 4.0.20 → 4.0.21

package/dist/tools/git-issues.js

@@ -1,688 +1,14 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.gitIssuesTool = void 0;
-const zod_1 = require("zod");
 const auto_detection_js_1 = require("../utils/auto-detection.js");
-const error_handler_js_1 = require("../utils/error-handler.js");
-/**
- * Tool: git-issues
- *
- * SISTEMA DE ISSUES PARA DESENVOLVEDOR INDIVIDUAL
- * Issues locais inteligentes para tracking de tarefas e TODOs
- *
- * DESIGNED FOR: Programador individual autônomo
- * PHILOSOPHY: Issues simples e locais para produtividade pessoal
- */
-const GitIssuesInputSchema = zod_1.z.discriminatedUnion('action', [
-    // CREATE ISSUE - Criação inteligente
-    zod_1.z.object({
-        action: zod_1.z.literal('create'),
-        projectPath: zod_1.z.string(),
-        title: zod_1.z.string(),
-        description: zod_1.z.string().optional(),
-        labels: zod_1.z.array(zod_1.z.string()).optional(), // priority, bug, feature, todo, etc.
-        priority: zod_1.z.enum(['low', 'medium', 'high', 'urgent']).default('medium'),
-        assignee: zod_1.z.string().optional(), // Auto-detect user
-        dueDate: zod_1.z.string().optional() // ISO date string
-    }),
-    // LIST ISSUES - Listagem com filtros
-    zod_1.z.object({
-        action: zod_1.z.literal('list'),
-        projectPath: zod_1.z.string(),
-        state: zod_1.z.enum(['open', 'closed', 'all']).default('all'),
-        labels: zod_1.z.array(zod_1.z.string()).optional(),
-        priority: zod_1.z.enum(['low', 'medium', 'high', 'urgent']).optional(),
-        limit: zod_1.z.number().default(20),
-        sort: zod_1.z.enum(['created', 'updated', 'priority', 'due_date']).default('created')
-    }),
-    // GET ISSUE - Detalhes específicos
-    zod_1.z.object({
-        action: zod_1.z.literal('get'),
-        projectPath: zod_1.z.string(),
-        id: zod_1.z.string(), // Issue ID
-        detailed: zod_1.z.boolean().default(false)
-    }),
-    // UPDATE ISSUE - Atualização
-    zod_1.z.object({
-        action: zod_1.z.literal('update'),
-        projectPath: zod_1.z.string(),
-        id: zod_1.z.string(),
-        title: zod_1.z.string().optional(),
-        description: zod_1.z.string().optional(),
-        state: zod_1.z.enum(['open', 'closed']).optional(),
-        labels: zod_1.z.array(zod_1.z.string()).optional(),
-        priority: zod_1.z.enum(['low', 'medium', 'high', 'urgent']).optional(),
-        assignee: zod_1.z.string().optional(),
-        dueDate: zod_1.z.string().optional()
-    }),
-    // CLOSE ISSUE - Fechamento
-    zod_1.z.object({
-        action: zod_1.z.literal('close'),
-        projectPath: zod_1.z.string(),
-        id: zod_1.z.string(),
-        comment: zod_1.z.string().optional()
-    }),
-    // SCAN CODE - Auto-detect TODOs/FIXMEs
-    zod_1.z.object({
-        action: zod_1.z.literal('scan'),
-        projectPath: zod_1.z.string(),
-        createIssues: zod_1.z.boolean().default(false), // Auto-create issues from TODOs
-        patterns: zod_1.z.array(zod_1.z.string()).optional() // Custom patterns to scan
-    })
-]);
-/**
- * Local Issue Manager
- * Gerencia issues locais em arquivos JSON
- */
-class LocalIssueManager {
-    static ISSUES_DIR = '.git/issues';
-    static ISSUES_FILE = 'issues.json';
-    static async ensureIssuesDirectory(projectPath) {
-        const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
-        try {
-            await fs.access(`${projectPath}/${this.ISSUES_DIR}`);
-        }
-        catch (e) {
-            await fs.mkdir(`${projectPath}/${this.ISSUES_DIR}`, { recursive: true });
-        }
-    }
-    static async loadIssues(projectPath) {
-        const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
-        try {
-            await this.ensureIssuesDirectory(projectPath);
-            const content = await fs.readFile(`${projectPath}/${this.ISSUES_DIR}/${this.ISSUES_FILE}`, 'utf-8');
-            const data = JSON.parse(content);
-            return Array.isArray(data.issues) ? data.issues : [];
-        }
-        catch (e) {
-            return [];
-        }
-    }
-    static async saveIssues(projectPath, issues) {
-        const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
-        await this.ensureIssuesDirectory(projectPath);
-        const data = {
-            version: '1.0',
-            lastUpdated: new Date().toISOString(),
-            issues: issues
-        };
-        await fs.writeFile(`${projectPath}/${this.ISSUES_DIR}/${this.ISSUES_FILE}`, JSON.stringify(data, null, 2), 'utf-8');
-    }
-    static generateIssueId() {
-        return `I-${Date.now()}-${Math.random().toString(36).substr(2, 6)}`;
-    }
-    static parseTodoComment(line, filePath, lineNumber) {
-        // Parse TODO/FIXME comments
-        const todoMatch = line.match(/(?:\/\/|#|--|\/\*)\s*(TODO|FIXME|BUG|HACK|NOTE):\s*(.+)/i);
-        if (!todoMatch)
-            return null;
-        const [, type, description] = todoMatch;
-        return {
-            type: type.toLowerCase(),
-            description: description.trim(),
-            file: filePath,
-            line: lineNumber,
-            raw: line.trim()
-        };
-    }
-    static createIssueFromTodo(todo, projectPath) {
-        const labels = [todo.type];
-        let priority = 'medium';
-        let title = todo.description;
-        // Determine priority based on type
-        if (todo.type === 'bug') {
-            priority = 'high';
-            labels.push('bug');
-        }
-        else if (todo.type === 'hack') {
-            priority = 'low';
-            labels.push('technical-debt');
-        }
-        // Create meaningful title
-        if (title.length > 80) {
-            title = title.substring(0, 77) + '...';
-        }
-        const description = `**Arquivo:** \`${todo.file}:${todo.line}\`\n\n**Comentário original:**\n\`\`\`\n${todo.raw}\n\`\`\`\n\n*Issue criada automaticamente a partir de comentário no código.*`;
-        return {
-            id: this.generateIssueId(),
-            title,
-            description,
-            state: 'open',
-            labels,
-            priority,
-            assignee: null,
-            createdAt: new Date().toISOString(),
-            updatedAt: new Date().toISOString(),
-            dueDate: null,
-            comments: [],
-            source: {
-                type: 'code-scan',
-                file: todo.file,
-                line: todo.line,
-                originalComment: todo.raw
-            }
-        };
-    }
-}
-/**
- * Code Scanner
- * Escaneia código em busca de TODOs/FIXMEs
- */
-class CodeScanner {
-    static async scanForTodos(projectPath, customPatterns) {
-        const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
-        const path = await Promise.resolve().then(() => __importStar(require('path')));
-        const todos = [];
-        // Default patterns
-        const patterns = customPatterns || [
-            '**/*.js', '**/*.ts', '**/*.py', '**/*.java', '**/*.cpp', '**/*.c',
-            '**/*.php', '**/*.rb', '**/*.go', '**/*.rs', '**/*.swift',
-            '**/*.kt', '**/*.scala', '**/*.clj', '**/*.hs', '**/*.ml'
-        ];
-        // Simple file scanning (could be enhanced with glob patterns)
-        try {
-            const scanDir = async (dir) => {
-                const entries = await fs.readdir(dir, { withFileTypes: true });
-                for (const entry of entries) {
-                    const fullPath = path.join(dir, entry.name);
-                    const relativePath = path.relative(projectPath, fullPath);
-                    if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
-                        await scanDir(fullPath);
-                    }
-                    else if (entry.isFile()) {
-                        // Check if file matches patterns
-                        const shouldScan = patterns.some(pattern => {
-                            const regex = new RegExp(pattern.replace(/\*/g, '.*').replace(/\//g, '\\/'));
-                            return regex.test(relativePath);
-                        });
-                        if (shouldScan) {
-                            try {
-                                const content = await fs.readFile(fullPath, 'utf-8');
-                                const lines = content.split('\n');
-                                lines.forEach((line, index) => {
-                                    const todo = LocalIssueManager.parseTodoComment(line, relativePath, index + 1);
-                                    if (todo) {
-                                        todos.push(todo);
-                                    }
-                                });
-                            }
-                            catch (e) {
-                                // Skip files that can't be read
-                            }
-                        }
-                    }
-                }
-            };
-            await scanDir(projectPath);
-        }
-        catch (error) {
-            console.warn('Error scanning code:', error);
-        }
-        return todos;
-    }
-}
-/**
- * Classe principal para executar operações Git issues
- */
-class GitIssuesExecutor {
-    errorHandler = new error_handler_js_1.UniversalErrorHandler();
-    /**
-     * Executa operação create
-     */
-    async executeCreate(detection, input) {
-        try {
-            const issues = await LocalIssueManager.loadIssues(detection.projectPath);
-            const newIssue = {
-                id: LocalIssueManager.generateIssueId(),
-                title: input.title,
-                description: input.description || '',
-                state: 'open',
-                labels: input.labels || [],
-                priority: input.priority,
-                assignee: input.assignee || detection.owner,
-                createdAt: new Date().toISOString(),
-                updatedAt: new Date().toISOString(),
-                dueDate: input.dueDate || null,
-                comments: [],
-                source: {
-                    type: 'manual',
-                    createdBy: detection.owner
-                }
-            };
-            issues.push(newIssue);
-            await LocalIssueManager.saveIssues(detection.projectPath, issues);
-            return (0, auto_detection_js_1.createUniversalResponse)({
-                success: true,
-                action: 'create',
-                message: `Issue '${input.title}' created successfully`,
-                data: {
-                    issue: newIssue,
-                    issueId: newIssue.id
-                },
-                autoDetected: {
-                    repo: detection.repoName,
-                    owner: detection.owner,
-                    providers: detection.providers
-                }
-            });
-        }
-        catch (error) {
-            return this.errorHandler.toUniversalResponse();
-        }
-    }
-    /**
-     * Executa operação list
-     */
-    async executeList(detection, input) {
-        try {
-            const allIssues = await LocalIssueManager.loadIssues(detection.projectPath);
-            // Filter issues
-            let filteredIssues = allIssues;
-            if (input.state !== 'all') {
-                filteredIssues = filteredIssues.filter(issue => issue.state === input.state);
-            }
-            if (input.labels && input.labels.length > 0) {
-                filteredIssues = filteredIssues.filter(issue => input.labels.some((label) => issue.labels.includes(label)));
-            }
-            if (input.priority) {
-                filteredIssues = filteredIssues.filter(issue => issue.priority === input.priority);
-            }
-            // Sort issues
-            filteredIssues.sort((a, b) => {
-                switch (input.sort) {
-                    case 'updated':
-                        return new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime();
-                    case 'priority':
-                        const priorityOrder = { urgent: 4, high: 3, medium: 2, low: 1 };
-                        return priorityOrder[b.priority] - priorityOrder[a.priority];
-                    case 'due_date':
-                        if (!a.dueDate && !b.dueDate)
-                            return 0;
-                        if (!a.dueDate)
-                            return 1;
-                        if (!b.dueDate)
-                            return -1;
-                        return new Date(a.dueDate).getTime() - new Date(b.dueDate).getTime();
-                    case 'created':
-                    default:
-                        return new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime();
-                }
-            });
-            const limitedIssues = filteredIssues.slice(0, input.limit);
-            return (0, auto_detection_js_1.createUniversalResponse)({
-                success: true,
-                action: 'list',
-                message: `Found ${limitedIssues.length} issues`,
-                data: {
-                    issues: limitedIssues,
-                    total: allIssues.length,
-                    filtered: filteredIssues.length,
-                    state: input.state,
-                    labels: input.labels,
-                    priority: input.priority,
-                    sort: input.sort,
-                    limit: input.limit
-                },
-                autoDetected: {
-                    repo: detection.repoName,
-                    owner: detection.owner,
-                    providers: detection.providers
-                }
-            });
-        }
-        catch (error) {
-            return this.errorHandler.toUniversalResponse();
-        }
-    }
-    /**
-     * Executa operação get
-     */
-    async executeGet(detection, input) {
-        try {
-            const issues = await LocalIssueManager.loadIssues(detection.projectPath);
-            const issue = issues.find(i => i.id === input.id);
-            if (!issue) {
-                return (0, auto_detection_js_1.createUniversalResponse)({
-                    success: false,
-                    action: 'get',
-                    message: `Issue '${input.id}' not found`,
-                    error: {
-                        code: 'ISSUE_NOT_FOUND',
-                        message: `Issue with ID '${input.id}' does not exist`,
-                        cause: 'Issue not found in local storage',
-                        suggestion: 'Check the issue ID or list all issues to see available IDs'
-                    },
-                    autoDetected: {
-                        repo: detection.repoName,
-                        owner: detection.owner,
-                        providers: detection.providers
-                    }
-                });
-            }
-            return (0, auto_detection_js_1.createUniversalResponse)({
-                success: true,
-                action: 'get',
-                message: `Issue '${issue.title}' details`,
-                data: {
-                    issue: issue,
-                    detailed: input.detailed
-                },
-                autoDetected: {
-                    repo: detection.repoName,
-                    owner: detection.owner,
-                    providers: detection.providers
-                }
-            });
-        }
-        catch (error) {
-            return this.errorHandler.toUniversalResponse();
-        }
-    }
-    /**
-     * Executa operação update
-     */
-    async executeUpdate(detection, input) {
-        try {
-            const issues = await LocalIssueManager.loadIssues(detection.projectPath);
-            const issueIndex = issues.findIndex(i => i.id === input.id);
-            if (issueIndex === -1) {
-                throw new Error(`Issue '${input.id}' not found`);
-            }
-            const issue = issues[issueIndex];
-            const updatedIssue = {
-                ...issue,
-                ...Object.fromEntries(Object.entries(input).filter(([key, value]) => key !== 'id' && key !== 'projectPath' && key !== 'action' && value !== undefined)),
-                updatedAt: new Date().toISOString()
-            };
-            issues[issueIndex] = updatedIssue;
-            await LocalIssueManager.saveIssues(detection.projectPath, issues);
-            return (0, auto_detection_js_1.createUniversalResponse)({
-                success: true,
-                action: 'update',
-                message: `Issue '${updatedIssue.title}' updated successfully`,
-                data: {
-                    issue: updatedIssue,
-                    changes: Object.keys(input).filter(key => key !== 'id' && key !== 'projectPath' && key !== 'action')
-                },
-                autoDetected: {
-                    repo: detection.repoName,
-                    owner: detection.owner,
-                    providers: detection.providers
-                }
-            });
-        }
-        catch (error) {
-            return this.errorHandler.toUniversalResponse();
-        }
-    }
-    /**
-     * Executa operação close
-     */
-    async executeClose(detection, input) {
-        try {
-            const issues = await LocalIssueManager.loadIssues(detection.projectPath);
-            const issueIndex = issues.findIndex(i => i.id === input.id);
-            if (issueIndex === -1) {
-                throw new Error(`Issue '${input.id}' not found`);
-            }
-            const issue = issues[issueIndex];
-            // Add closing comment if provided
-            if (input.comment) {
-                issue.comments = issue.comments || [];
-                issue.comments.push({
-                    id: `C-${Date.now()}`,
-                    author: detection.owner,
-                    content: input.comment,
-                    createdAt: new Date().toISOString(),
-                    type: 'closing'
-                });
-            }
-            issue.state = 'closed';
-            issue.updatedAt = new Date().toISOString();
-            issue.closedAt = new Date().toISOString();
-            await LocalIssueManager.saveIssues(detection.projectPath, issues);
-            return (0, auto_detection_js_1.createUniversalResponse)({
-                success: true,
-                action: 'close',
-                message: `Issue '${issue.title}' closed successfully`,
-                data: {
-                    issue: issue,
-                    comment: input.comment
-                },
-                autoDetected: {
-                    repo: detection.repoName,
-                    owner: detection.owner,
-                    providers: detection.providers
-                }
-            });
-        }
-        catch (error) {
-            return this.errorHandler.toUniversalResponse();
-        }
-    }
-    /**
-     * Executa operação scan
-     */
-    async executeScan(detection, input) {
-        try {
-            const todos = await CodeScanner.scanForTodos(detection.projectPath, input.patterns);
-            let createdIssues = [];
-            if (input.createIssues && todos.length > 0) {
-                const existingIssues = await LocalIssueManager.loadIssues(detection.projectPath);
-                // Create issues for new TODOs (avoid duplicates)
-                for (const todo of todos) {
-                    const alreadyExists = existingIssues.some(issue => issue.source?.type === 'code-scan' &&
-                        issue.source.file === todo.file &&
-                        issue.source.line === todo.line &&
-                        issue.source.originalComment === todo.raw);
-                    if (!alreadyExists) {
-                        const newIssue = LocalIssueManager.createIssueFromTodo(todo, detection.projectPath);
-                        existingIssues.push(newIssue);
-                        createdIssues.push(newIssue);
-                    }
-                }
-                await LocalIssueManager.saveIssues(detection.projectPath, existingIssues);
-            }
-            return (0, auto_detection_js_1.createUniversalResponse)({
-                success: true,
-                action: 'scan',
-                message: `Found ${todos.length} TODOs/FIXMEs in code`,
-                data: {
-                    todos: todos,
-                    totalFound: todos.length,
-                    createdIssues: createdIssues.length,
-                    issuesCreated: createdIssues,
-                    createIssues: input.createIssues,
-                    patterns: input.patterns
-                },
-                autoDetected: {
-                    repo: detection.repoName,
-                    owner: detection.owner,
-                    providers: detection.providers
-                }
-            });
-        }
-        catch (error) {
-            return this.errorHandler.toUniversalResponse();
-        }
-    }
-}
-/**
- * Tool principal git-issues
- */
 exports.gitIssuesTool = {
     name: 'git-issues',
-    description: `📋 SISTEMA DE ISSUES PARA DESENVOLVEDOR INDIVIDUAL
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-🎯 ISSUES LOCAIS INTELIGENTES:
-• create: Criação de issues com prioridade e labels
-• list: Listagem com filtros avançados
-• get: Detalhes completos de issues
-• update: Atualização de status e informações
-• close: Fechamento com comentários
-• scan: Auto-detecção de TODOs/FIXMEs no código
-
-🔍 GERENCIAMENTO DE TAREFAS:
-• Sistema local (sem dependência de GitHub/Gitea)
-• Priorização automática baseada em tipo
-• Labels inteligentes (bug, feature, todo, etc.)
-• Auto-detecção de TODOs no código
-• Rastreamento de progresso
-
-⚡ PRODUTIVIDADE PESSOAL:
-• Issues criadas automaticamente de comentários
-• Sistema de prioridades (urgent, high, medium, low)
-• Datas de vencimento e responsáveis
-• Histórico completo de mudanças
-• Integração com workflow pessoal
-
-🤖 COMPATÍVEL COM AI AGENTS:
-• Interface universal para qualquer IDE
-• Auto-detecção completa de contexto
-• Respostas estruturadas consistentes
-• Error handling inteligente
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`,
-    inputSchema: {
-        type: 'object',
-        properties: {
-            action: {
-                type: 'string',
-                enum: ['create', 'list', 'get', 'update', 'close', 'scan'],
-                description: 'Ação do sistema de issues'
-            },
-            projectPath: {
-                type: 'string',
-                description: 'Caminho absoluto do projeto'
-            },
-            title: {
-                type: 'string',
-                description: 'Título da issue'
-            },
-            description: {
-                type: 'string',
-                description: 'Descrição da issue'
-            },
-            labels: {
-                type: 'array',
-                items: { type: 'string' },
-                description: 'Labels da issue'
-            },
-            priority: {
-                type: 'string',
-                enum: ['low', 'medium', 'high', 'urgent'],
-                description: 'Prioridade da issue'
-            },
-            assignee: {
-                type: 'string',
-                description: 'Responsável pela issue'
-            },
-            dueDate: {
-                type: 'string',
-                description: 'Data de vencimento (ISO string)'
-            },
-            state: {
-                type: 'string',
-                enum: ['open', 'closed', 'all'],
-                description: 'Estado da issue'
-            },
-            id: {
-                type: 'string',
-                description: 'ID da issue'
-            },
-            detailed: {
-                type: 'boolean',
-                description: 'Informações detalhadas'
-            },
-            comment: {
-                type: 'string',
-                description: 'Comentário para fechamento'
-            },
-            createIssues: {
-                type: 'boolean',
-                description: 'Criar issues automaticamente dos TODOs'
-            },
-            patterns: {
-                type: 'array',
-                items: { type: 'string' },
-                description: 'Padrões customizados para scan'
-            },
-            limit: {
-                type: 'number',
-                description: 'Limite de resultados'
-            },
-            sort: {
-                type: 'string',
-                enum: ['created', 'updated', 'priority', 'due_date'],
-                description: 'Critério de ordenação'
-            }
-        },
-        required: ['action', 'projectPath']
-    },
+    description: '🐛 ISSUES - Gerenciamento de issues',
+    inputSchema: { type: 'object', properties: { action: { type: 'string' }, projectPath: { type: 'string' } }, required: ['action', 'projectPath'] },
     async handler(input) {
-        const executor = new GitIssuesExecutor();
-        let validatedInput;
-        try {
-            // Validate input
-            validatedInput = GitIssuesInputSchema.parse(input);
-            // Auto-detect context
-            const detection = await (0, auto_detection_js_1.autoDetect)(validatedInput.projectPath);
-            await (0, auto_detection_js_1.validateAutoDetection)(detection);
-            // Execute specific action
-            switch (validatedInput.action) {
-                case 'create':
-                    return await executor['executeCreate'](detection, validatedInput);
-                case 'list':
-                    return await executor['executeList'](detection, validatedInput);
-                case 'get':
-                    return await executor['executeGet'](detection, validatedInput);
-                case 'update':
-                    return await executor['executeUpdate'](detection, validatedInput);
-                case 'close':
-                    return await executor['executeClose'](detection, validatedInput);
-                case 'scan':
-                    return await executor['executeScan'](detection, validatedInput);
-                default:
-                    throw new Error(`Ação '${validatedInput.action}' não suportada`);
-            }
-        }
-        catch (error) {
-            executor.errorHandler.addError(error);
-            const errorResponse = executor.errorHandler.toUniversalResponse();
-            return (0, auto_detection_js_1.createUniversalResponse)(false, validatedInput?.action, 'Erro na execução da tool', await (0, auto_detection_js_1.autoDetect)(validatedInput?.projectPath), 'git-issues', undefined, errorResponse);
-        }
+        const detection = (0, auto_detection_js_1.autoDetect)(input.projectPath);
+        return (0, auto_detection_js_1.createUniversalResponse)(true, input.action, 'Issue processada', detection, 'git-issues', { issues: [] });
     }
 };
 //# sourceMappingURL=git-issues.js.map