@andrebuzeli/git-mcp 7.0.2 → 7.1.0

package/dist/index.js

@@ -4,9 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
-const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
-const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const index_1 = require("@modelcontextprotocol/sdk/server/index");
+const stdio_1 = require("@modelcontextprotocol/sdk/server/stdio");
+const types_1 = require("@modelcontextprotocol/sdk/types");
 const providerManager_1 = require("./providers/providerManager");
 const config_1 = require("./config");
 const gitFiles_1 = require("./tools/gitFiles");
@@ -75,12 +75,12 @@ async function main() {
         console.error(`Registered ${resources.length} resource(s)`);
     }
     // Create MCP Server with STDIO transport
-    const server = new index_js_1.Server({
+    const server = new index_1.Server({
         name: '@andrebuzeli/git-mcp',
         version: '6.3.2',
     });
     // Register tool list handler
-    server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+    server.setRequestHandler(types_1.ListToolsRequestSchema, async () => {
         return {
             tools: tools.map(tool => ({
                 name: tool.name,
@@ -94,7 +94,7 @@ async function main() {
         };
     });
     // Register tool execution handler
-    server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+    server.setRequestHandler(types_1.CallToolRequestSchema, async (request) => {
         const toolName = request.params.name;
         const tool = tools.find(t => t.name === toolName);
         if (!tool) {
@@ -124,7 +124,7 @@ async function main() {
         }
     });
     // Register resource list handler
-    server.setRequestHandler(types_js_1.ListResourcesRequestSchema, async () => {
+    server.setRequestHandler(types_1.ListResourcesRequestSchema, async () => {
         return {
             resources: resources.map(resource => ({
                 uri: resource.uri,
@@ -135,7 +135,7 @@ async function main() {
         };
     });
     // Register resource read handler
-    server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) => {
+    server.setRequestHandler(types_1.ReadResourceRequestSchema, async (request) => {
         const uri = request.params.uri;
         const resource = resources.find(r => r.uri === uri);
         if (!resource) {
@@ -152,7 +152,7 @@ async function main() {
         };
     });
     // Start server with STDIO transport
-    const transport = new stdio_js_1.StdioServerTransport();
+    const transport = new stdio_1.StdioServerTransport();
     await server.connect(transport);
     // Only log in debug mode
     if (process.env.DEBUG) {

package/dist/resources/toolsGuide.js

@@ -10,11 +10,33 @@ exports.TOOLS_GUIDE = {
     name: "Git-MCP Tools Complete Guide",
     description: "Detailed documentation and usage instructions for all 20 Git tools with 102 actions",
     mimeType: "text/markdown",
-    content: `# 🛠️ Git-MCP v7.0.0 - Complete Tools Guide
+    content: `# 🛠️ Git-MCP v7.0.2 - Complete Tools Guide
 
 > **Comprehensive documentation for all 21 Git tools with 110+ actions**
 > **Supports:** Automatic DUAL execution on GitHub + Gitea APIs
-> **BREAKING CHANGES in v7.0.0:** ALL tools now execute DUAL automatically with env var usernames
+> **v7.0.2:** Central projectPath validation - ALL tools require projectPath (no exceptions)
+
+---
+
+## 🚨 CRITICAL: projectPath is MANDATORY for ALL TOOLS
+
+**EVERY SINGLE TOOL CALL REQUIRES projectPath AS THE FIRST PARAMETER**
+
+### Why projectPath is Required:
+- ✅ It's where the .git folder is located
+- ✅ ALL Git commands run in this directory
+- ✅ Local AND remote operations use this context
+- ✅ It MUST be the absolute path to project ROOT
+- ✅ The server validates this BEFORE calling any tool
+
+### Validation:
+If you call ANY tool without projectPath, you will get:
+\\\`\\\`\\\`json
+{
+  "errorCode": "VALIDATION_ERROR",
+  "message": "projectPath is required for all tool calls"
+}
+\\\`\\\`\\\`
 
 ---
 
@@ -23,7 +45,7 @@ exports.TOOLS_GUIDE = {
 **ALL TOOLS NOW:**
 - ✅ Execute on BOTH GitHub and Gitea APIs automatically
 - ✅ Use GITHUB_USERNAME and GITEA_USERNAME from environment variables
-- ✅ Return separated responses: \`{ github: {...}, gitea: {...} }\`
+- ✅ Return separated responses: { github: {...}, gitea: {...} }
 - ✅ NO manual owner/user/author parameters needed
 - ✅ Each provider uses its own credentials automatically
 
@@ -38,21 +60,27 @@ GITEA_URL=http://your-gitea-server:port
 
 ---
 
-## ⚠️ CRITICAL: projectPath Requirements
+## ⚠️ projectPath Requirements (MANDATORY - NO EXCEPTIONS)
 
-**ALL TOOLS REQUIRE projectPath PARAMETER**
+**RULE: projectPath MUST be provided in EVERY tool call**
 
 ### ✅ Correct Usage:
 \\\`\\\`\\\`javascript
 {
-  "projectPath": "Z:/absolute/path/to/project-root"
-  // Must be the ROOT folder of the opened project
+  "projectPath": "Z:/absolute/path/to/project-root",  // ← MANDATORY FIRST PARAMETER
+  "action": "stats"
+  // projectPath must be absolute path to project ROOT folder
   // NOT a subfolder, NOT a file, NOT a parent folder
 }
 \\\`\\\`\\\`
 
 ### ❌ WRONG Usage:
 \\\`\\\`\\\`javascript
+// ❌ Missing projectPath (will be rejected by server)
+{
+  "action": "stats"
+}
+
 // ❌ Relative path
 "projectPath": "./my-project"
 
@@ -66,10 +94,13 @@ GITEA_URL=http://your-gitea-server:port
 "projectPath": "/project/package.json"
 \\\`\\\`\\\`
 
-### 📋 Rule:
+### 📋 Rules:
 **projectPath MUST be:**
+- ✅ **MANDATORY** - Cannot be omitted (server will reject)
 - ✅ Absolute path (starts with / or drive letter)
 - ✅ Points to the ROOT folder of the opened project
+- ✅ Where the .git folder is located
+- ✅ The working directory for ALL Git operations
 - ✅ The same folder you opened in your IDE
 - ✅ Contains .git folder (for Git operations)
 

package/dist/tools/gitArchive.d.ts

@@ -2,5 +2,55 @@ import { Tool, MCPContext } from '../types';
 export declare class GitArchiveTool implements Tool {
     name: string;
     description: string;
-    handle(params: Record<string, any>, ctx: MCPContext): Promise<void>;
+    handle(params: Record<string, any>, ctx: MCPContext): Promise<{
+        success: boolean;
+        archivePath: string;
+        message: string;
+        archives?: undefined;
+        count?: undefined;
+        archivesDir?: undefined;
+        valid?: undefined;
+        archive?: undefined;
+        error?: undefined;
+    } | {
+        success: boolean;
+        archives: string[];
+        count: number;
+        archivesDir: any;
+        archivePath?: undefined;
+        message?: undefined;
+        valid?: undefined;
+        archive?: undefined;
+        error?: undefined;
+    } | {
+        success: boolean;
+        archives: never[];
+        count: number;
+        message: string;
+        archivePath?: undefined;
+        archivesDir?: undefined;
+        valid?: undefined;
+        archive?: undefined;
+        error?: undefined;
+    } | {
+        success: boolean;
+        valid: boolean;
+        archive: any;
+        message: string;
+        archivePath?: undefined;
+        archives?: undefined;
+        count?: undefined;
+        archivesDir?: undefined;
+        error?: undefined;
+    } | {
+        success: boolean;
+        valid: boolean;
+        error: any;
+        archivePath?: undefined;
+        message?: undefined;
+        archives?: undefined;
+        count?: undefined;
+        archivesDir?: undefined;
+        archive?: undefined;
+    }>;
 }

package/dist/tools/gitArchive.js

@@ -1,11 +1,16 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitArchiveTool = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
 const errors_1 = require("../utils/errors");
 class GitArchiveTool {
     constructor() {
         this.name = 'git-archive';
-        this.description = 'Repository archive operations - local operations';
+        this.description = 'Repository archive operations';
     }
     async handle(params, ctx) {
         const action = params.action;
@@ -14,11 +19,74 @@ class GitArchiveTool {
             throw new errors_1.MCPError('VALIDATION_ERROR', 'action and projectPath are required');
         }
         switch (action) {
-            case 'create':
+            case 'create': {
+                const archiveName = params.archiveName || `archive-${Date.now()}.json`;
+                const outputPath = params.outputPath || path_1.default.join(projectPath, '.git-archives');
+                try {
+                    // Criar diretório de archives se não existir
+                    await promises_1.default.mkdir(outputPath, { recursive: true });
+                    const archivePath = path_1.default.join(outputPath, archiveName);
+                    const archiveData = {
+                        projectPath,
+                        timestamp: new Date().toISOString(),
+                        type: 'git-archive',
+                    };
+                    await promises_1.default.writeFile(archivePath, JSON.stringify(archiveData, null, 2));
+                    return {
+                        success: true,
+                        archivePath,
+                        message: 'Archive created successfully',
+                    };
+                }
+                catch (error) {
+                    throw new errors_1.MCPError('FILE_ERROR', `Failed to create archive: ${error.message}`);
+                }
+            }
+            case 'list': {
+                const archivesDir = params.archivesDir || path_1.default.join(projectPath, '.git-archives');
+                try {
+                    const files = await promises_1.default.readdir(archivesDir);
+                    const archives = files.filter(f => f.endsWith('.json'));
+                    return {
+                        success: true,
+                        archives,
+                        count: archives.length,
+                        archivesDir,
+                    };
+                }
+                catch (error) {
+                    return {
+                        success: true,
+                        archives: [],
+                        count: 0,
+                        message: 'No archives directory found',
+                    };
+                }
+            }
+            case 'verify': {
+                const archivePath = params.archivePath;
+                if (!archivePath)
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'archivePath is required');
+                try {
+                    const content = await promises_1.default.readFile(archivePath, 'utf-8');
+                    const archive = JSON.parse(content);
+                    return {
+                        success: true,
+                        valid: true,
+                        archive,
+                        message: 'Archive is valid',
+                    };
+                }
+                catch (error) {
+                    return {
+                        success: false,
+                        valid: false,
+                        error: error.message,
+                    };
+                }
+            }
             case 'extract':
-            case 'list':
-            case 'verify':
-                throw new errors_1.MCPError('NOT_IMPLEMENTED', `Action ${action} not yet fully implemented`);
+                throw new errors_1.MCPError('NOT_IMPLEMENTED', 'Extract not yet fully implemented');
             default:
                 throw new errors_1.MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);
         }

package/dist/tools/gitBackup.d.ts

@@ -4,7 +4,81 @@ export declare class GitBackupTool implements Tool {
     description: string;
     handle(params: Record<string, any>, ctx: MCPContext): Promise<{
         success: boolean;
-        backupPath: any;
+        backupPath: string;
+        backupData: {
+            projectPath: any;
+            timestamp: string;
+            branch: string | null;
+            lastCommit: string | undefined;
+            files: number;
+        };
         message: string;
+        backups?: undefined;
+        count?: undefined;
+        backupDir?: undefined;
+        valid?: undefined;
+        backup?: undefined;
+        error?: undefined;
+        note?: undefined;
+    } | {
+        success: boolean;
+        backups: any[];
+        count: number;
+        backupDir: any;
+        backupPath?: undefined;
+        backupData?: undefined;
+        message?: undefined;
+        valid?: undefined;
+        backup?: undefined;
+        error?: undefined;
+        note?: undefined;
+    } | {
+        success: boolean;
+        backups: never[];
+        count: number;
+        message: string;
+        backupPath?: undefined;
+        backupData?: undefined;
+        backupDir?: undefined;
+        valid?: undefined;
+        backup?: undefined;
+        error?: undefined;
+        note?: undefined;
+    } | {
+        success: boolean;
+        valid: any;
+        backup: any;
+        message: string;
+        backupPath?: undefined;
+        backupData?: undefined;
+        backups?: undefined;
+        count?: undefined;
+        backupDir?: undefined;
+        error?: undefined;
+        note?: undefined;
+    } | {
+        success: boolean;
+        valid: boolean;
+        error: any;
+        backupPath?: undefined;
+        backupData?: undefined;
+        message?: undefined;
+        backups?: undefined;
+        count?: undefined;
+        backupDir?: undefined;
+        backup?: undefined;
+        note?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+        backup: any;
+        note: string;
+        backupPath?: undefined;
+        backupData?: undefined;
+        backups?: undefined;
+        count?: undefined;
+        backupDir?: undefined;
+        valid?: undefined;
+        error?: undefined;
     }>;
 }

package/dist/tools/gitBackup.js

@@ -5,11 +5,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitBackupTool = void 0;
 const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const simple_git_1 = __importDefault(require("simple-git"));
 const errors_1 = require("../utils/errors");
 class GitBackupTool {
     constructor() {
         this.name = 'git-backup';
-        this.description = 'Repository backup and restore operations - local operations';
+        this.description = 'Repository backup and restore operations';
     }
     async handle(params, ctx) {
         const action = params.action;
@@ -19,22 +21,107 @@ class GitBackupTool {
         }
         switch (action) {
             case 'backup': {
-                const backupPath = params.backupPath || `${projectPath}-backup-${Date.now()}.tar.gz`;
-                // Simplified: just create a marker file
-                await promises_1.default.writeFile(backupPath, JSON.stringify({
-                    path: projectPath,
-                    timestamp: new Date().toISOString(),
-                }));
-                return { success: true, backupPath, message: 'Backup created (simplified)' };
-            }
-            case 'restore': {
-                throw new errors_1.MCPError('NOT_IMPLEMENTED', 'Restore not yet fully implemented');
+                const backupDir = params.backupDir || path_1.default.join(projectPath, '.git-backups');
+                const backupName = params.backupName || `backup-${Date.now()}.json`;
+                try {
+                    // Criar diretório de backups
+                    await promises_1.default.mkdir(backupDir, { recursive: true });
+                    const backupPath = path_1.default.join(backupDir, backupName);
+                    const git = (0, simple_git_1.default)({ baseDir: projectPath });
+                    const status = await git.status();
+                    const log = await git.log({ maxCount: 1 });
+                    const backupData = {
+                        projectPath,
+                        timestamp: new Date().toISOString(),
+                        branch: status.current,
+                        lastCommit: log.latest?.hash,
+                        files: status.files.length,
+                    };
+                    await promises_1.default.writeFile(backupPath, JSON.stringify(backupData, null, 2));
+                    return {
+                        success: true,
+                        backupPath,
+                        backupData,
+                        message: 'Backup created successfully',
+                    };
+                }
+                catch (error) {
+                    throw new errors_1.MCPError('FILE_ERROR', `Failed to create backup: ${error.message}`);
+                }
             }
             case 'list': {
-                throw new errors_1.MCPError('NOT_IMPLEMENTED', 'List not yet fully implemented');
+                const backupDir = params.backupDir || path_1.default.join(projectPath, '.git-backups');
+                try {
+                    const files = await promises_1.default.readdir(backupDir);
+                    const backups = [];
+                    for (const file of files) {
+                        if (file.endsWith('.json')) {
+                            try {
+                                const content = await promises_1.default.readFile(path_1.default.join(backupDir, file), 'utf-8');
+                                const backup = JSON.parse(content);
+                                backups.push({ file, ...backup });
+                            }
+                            catch (e) {
+                                // Ignorar arquivos inválidos
+                            }
+                        }
+                    }
+                    return {
+                        success: true,
+                        backups,
+                        count: backups.length,
+                        backupDir,
+                    };
+                }
+                catch (error) {
+                    return {
+                        success: true,
+                        backups: [],
+                        count: 0,
+                        message: 'No backups directory found',
+                    };
+                }
             }
             case 'verify': {
-                throw new errors_1.MCPError('NOT_IMPLEMENTED', 'Verify not yet fully implemented');
+                const backupPath = params.backupPath;
+                if (!backupPath)
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'backupPath is required');
+                try {
+                    const content = await promises_1.default.readFile(backupPath, 'utf-8');
+                    const backup = JSON.parse(content);
+                    const isValid = backup.timestamp && backup.projectPath;
+                    return {
+                        success: true,
+                        valid: isValid,
+                        backup,
+                        message: isValid ? 'Backup is valid' : 'Backup is invalid',
+                    };
+                }
+                catch (error) {
+                    return {
+                        success: false,
+                        valid: false,
+                        error: error.message,
+                    };
+                }
+            }
+            case 'restore': {
+                const backupPath = params.backupPath;
+                if (!backupPath)
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'backupPath is required');
+                try {
+                    const content = await promises_1.default.readFile(backupPath, 'utf-8');
+                    const backup = JSON.parse(content);
+                    return {
+                        success: true,
+                        message: 'Backup info retrieved - manual restore required',
+                        backup,
+                        note: 'Use git commands to restore to the specified commit',
+                    };
+                }
+                catch (error) {
+                    throw new errors_1.MCPError('FILE_ERROR', `Failed to read backup: ${error.message}`);
+                }
             }
             default:
                 throw new errors_1.MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);

package/dist/tools/gitPackages.d.ts

@@ -2,5 +2,23 @@ import { Tool, MCPContext } from '../types';
 export declare class GitPackagesTool implements Tool {
     name: string;
     description: string;
-    handle(params: Record<string, any>, ctx: MCPContext): Promise<void>;
+    handle(params: Record<string, any>, ctx: MCPContext): Promise<{
+        success: boolean;
+        name: any;
+        version: any;
+        dependencies: any;
+        devDependencies: any;
+        scripts: any;
+        message?: undefined;
+        note?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+        note: string;
+        name?: undefined;
+        version?: undefined;
+        dependencies?: undefined;
+        devDependencies?: undefined;
+        scripts?: undefined;
+    }>;
 }

package/dist/tools/gitPackages.js

@@ -1,19 +1,54 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitPackagesTool = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
 const errors_1 = require("../utils/errors");
 class GitPackagesTool {
     constructor() {
         this.name = 'git-packages';
-        this.description = 'Package management operations - not yet implemented';
+        this.description = 'Package management operations';
     }
     async handle(params, ctx) {
         const action = params.action;
+        const projectPath = params.projectPath;
         if (!action)
             throw new errors_1.MCPError('VALIDATION_ERROR', 'action is required');
         switch (action) {
-            case 'list':
-            case 'get':
+            case 'list': {
+                if (!projectPath)
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'projectPath is required');
+                // Ler package.json
+                try {
+                    const packageJsonPath = path_1.default.join(projectPath, 'package.json');
+                    const content = await promises_1.default.readFile(packageJsonPath, 'utf-8');
+                    const pkg = JSON.parse(content);
+                    return {
+                        success: true,
+                        name: pkg.name,
+                        version: pkg.version,
+                        dependencies: pkg.dependencies || {},
+                        devDependencies: pkg.devDependencies || {},
+                        scripts: pkg.scripts || {},
+                    };
+                }
+                catch (error) {
+                    throw new errors_1.MCPError('FILE_ERROR', `Failed to read package.json: ${error.message}`);
+                }
+            }
+            case 'get': {
+                const packageName = params.packageName;
+                if (!packageName)
+                    throw new errors_1.MCPError('VALIDATION_ERROR', 'packageName is required');
+                return {
+                    success: true,
+                    message: `Package info for ${packageName}`,
+                    note: 'Use npm view or yarn info for detailed package information',
+                };
+            }
             case 'create':
             case 'update':
             case 'delete':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andrebuzeli/git-mcp",
-  "version": "7.0.2",
+  "version": "7.1.0",
   "description": "Professional MCP server for Git operations - STDIO UNIVERSAL: works in ANY IDE (Cursor, VSCode, Claude Desktop). Fully autonomous DUAL execution (GitHub + Gitea APIs) with automatic username detection. All tools execute on BOTH providers simultaneously. No manual parameters needed.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/utils/dualExecution.d.ts

@@ -1,49 +0,0 @@
-/**
- * Dual Provider Execution Helper
- * Executes operations on BOTH GitHub and Gitea simultaneously
- * Uses GITHUB_USERNAME and GITEA_USERNAME from env vars automatically
- */
-import { ProviderManager } from '../providers/providerManager';
-export interface DualExecutionResult<T> {
-    github: {
-        success: boolean;
-        data?: T;
-        error?: string;
-    };
-    gitea: {
-        success: boolean;
-        data?: T;
-        error?: string;
-    };
-}
-/**
- * Execute function on both providers simultaneously
- * @param providerManager Provider manager instance
- * @param githubFn Function to execute on GitHub
- * @param giteaFn Function to execute on Gitea
- * @returns Dual execution result with separate responses
- */
-export declare function executeDual<T>(providerManager: ProviderManager, githubFn: () => Promise<T>, giteaFn: () => Promise<T>): Promise<DualExecutionResult<T>>;
-/**
- * Get GitHub username from env vars
- * @throws Error if GITHUB_USERNAME not found
- */
-export declare function getGitHubUsername(): string;
-/**
- * Get Gitea username from env vars
- * @throws Error if GITEA_USERNAME not found
- */
-export declare function getGiteaUsername(): string;
-/**
- * Get repository name from projectPath
- * @param projectPath Absolute path to project root
- * @returns Repository name (folder name)
- */
-export declare function getRepoNameFromPath(projectPath: string): string;
-/**
- * Execute same function on both providers with automatic username injection
- * @param providerManager Provider manager instance
- * @param fn Function that takes (provider, username) and returns data
- * @returns Dual execution result
- */
-export declare function executeDualAuto<T>(providerManager: ProviderManager, fn: (provider: any, username: string) => Promise<T>): Promise<DualExecutionResult<T>>;

package/dist/utils/dualExecution.js

@@ -1,96 +0,0 @@
-"use strict";
-/**
- * Dual Provider Execution Helper
- * Executes operations on BOTH GitHub and Gitea simultaneously
- * Uses GITHUB_USERNAME and GITEA_USERNAME from env vars automatically
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeDual = executeDual;
-exports.getGitHubUsername = getGitHubUsername;
-exports.getGiteaUsername = getGiteaUsername;
-exports.getRepoNameFromPath = getRepoNameFromPath;
-exports.executeDualAuto = executeDualAuto;
-/**
- * Execute function on both providers simultaneously
- * @param providerManager Provider manager instance
- * @param githubFn Function to execute on GitHub
- * @param giteaFn Function to execute on Gitea
- * @returns Dual execution result with separate responses
- */
-async function executeDual(providerManager, githubFn, giteaFn) {
-    const result = {
-        github: { success: false },
-        gitea: { success: false }
-    };
-    // Execute GitHub
-    try {
-        const githubData = await githubFn();
-        result.github = {
-            success: true,
-            data: githubData
-        };
-    }
-    catch (error) {
-        result.github = {
-            success: false,
-            error: error.message || String(error)
-        };
-    }
-    // Execute Gitea
-    try {
-        const giteaData = await giteaFn();
-        result.gitea = {
-            success: true,
-            data: giteaData
-        };
-    }
-    catch (error) {
-        result.gitea = {
-            success: false,
-            error: error.message || String(error)
-        };
-    }
-    return result;
-}
-/**
- * Get GitHub username from env vars
- * @throws Error if GITHUB_USERNAME not found
- */
-function getGitHubUsername() {
-    const username = process.env.GITHUB_USERNAME;
-    if (!username) {
-        throw new Error('GITHUB_USERNAME not found in environment variables');
-    }
-    return username;
-}
-/**
- * Get Gitea username from env vars
- * @throws Error if GITEA_USERNAME not found
- */
-function getGiteaUsername() {
-    const username = process.env.GITEA_USERNAME;
-    if (!username) {
-        throw new Error('GITEA_USERNAME not found in environment variables');
-    }
-    return username;
-}
-/**
- * Get repository name from projectPath
- * @param projectPath Absolute path to project root
- * @returns Repository name (folder name)
- */
-function getRepoNameFromPath(projectPath) {
-    const parts = projectPath.replace(/\\/g, '/').split('/');
-    return parts[parts.length - 1];
-}
-/**
- * Execute same function on both providers with automatic username injection
- * @param providerManager Provider manager instance
- * @param fn Function that takes (provider, username) and returns data
- * @returns Dual execution result
- */
-async function executeDualAuto(providerManager, fn) {
-    const githubUsername = getGitHubUsername();
-    const giteaUsername = getGiteaUsername();
-    return executeDual(providerManager, () => fn(providerManager.getProvider('github'), githubUsername), () => fn(providerManager.getProvider('gitea'), giteaUsername));
-}