@andrebuzeli/git-mcp 8.0.2 → 8.0.3

package/dist/tools/gitPackages.d.ts

@@ -1,4 +1,8 @@
 import { Tool, MCPContext } from '../types.js';
+/**
+ * Git Packages Tool - DUAL-PROVIDER (GitHub + Gitea)
+ * Manages packages published to GitHub Packages and Gitea Packages
+ */
 export declare class GitPackagesTool implements Tool {
     name: string;
     description: string;
@@ -14,10 +18,6 @@ export declare class GitPackagesTool implements Tool {
                 description: string;
                 enum: string[];
             };
-            repo: {
-                type: string;
-                description: string;
-            };
             packageType: {
                 type: string;
                 description: string;
@@ -27,10 +27,6 @@ export declare class GitPackagesTool implements Tool {
                 type: string;
                 description: string;
             };
-            packageId: {
-                type: string;
-                description: string;
-            };
             confirm: {
                 type: string;
                 description: string;
@@ -39,152 +35,6 @@ export declare class GitPackagesTool implements Tool {
         required: string[];
         additionalProperties: boolean;
     };
-    handle(params: Record<string, any>, ctx: MCPContext): Promise<{
-        success: boolean;
-        name: any;
-        version: any;
-        dependencies: any;
-        devDependencies: any;
-        scripts: any;
-        message?: undefined;
-        note?: undefined;
-        created?: undefined;
-        path?: undefined;
-        package?: undefined;
-        updated?: undefined;
-        deleted?: undefined;
-        instructions?: undefined;
-        projectPath?: undefined;
-    } | {
-        success: boolean;
-        message: string;
-        note: string;
-        name?: undefined;
-        version?: undefined;
-        dependencies?: undefined;
-        devDependencies?: undefined;
-        scripts?: undefined;
-        created?: undefined;
-        path?: undefined;
-        package?: undefined;
-        updated?: undefined;
-        deleted?: undefined;
-        instructions?: undefined;
-        projectPath?: undefined;
-    } | {
-        success: boolean;
-        created: boolean;
-        path: string;
-        package: any;
-        name?: undefined;
-        version?: undefined;
-        dependencies?: undefined;
-        devDependencies?: undefined;
-        scripts?: undefined;
-        message?: undefined;
-        note?: undefined;
-        updated?: undefined;
-        deleted?: undefined;
-        instructions?: undefined;
-        projectPath?: undefined;
-    } | {
-        success: boolean;
-        updated: boolean;
-        path: string;
-        package: any;
-        name?: undefined;
-        version?: undefined;
-        dependencies?: undefined;
-        devDependencies?: undefined;
-        scripts?: undefined;
-        message?: undefined;
-        note?: undefined;
-        created?: undefined;
-        deleted?: undefined;
-        instructions?: undefined;
-        projectPath?: undefined;
-    } | {
-        success: boolean;
-        deleted: boolean;
-        path: string;
-        name?: undefined;
-        version?: undefined;
-        dependencies?: undefined;
-        devDependencies?: undefined;
-        scripts?: undefined;
-        message?: undefined;
-        note?: undefined;
-        created?: undefined;
-        package?: undefined;
-        updated?: undefined;
-        instructions?: undefined;
-        projectPath?: undefined;
-    } | {
-        success: boolean;
-        message: string;
-        path: string;
-        name?: undefined;
-        version?: undefined;
-        dependencies?: undefined;
-        devDependencies?: undefined;
-        scripts?: undefined;
-        note?: undefined;
-        created?: undefined;
-        package?: undefined;
-        updated?: undefined;
-        deleted?: undefined;
-        instructions?: undefined;
-        projectPath?: undefined;
-    } | {
-        success: boolean;
-        message: string;
-        instructions: {
-            command: string;
-            registry: any;
-            access: any;
-            tag: any;
-            note: string;
-            package?: undefined;
-            version?: undefined;
-            destination?: undefined;
-        };
-        projectPath: any;
-        name?: undefined;
-        version?: undefined;
-        dependencies?: undefined;
-        devDependencies?: undefined;
-        scripts?: undefined;
-        note?: undefined;
-        created?: undefined;
-        path?: undefined;
-        package?: undefined;
-        updated?: undefined;
-        deleted?: undefined;
-    } | {
-        success: boolean;
-        message: string;
-        instructions: {
-            command: string;
-            package: any;
-            version: any;
-            destination: any;
-            note: string;
-            registry?: undefined;
-            access?: undefined;
-            tag?: undefined;
-        };
-        name?: undefined;
-        version?: undefined;
-        dependencies?: undefined;
-        devDependencies?: undefined;
-        scripts?: undefined;
-        note?: undefined;
-        created?: undefined;
-        path?: undefined;
-        package?: undefined;
-        updated?: undefined;
-        deleted?: undefined;
-        projectPath?: undefined;
-    }>;
+    handle(params: Record<string, any>, ctx: MCPContext): Promise<any>;
 }
 //# sourceMappingURL=gitPackages.d.ts.map

package/dist/tools/gitPackages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gitPackages.d.ts","sourceRoot":"","sources":["../../src/tools/gitPackages.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAI/C,qBAAa,eAAgB,YAAW,IAAI;IAC1C,IAAI,SAAkB;IACtB,WAAW,SAAmC;IAE9C,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAoCT;IAEI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,GAAG,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiL1D"}
+{"version":3,"file":"gitPackages.d.ts","sourceRoot":"","sources":["../../src/tools/gitPackages.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAI/C;;;GAGG;AACH,qBAAa,eAAgB,YAAW,IAAI;IAC1C,IAAI,SAAkB;IACtB,WAAW,SAAuE;IAElF,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA4BT;IAEI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,GAAG,EAAE,UAAU;CAyU1D"}

package/dist/tools/gitPackages.js

@@ -1,40 +1,34 @@
-import fs from 'fs/promises';
-import path from 'path';
 import { MCPError } from '../utils/errors.js';
 import { normalizeToolParams } from '../utils/repoHelpers.js';
+/**
+ * Git Packages Tool - DUAL-PROVIDER (GitHub + Gitea)
+ * Manages packages published to GitHub Packages and Gitea Packages
+ */
 export class GitPackagesTool {
     constructor() {
         this.name = 'git-packages';
-        this.description = 'Package management operations';
+        this.description = 'Package management operations - automatic dual-provider execution';
         this.inputSchema = {
             type: "object",
             properties: {
                 projectPath: {
                     type: "string",
-                    description: "Absolute path to the project/repository (auto-extracts repo name)"
+                    description: "Absolute path to the project/repository (REQUIRED)"
                 },
                 action: {
                     type: "string",
                     description: "Package operation to perform (REQUIRED)",
                     enum: ["list", "get", "delete", "versions"]
                 },
-                repo: {
-                    type: "string",
-                    description: "Repository name (auto-detected from projectPath)"
-                },
                 packageType: {
                     type: "string",
                     description: "Package type (required for operations)",
-                    enum: ["npm", "maven", "docker", "nuget", "rubygems"]
+                    enum: ["npm", "container", "maven", "nuget", "rubygems"]
                 },
                 packageName: {
                     type: "string",
                     description: "Package name (required for get/delete/versions)"
                 },
-                packageId: {
-                    type: "number",
-                    description: "Package ID (required for delete)"
-                },
                 confirm: {
                     type: "boolean",
                     description: "Confirm destructive operations (optional for delete)"
@@ -47,174 +41,274 @@ export class GitPackagesTool {
     async handle(params, ctx) {
         params = normalizeToolParams(params);
         const action = params.action;
-        const projectPath = params.projectPath;
         if (!action)
             throw new MCPError('VALIDATION_ERROR', 'action is required');
+        const githubOwner = process.env.GITHUB_USERNAME;
+        const giteaOwner = process.env.GITEA_USERNAME;
         switch (action) {
             case 'list': {
-                if (!projectPath)
-                    throw new MCPError('VALIDATION_ERROR', 'projectPath is required');
-                // Ler package.json
-                try {
-                    const packageJsonPath = path.join(projectPath, 'package.json');
-                    const content = await fs.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 || {},
-                    };
+                const results = {
+                    success: true,
+                    providers: {},
+                    summary: {
+                        total: 0,
+                        byProvider: {},
+                        byType: {}
+                    }
+                };
+                // GitHub Packages
+                if (ctx.providerManager.github && githubOwner) {
+                    try {
+                        // GitHub Packages API endpoint
+                        const response = await ctx.providerManager.github.request('GET /users/{username}/packages', {
+                            username: githubOwner,
+                            package_type: params.packageType || 'npm'
+                        });
+                        results.providers.github = {
+                            success: true,
+                            packages: response.data.map((pkg) => ({
+                                name: pkg.name,
+                                package_type: pkg.package_type,
+                                visibility: pkg.visibility,
+                                created_at: pkg.created_at,
+                                updated_at: pkg.updated_at,
+                                repository: pkg.repository?.full_name,
+                                url: pkg.html_url
+                            })),
+                            count: response.data.length
+                        };
+                        results.summary.byProvider.github = response.data.length;
+                        results.summary.total += response.data.length;
+                    }
+                    catch (error) {
+                        results.providers.github = {
+                            success: false,
+                            error: error.message,
+                            note: 'GitHub Packages may require specific permissions'
+                        };
+                    }
                 }
-                catch (error) {
-                    throw new MCPError('FILE_ERROR', `Failed to read package.json: ${error.message}`);
+                // Gitea Packages
+                if (ctx.providerManager.gitea && giteaOwner) {
+                    try {
+                        const packageType = params.packageType || 'npm';
+                        const response = await ctx.providerManager.gitea.request(`GET /packages/${giteaOwner}`, {
+                            type: packageType
+                        });
+                        const packages = Array.isArray(response.data) ? response.data : [];
+                        results.providers.gitea = {
+                            success: true,
+                            packages: packages.map((pkg) => ({
+                                name: pkg.name,
+                                version: pkg.version,
+                                package_type: pkg.type,
+                                created_at: pkg.created_at,
+                                repository: pkg.repository?.full_name,
+                                url: `${process.env.GITEA_URL}/${giteaOwner}/-/packages/${pkg.type}/${pkg.name}`
+                            })),
+                            count: packages.length
+                        };
+                        results.summary.byProvider.gitea = packages.length;
+                        results.summary.total += packages.length;
+                    }
+                    catch (error) {
+                        results.providers.gitea = {
+                            success: false,
+                            error: error.message,
+                            note: 'Gitea Packages API may not be available or enabled'
+                        };
+                    }
                 }
+                if (!ctx.providerManager.github && !ctx.providerManager.gitea) {
+                    throw new MCPError('VALIDATION_ERROR', 'No providers configured. Set GITHUB_TOKEN and/or GITEA_TOKEN');
+                }
+                return results;
             }
             case 'get': {
                 const packageName = params.packageName;
                 if (!packageName)
-                    throw new MCPError('VALIDATION_ERROR', 'packageName is required');
-                return {
+                    throw new MCPError('VALIDATION_ERROR', 'packageName is required for get action');
+                const packageType = params.packageType || 'npm';
+                const results = {
                     success: true,
-                    message: `Package info for ${packageName}`,
-                    note: 'Use npm view or yarn info for detailed package information',
-                };
-            }
-            case 'create': {
-                if (!projectPath)
-                    throw new MCPError('VALIDATION_ERROR', 'projectPath is required');
-                const packageJsonPath = path.join(projectPath, 'package.json');
-                const packageData = {
-                    name: params.name || path.basename(projectPath),
-                    version: params.version || '1.0.0',
-                    description: params.description || '',
-                    main: params.main || 'index.js',
-                    scripts: params.scripts || {},
-                    keywords: params.keywords || [],
-                    author: params.author || '',
-                    license: params.license || 'MIT',
+                    packageName,
+                    packageType,
+                    providers: {}
                 };
-                if (params.dependencies)
-                    packageData.dependencies = params.dependencies;
-                if (params.devDependencies)
-                    packageData.devDependencies = params.devDependencies;
-                try {
-                    await fs.writeFile(packageJsonPath, JSON.stringify(packageData, null, 2), 'utf-8');
-                    return {
-                        success: true,
-                        created: true,
-                        path: packageJsonPath,
-                        package: packageData,
-                    };
-                }
-                catch (error) {
-                    throw new MCPError('FILE_ERROR', `Failed to create package.json: ${error.message}`);
-                }
-            }
-            case 'update': {
-                if (!projectPath)
-                    throw new MCPError('VALIDATION_ERROR', 'projectPath is required');
-                const packageJsonPath = path.join(projectPath, 'package.json');
-                try {
-                    const content = await fs.readFile(packageJsonPath, 'utf-8');
-                    const pkg = JSON.parse(content);
-                    // Update fields if provided
-                    if (params.name)
-                        pkg.name = params.name;
-                    if (params.version)
-                        pkg.version = params.version;
-                    if (params.description)
-                        pkg.description = params.description;
-                    if (params.main)
-                        pkg.main = params.main;
-                    if (params.scripts)
-                        pkg.scripts = { ...pkg.scripts, ...params.scripts };
-                    if (params.keywords)
-                        pkg.keywords = params.keywords;
-                    if (params.author)
-                        pkg.author = params.author;
-                    if (params.license)
-                        pkg.license = params.license;
-                    if (params.dependencies)
-                        pkg.dependencies = { ...pkg.dependencies, ...params.dependencies };
-                    if (params.devDependencies)
-                        pkg.devDependencies = { ...pkg.devDependencies, ...params.devDependencies };
-                    await fs.writeFile(packageJsonPath, JSON.stringify(pkg, null, 2), 'utf-8');
-                    return {
-                        success: true,
-                        updated: true,
-                        path: packageJsonPath,
-                        package: pkg,
-                    };
-                }
-                catch (error) {
-                    throw new MCPError('FILE_ERROR', `Failed to update package.json: ${error.message}`);
-                }
-            }
-            case 'delete': {
-                if (!projectPath)
-                    throw new MCPError('VALIDATION_ERROR', 'projectPath is required');
-                const packageJsonPath = path.join(projectPath, 'package.json');
-                try {
-                    await fs.unlink(packageJsonPath);
-                    return {
-                        success: true,
-                        deleted: true,
-                        path: packageJsonPath,
-                    };
+                // GitHub Package Details
+                if (ctx.providerManager.github && githubOwner) {
+                    try {
+                        const response = await ctx.providerManager.github.request('GET /users/{username}/packages/{package_type}/{package_name}', {
+                            username: githubOwner,
+                            package_type: packageType,
+                            package_name: packageName
+                        });
+                        results.providers.github = {
+                            success: true,
+                            package: {
+                                name: response.data.name,
+                                package_type: response.data.package_type,
+                                visibility: response.data.visibility,
+                                version_count: response.data.version_count,
+                                created_at: response.data.created_at,
+                                updated_at: response.data.updated_at,
+                                repository: response.data.repository?.full_name,
+                                url: response.data.html_url
+                            }
+                        };
+                    }
+                    catch (error) {
+                        results.providers.github = {
+                            success: false,
+                            error: error.message,
+                            note: error.status === 404 ? 'Package not found on GitHub' : error.message
+                        };
+                    }
                 }
-                catch (error) {
-                    if (error.code === 'ENOENT') {
-                        return {
+                // Gitea Package Details
+                if (ctx.providerManager.gitea && giteaOwner) {
+                    try {
+                        const response = await ctx.providerManager.gitea.request(`GET /packages/${giteaOwner}/${packageType}/${packageName}`);
+                        results.providers.gitea = {
+                            success: true,
+                            package: {
+                                name: response.data.name,
+                                version: response.data.version,
+                                package_type: response.data.type,
+                                created_at: response.data.created_at,
+                                repository: response.data.repository?.full_name,
+                                url: `${process.env.GITEA_URL}/${giteaOwner}/-/packages/${packageType}/${packageName}`
+                            }
+                        };
+                    }
+                    catch (error) {
+                        results.providers.gitea = {
                             success: false,
-                            message: 'package.json not found',
-                            path: packageJsonPath,
+                            error: error.message,
+                            note: error.status === 404 ? 'Package not found on Gitea' : error.message
                         };
                     }
-                    throw new MCPError('FILE_ERROR', `Failed to delete package.json: ${error.message}`);
                 }
+                return results;
             }
-            case 'publish': {
-                if (!projectPath)
-                    throw new MCPError('VALIDATION_ERROR', 'projectPath is required');
-                const registry = params.registry || 'https://registry.npmjs.org';
-                const access = params.access || 'public'; // public or restricted
-                const tag = params.tag || 'latest';
-                const dryRun = params.dryRun || false;
-                return {
+            case 'versions': {
+                const packageName = params.packageName;
+                if (!packageName)
+                    throw new MCPError('VALIDATION_ERROR', 'packageName is required for versions action');
+                const packageType = params.packageType || 'npm';
+                const results = {
                     success: true,
-                    message: 'To publish, run: npm publish in your terminal',
-                    instructions: {
-                        command: dryRun ? 'npm publish --dry-run' : 'npm publish',
-                        registry,
-                        access,
-                        tag,
-                        note: 'Make sure you are logged in with: npm login',
-                    },
-                    projectPath,
+                    packageName,
+                    packageType,
+                    providers: {}
                 };
+                // GitHub Package Versions
+                if (ctx.providerManager.github && githubOwner) {
+                    try {
+                        const response = await ctx.providerManager.github.request('GET /users/{username}/packages/{package_type}/{package_name}/versions', {
+                            username: githubOwner,
+                            package_type: packageType,
+                            package_name: packageName
+                        });
+                        results.providers.github = {
+                            success: true,
+                            versions: response.data.map((v) => ({
+                                id: v.id,
+                                name: v.name,
+                                created_at: v.created_at,
+                                updated_at: v.updated_at,
+                                url: v.html_url
+                            })),
+                            count: response.data.length
+                        };
+                    }
+                    catch (error) {
+                        results.providers.github = {
+                            success: false,
+                            error: error.message
+                        };
+                    }
+                }
+                // Gitea Package Versions
+                if (ctx.providerManager.gitea && giteaOwner) {
+                    try {
+                        const response = await ctx.providerManager.gitea.request(`GET /packages/${giteaOwner}/${packageType}/${packageName}/versions`);
+                        const versions = Array.isArray(response.data) ? response.data : [];
+                        results.providers.gitea = {
+                            success: true,
+                            versions: versions.map((v) => ({
+                                version: v.version,
+                                created_at: v.created_at,
+                                url: `${process.env.GITEA_URL}/${giteaOwner}/-/packages/${packageType}/${packageName}/${v.version}`
+                            })),
+                            count: versions.length
+                        };
+                    }
+                    catch (error) {
+                        results.providers.gitea = {
+                            success: false,
+                            error: error.message
+                        };
+                    }
+                }
+                return results;
             }
-            case 'download': {
+            case 'delete': {
                 const packageName = params.packageName;
-                const version = params.version || 'latest';
-                const destination = params.destination || projectPath;
                 if (!packageName)
-                    throw new MCPError('VALIDATION_ERROR', 'packageName is required');
-                if (!destination)
-                    throw new MCPError('VALIDATION_ERROR', 'destination is required');
-                return {
+                    throw new MCPError('VALIDATION_ERROR', 'packageName is required for delete action');
+                if (!params.confirm) {
+                    throw new MCPError('VALIDATION_ERROR', 'confirm must be true to delete packages (destructive operation)');
+                }
+                const packageType = params.packageType || 'npm';
+                const results = {
                     success: true,
-                    message: `To download ${packageName}@${version}, run: npm install ${packageName}@${version} in your terminal`,
-                    instructions: {
-                        command: `npm install ${packageName}@${version}`,
-                        package: packageName,
-                        version,
-                        destination,
-                        note: 'Run this command in your project directory',
-                    },
+                    packageName,
+                    packageType,
+                    providers: {},
+                    warning: 'Package deleted from remote registries'
                 };
+                // Delete from GitHub
+                if (ctx.providerManager.github && githubOwner) {
+                    try {
+                        await ctx.providerManager.github.request('DELETE /users/{username}/packages/{package_type}/{package_name}', {
+                            username: githubOwner,
+                            package_type: packageType,
+                            package_name: packageName
+                        });
+                        results.providers.github = {
+                            success: true,
+                            deleted: true,
+                            message: `Package ${packageName} deleted from GitHub Packages`
+                        };
+                    }
+                    catch (error) {
+                        results.providers.github = {
+                            success: false,
+                            error: error.message,
+                            note: error.status === 404 ? 'Package not found' : 'Failed to delete'
+                        };
+                    }
+                }
+                // Delete from Gitea
+                if (ctx.providerManager.gitea && giteaOwner) {
+                    try {
+                        await ctx.providerManager.gitea.request(`DELETE /packages/${giteaOwner}/${packageType}/${packageName}`);
+                        results.providers.gitea = {
+                            success: true,
+                            deleted: true,
+                            message: `Package ${packageName} deleted from Gitea Packages`
+                        };
+                    }
+                    catch (error) {
+                        results.providers.gitea = {
+                            success: false,
+                            error: error.message,
+                            note: error.status === 404 ? 'Package not found' : 'Failed to delete'
+                        };
+                    }
+                }
+                return results;
             }
             default:
                 throw new MCPError('VALIDATION_ERROR', `Unsupported action: ${action}`);