@andrebuzeli/git-mcp 2.48.0 → 3.0.1

package/dist/tools/git-update-project.d.ts

@@ -16,8 +16,8 @@ declare const GitUpdateProjectInputSchema: z.ZodDiscriminatedUnion<"action", [z.
     action: "init";
     projectPath: string;
     branch?: string | undefined;
-    createRepo?: boolean | undefined;
     forcePush?: boolean | undefined;
+    createRepo?: boolean | undefined;
     granular?: boolean | undefined;
 }, {
     provider: "gitea" | "github";
@@ -26,8 +26,8 @@ declare const GitUpdateProjectInputSchema: z.ZodDiscriminatedUnion<"action", [z.
     action: "init";
     projectPath: string;
     branch?: string | undefined;
-    createRepo?: boolean | undefined;
     forcePush?: boolean | undefined;
+    createRepo?: boolean | undefined;
     granular?: boolean | undefined;
 }>, z.ZodObject<{
     action: z.ZodLiteral<"update">;
@@ -93,14 +93,14 @@ declare const GitUpdateProjectInputSchema: z.ZodDiscriminatedUnion<"action", [z.
     action: "log";
     projectPath: string;
     branch?: string | undefined;
-    maxCount?: number | undefined;
     oneline?: boolean | undefined;
+    maxCount?: number | undefined;
 }, {
     action: "log";
     projectPath: string;
     branch?: string | undefined;
-    maxCount?: number | undefined;
     oneline?: boolean | undefined;
+    maxCount?: number | undefined;
 }>, z.ZodObject<{
     action: z.ZodLiteral<"reset">;
     projectPath: z.ZodString;
@@ -167,93 +167,6 @@ declare const GitUpdateProjectInputSchema: z.ZodDiscriminatedUnion<"action", [z.
     projectPath: string;
     branch?: string | undefined;
     forcePush?: boolean | undefined;
-}>, z.ZodObject<{
-    action: z.ZodLiteral<"daily-workflow">;
-    projectPath: z.ZodString;
-    autoMessage: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    autoPush: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    createBackup: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    granularCommits: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-}, "strip", z.ZodTypeAny, {
-    action: "daily-workflow";
-    projectPath: string;
-    autoMessage: boolean;
-    autoPush: boolean;
-    createBackup: boolean;
-    granularCommits: boolean;
-}, {
-    action: "daily-workflow";
-    projectPath: string;
-    autoMessage?: boolean | undefined;
-    autoPush?: boolean | undefined;
-    createBackup?: boolean | undefined;
-    granularCommits?: boolean | undefined;
-}>, z.ZodObject<{
-    action: z.ZodLiteral<"smart-commit">;
-    projectPath: z.ZodString;
-    detectChanges: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    autoCategorize: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    suggestedMessage: z.ZodOptional<z.ZodString>;
-    validateSyntax: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    autoPush: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-}, "strip", z.ZodTypeAny, {
-    action: "smart-commit";
-    projectPath: string;
-    autoPush: boolean;
-    detectChanges: boolean;
-    autoCategorize: boolean;
-    validateSyntax: boolean;
-    suggestedMessage?: string | undefined;
-}, {
-    action: "smart-commit";
-    projectPath: string;
-    autoPush?: boolean | undefined;
-    detectChanges?: boolean | undefined;
-    autoCategorize?: boolean | undefined;
-    suggestedMessage?: string | undefined;
-    validateSyntax?: boolean | undefined;
-}>, z.ZodObject<{
-    action: z.ZodLiteral<"full-sync">;
-    repo: z.ZodString;
-    projectPath: z.ZodString;
-    provider: z.ZodEnum<["gitea", "github"]>;
-    pullFirst: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    resolveConflicts: z.ZodDefault<z.ZodOptional<z.ZodEnum<["auto", "manual", "skip"]>>>;
-    forcePush: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    createBackup: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-}, "strip", z.ZodTypeAny, {
-    provider: "gitea" | "github";
-    repo: string;
-    action: "full-sync";
-    projectPath: string;
-    forcePush: boolean;
-    createBackup: boolean;
-    pullFirst: boolean;
-    resolveConflicts: "auto" | "manual" | "skip";
-}, {
-    provider: "gitea" | "github";
-    repo: string;
-    action: "full-sync";
-    projectPath: string;
-    forcePush?: boolean | undefined;
-    createBackup?: boolean | undefined;
-    pullFirst?: boolean | undefined;
-    resolveConflicts?: "auto" | "manual" | "skip" | undefined;
-}>, z.ZodObject<{
-    action: z.ZodLiteral<"auto-backup">;
-    projectPath: z.ZodString;
-    message: z.ZodOptional<z.ZodString>;
-    includeUntracked: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-}, "strip", z.ZodTypeAny, {
-    action: "auto-backup";
-    projectPath: string;
-    includeUntracked: boolean;
-    message?: string | undefined;
-}, {
-    action: "auto-backup";
-    projectPath: string;
-    message?: string | undefined;
-    includeUntracked?: boolean | undefined;
 }>]>;
 export type GitUpdateProjectInput = z.infer<typeof GitUpdateProjectInputSchema>;
 declare const GitUpdateProjectResultSchema: z.ZodObject<{
@@ -365,61 +278,6 @@ export declare const gitUpdateProjectTool: {
                 description: string;
                 default: string;
             };
-            autoMessage: {
-                type: string;
-                description: string;
-                default: boolean;
-            };
-            autoPush: {
-                type: string;
-                description: string;
-                default: boolean;
-            };
-            createBackup: {
-                type: string;
-                description: string;
-                default: boolean;
-            };
-            granularCommits: {
-                type: string;
-                description: string;
-                default: boolean;
-            };
-            detectChanges: {
-                type: string;
-                description: string;
-                default: boolean;
-            };
-            autoCategorize: {
-                type: string;
-                description: string;
-                default: boolean;
-            };
-            suggestedMessage: {
-                type: string;
-                description: string;
-            };
-            validateSyntax: {
-                type: string;
-                description: string;
-                default: boolean;
-            };
-            pullFirst: {
-                type: string;
-                description: string;
-                default: boolean;
-            };
-            resolveConflicts: {
-                type: string;
-                enum: string[];
-                description: string;
-                default: string;
-            };
-            includeUntracked: {
-                type: string;
-                description: string;
-                default: boolean;
-            };
         };
         required: string[];
     };
@@ -452,19 +310,6 @@ export declare const gitUpdateProjectTool: {
         action: "sync";
     }): Promise<GitUpdateProjectResult>;
     groupFilesByType(projectPath: string): Promise<Record<string, string[]>>;
-    handleDailyWorkflow(params: GitUpdateProjectInput & {
-        action: "daily-workflow";
-    }): Promise<GitUpdateProjectResult>;
-    handleSmartCommit(params: GitUpdateProjectInput & {
-        action: "smart-commit";
-    }): Promise<GitUpdateProjectResult>;
-    handleFullSync(params: GitUpdateProjectInput & {
-        action: "full-sync";
-    }): Promise<GitUpdateProjectResult>;
-    handleAutoBackup(params: GitUpdateProjectInput & {
-        action: "auto-backup";
-    }): Promise<GitUpdateProjectResult>;
-    generateSmartCommitMessage(fileGroups: Record<string, string[]>): string;
 };
 export {};
 //# sourceMappingURL=git-update-project.d.ts.map

package/dist/tools/git-update-project.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"git-update-project.d.ts","sourceRoot":"","sources":["../../src/tools/git-update-project.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,QAAA,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA4H/B,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,QAAA,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;EAMhC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAElF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAgDV,qBAAqB,GAAG,OAAO,CAAC,sBAAsB,CAAC;yBA6CjD,qBAAqB,GAAG;QAAE,MAAM,EAAE,QAAQ,CAAA;KAAE,GAAG,OAAO,CAAC,sBAAsB,CAAC;uBAyLhF,qBAAqB,GAAG;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,sBAAsB,CAAC;yBAuJ1E,qBAAqB,GAAG;QAAE,MAAM,EAAE,QAAQ,CAAA;KAAE,GAAG,OAAO,CAAC,sBAAsB,CAAC;uBAmDhF,qBAAqB,GAAG;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,sBAAsB,CAAC;sBAiD7E,qBAAqB,GAAG;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE,GAAG,OAAO,CAAC,sBAAsB,CAAC;wBAkDzE,qBAAqB,GAAG;QAAE,MAAM,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,sBAAsB,CAAC;wBA2C7E,qBAAqB,GAAG;QAAE,MAAM,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,sBAAsB,CAAC;uBA+D9E,qBAAqB,GAAG;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,sBAAsB,CAAC;uBAwC5E,qBAAqB,GAAG;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,sBAAsB,CAAC;kCAkGjE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;gCA0C5C,qBAAqB,GAAG;QAAE,MAAM,EAAE,gBAAgB,CAAA;KAAE,GAAG,OAAO,CAAC,sBAAsB,CAAC;8BAuHxF,qBAAqB,GAAG;QAAE,MAAM,EAAE,cAAc,CAAA;KAAE,GAAG,OAAO,CAAC,sBAAsB,CAAC;2BAsEvF,qBAAqB,GAAG;QAAE,MAAM,EAAE,WAAW,CAAA;KAAE,GAAG,OAAO,CAAC,sBAAsB,CAAC;6BAiE/E,qBAAqB,GAAG;QAAE,MAAM,EAAE,aAAa,CAAA;KAAE,GAAG,OAAO,CAAC,sBAAsB,CAAC;2CA2C3E,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,MAAM;CAkBzE,CAAC"}
+{"version":3,"file":"git-update-project.d.ts","sourceRoot":"","sources":["../../src/tools/git-update-project.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,QAAA,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAmF/B,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF,QAAA,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;EAMhC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAElF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAmCV,qBAAqB,GAAG,OAAO,CAAC,sBAAsB,CAAC;yBAqCjD,qBAAqB,GAAG;QAAE,MAAM,EAAE,QAAQ,CAAA;KAAE,GAAG,OAAO,CAAC,sBAAsB,CAAC;uBAyLhF,qBAAqB,GAAG;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,sBAAsB,CAAC;yBAuJ1E,qBAAqB,GAAG;QAAE,MAAM,EAAE,QAAQ,CAAA;KAAE,GAAG,OAAO,CAAC,sBAAsB,CAAC;uBAmDhF,qBAAqB,GAAG;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,sBAAsB,CAAC;sBAiD7E,qBAAqB,GAAG;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE,GAAG,OAAO,CAAC,sBAAsB,CAAC;wBAkDzE,qBAAqB,GAAG;QAAE,MAAM,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,sBAAsB,CAAC;wBA2C7E,qBAAqB,GAAG;QAAE,MAAM,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,sBAAsB,CAAC;uBA+D9E,qBAAqB,GAAG;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,sBAAsB,CAAC;uBAwC5E,qBAAqB,GAAG;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,sBAAsB,CAAC;kCAkGjE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CAwC/E,CAAC"}

package/dist/tools/git-update-project.js

@@ -79,43 +79,6 @@ const GitUpdateProjectInputSchema = zod_1.z.discriminatedUnion('action', [
         message: zod_1.z.string().min(1, 'Commit message is required'),
         branch: zod_1.z.string().optional(),
         forcePush: zod_1.z.boolean().optional()
-    }),
-    // NEW: Action: daily-workflow - workflow diário completo automatizado
-    zod_1.z.object({
-        action: zod_1.z.literal('daily-workflow'),
-        projectPath: zod_1.z.string(),
-        autoMessage: zod_1.z.boolean().optional().default(true),
-        autoPush: zod_1.z.boolean().optional().default(true),
-        createBackup: zod_1.z.boolean().optional().default(true),
-        granularCommits: zod_1.z.boolean().optional().default(false)
-    }),
-    // NEW: Action: smart-commit - commit inteligente com auto-detecção
-    zod_1.z.object({
-        action: zod_1.z.literal('smart-commit'),
-        projectPath: zod_1.z.string(),
-        detectChanges: zod_1.z.boolean().optional().default(true),
-        autoCategorize: zod_1.z.boolean().optional().default(true),
-        suggestedMessage: zod_1.z.string().optional(),
-        validateSyntax: zod_1.z.boolean().optional().default(true),
-        autoPush: zod_1.z.boolean().optional().default(true)
-    }),
-    // NEW: Action: full-sync - sincronização completa com resolução automática
-    zod_1.z.object({
-        action: zod_1.z.literal('full-sync'),
-        repo: zod_1.z.string(),
-        projectPath: zod_1.z.string(),
-        provider: zod_1.z.enum(['gitea', 'github']),
-        pullFirst: zod_1.z.boolean().optional().default(true),
-        resolveConflicts: zod_1.z.enum(['auto', 'manual', 'skip']).optional().default('auto'),
-        forcePush: zod_1.z.boolean().optional().default(false),
-        createBackup: zod_1.z.boolean().optional().default(true)
-    }),
-    // NEW: Action: auto-backup - backup automático do estado atual
-    zod_1.z.object({
-        action: zod_1.z.literal('auto-backup'),
-        projectPath: zod_1.z.string(),
-        message: zod_1.z.string().optional(),
-        includeUntracked: zod_1.z.boolean().optional().default(true)
     })
 ]);
 const GitUpdateProjectResultSchema = zod_1.z.object({
@@ -127,20 +90,20 @@ const GitUpdateProjectResultSchema = zod_1.z.object({
 });
 exports.gitUpdateProjectTool = {
     name: 'git-update-project',
-    description: 'tool: SUPER-OTIMIZADO - Gerenciamento COMPLETO de projetos Git para AI Agents\\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\\n13 ACTIONS DISPONÍVEIS (4 NOVAS para automação completa):\\n\\nLEGACY ACTIONS:\\n• init: UPLOAD INICIAL completo (substitui upload-project)\\n• update: Commit incremental automático\\n• status: Verificar status do repositório\\n• diff: Mostrar diferenças entre versões\\n• log: Histórico de commits\\n• reset: Desfazer mudanças\\n• stash: Gerenciar mudanças temporárias\\n• pull: Atualizar do repositório remoto\\n• sync: Sincronização completa (pull+commit+push)\\n\\nNEW AI-FIRST ACTIONS (⭐ RECOMENDADO):\\n• daily-workflow: Workflow diário completo (1 chamada)\\n• smart-commit: Commit inteligente com auto-detecção\\n• full-sync: Sincronização com resolução automática\\n• auto-backup: Backup automático do estado\\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\\n🤖 OTIMIZADO PARA AI AGENTS\\n• Auto-detecção de tipo de commit (feat/fix/docs)\\n• Mensagens inteligentes baseadas no diff\\n• Push automático configurável\\n• Backup automático antes de operações\\n• Resolução automática de conflitos\\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━',
+    description: 'tool: Gerenciamento COMPLETO de projetos Git (local + remoto)\\n──────────────\\n9 ACTIONS DISPONÍVEIS:\\n• init: UPLOAD INICIAL completo (substitui upload-project)\\n• update: Commit incremental automático\\n• status: Verificar status do repositório\\n• diff: Mostrar diferenças entre versões\\n• log: Histórico de commits\\n• reset: Desfazer mudanças\\n• stash: Gerenciar mudanças temporárias\\n• pull: Atualizar do repositório remoto\\n• sync: Sincronização completa (pull+commit+push)\\n───────────────\\nCOMMITS REAIS + RASTREABILIDADE TOTAL\\nFunciona com GitHub, Gitea e qualquer repositório Git',
     inputSchema: {
         type: 'object',
         properties: {
             action: {
                 type: 'string',
-                enum: ['init', 'update', 'status', 'diff', 'log', 'reset', 'stash', 'pull', 'sync', 'daily-workflow', 'smart-commit', 'full-sync', 'auto-backup'],
-                description: 'Action to perform (13 available actions)'
+                enum: ['init', 'update', 'status', 'diff', 'log', 'reset', 'stash', 'pull', 'sync'],
+                description: 'Action to perform'
             },
             // Parâmetros comuns
-            repo: { type: 'string', description: 'Repository name (required for init/update/sync/full-sync)' },
+            repo: { type: 'string', description: 'Repository name (required for init/update/sync)' },
             projectPath: { type: 'string', description: 'Local project path (OBRIGATÓRIO para TODAS as operações)' },
-            provider: { type: 'string', enum: ['gitea', 'github'], description: 'Provider (required for init/update/sync/full-sync)' },
-            // Parâmetros específicos - Legacy
+            provider: { type: 'string', enum: ['gitea', 'github'], description: 'Provider (required for init/update/sync)' },
+            // Parâmetros específicos
             message: { type: 'string', description: 'Commit message (required for init/update/sync)' },
             branch: { type: 'string', description: 'Branch name', default: 'main' },
             forcePush: { type: 'boolean', description: 'Force push', default: false },
@@ -153,19 +116,7 @@ exports.gitUpdateProjectTool = {
             maxCount: { type: 'number', description: 'Max commits for log', default: 10 },
             oneline: { type: 'boolean', description: 'One line format for log', default: true },
             mode: { type: 'string', enum: ['soft', 'mixed', 'hard'], description: 'Reset mode', default: 'mixed' },
-            operation: { type: 'string', enum: ['save', 'pop', 'apply', 'list', 'drop', 'clear'], description: 'Stash operation', default: 'save' },
-            // Parâmetros específicos - New AI-First Actions
-            autoMessage: { type: 'boolean', description: 'Auto-generate commit message based on changes', default: true },
-            autoPush: { type: 'boolean', description: 'Auto-push after commit', default: true },
-            createBackup: { type: 'boolean', description: 'Create backup before operations', default: true },
-            granularCommits: { type: 'boolean', description: 'Create separate commits by file type', default: false },
-            detectChanges: { type: 'boolean', description: 'Detect and categorize changes automatically', default: true },
-            autoCategorize: { type: 'boolean', description: 'Auto-categorize commits (feat/fix/docs)', default: true },
-            suggestedMessage: { type: 'string', description: 'Suggested commit message (optional)' },
-            validateSyntax: { type: 'boolean', description: 'Validate syntax before committing', default: true },
-            pullFirst: { type: 'boolean', description: 'Pull latest changes before sync', default: true },
-            resolveConflicts: { type: 'string', enum: ['auto', 'manual', 'skip'], description: 'Conflict resolution strategy', default: 'auto' },
-            includeUntracked: { type: 'boolean', description: 'Include untracked files in backup', default: true }
+            operation: { type: 'string', enum: ['save', 'pop', 'apply', 'list', 'drop', 'clear'], description: 'Stash operation', default: 'save' }
         },
         required: ['action', 'projectPath']
     },
@@ -192,14 +143,6 @@ exports.gitUpdateProjectTool = {
                     return await this.handlePull(validatedInput);
                 case 'sync':
                     return await this.handleSync(validatedInput);
-                case 'daily-workflow':
-                    return await this.handleDailyWorkflow(validatedInput);
-                case 'smart-commit':
-                    return await this.handleSmartCommit(validatedInput);
-                case 'full-sync':
-                    return await this.handleFullSync(validatedInput);
-                case 'auto-backup':
-                    return await this.handleAutoBackup(validatedInput);
                 default:
                     throw new Error(`Action '${validatedInput.action}' não suportada`);
             }
@@ -925,291 +868,6 @@ exports.gitUpdateProjectTool = {
             }
         }
         return fileGroups;
-    },
-    // NEW: Handle daily-workflow - Workflow diário completo automatizado
-    async handleDailyWorkflow(params) {
-        try {
-            const { projectPath, autoMessage = true, autoPush = true, createBackup = true, granularCommits = false } = params;
-            const gitOps = new git_operations_js_1.GitOperations(projectPath);
-            // 1. Verificar se é repositório Git
-            const isGitRepo = await gitOps.isGitRepository();
-            if (!isGitRepo) {
-                throw new Error(`Diretório '${projectPath}' não é um repositório Git válido`);
-            }
-            // 2. Backup se solicitado
-            let backupResult = null;
-            if (createBackup) {
-                backupResult = await this.handleAutoBackup({ action: 'auto-backup', projectPath, includeUntracked: true });
-            }
-            // 3. Verificar status
-            const statusResult = await gitOps.status({ porcelain: true });
-            const hasChanges = statusResult.success && statusResult.output.trim().length > 0;
-            if (!hasChanges) {
-                return {
-                    success: true,
-                    action: 'daily-workflow',
-                    message: 'Nenhuma mudança detectada - workflow diário concluído',
-                    data: {
-                        backup: backupResult?.success,
-                        changesDetected: false,
-                        implementation: 'AI_WORKFLOW_v2.39.0'
-                    }
-                };
-            }
-            // 4. Add files
-            const addResult = await gitOps.addFiles(['.']);
-            if (!addResult.success) {
-                throw new Error(`Falha ao adicionar arquivos: ${addResult.error}`);
-            }
-            // 5. Commit inteligente
-            let commitMessage = 'Daily update';
-            if (autoMessage) {
-                const fileGroups = await this.groupFilesByType(projectPath);
-                const totalFiles = Object.values(fileGroups).flat().length;
-                if (granularCommits && totalFiles > 1) {
-                    // Commits granulares por tipo
-                    const results = [];
-                    for (const [type, files] of Object.entries(fileGroups)) {
-                        if (files.length === 0)
-                            continue;
-                        const typeCommit = await gitOps.commit(`${type}: ${files.length} files updated`);
-                        results.push({ type, files: files.length, success: typeCommit.success });
-                    }
-                    if (autoPush) {
-                        const pushResult = await gitOps.push('origin', 'main');
-                        return {
-                            success: results.every(r => r.success) && pushResult.success,
-                            action: 'daily-workflow',
-                            message: `Daily workflow concluído com ${results.length} commits granulares`,
-                            data: {
-                                granularCommits: results,
-                                push: pushResult.success,
-                                backup: backupResult?.success,
-                                implementation: 'AI_WORKFLOW_v2.39.0'
-                            }
-                        };
-                    }
-                    return {
-                        success: results.every(r => r.success),
-                        action: 'daily-workflow',
-                        message: `Daily workflow concluído com ${results.length} commits granulares`,
-                        data: {
-                            granularCommits: results,
-                            backup: backupResult?.success,
-                            implementation: 'AI_WORKFLOW_v2.39.0'
-                        }
-                    };
-                }
-                else {
-                    // Single commit
-                    commitMessage = this.generateSmartCommitMessage(fileGroups);
-                }
-            }
-            const commitResult = await gitOps.commit(commitMessage);
-            // 6. Push se solicitado
-            let pushResult = null;
-            if (autoPush === true && commitResult.success) {
-                pushResult = await gitOps.push('origin', 'main');
-            }
-            return {
-                success: commitResult.success && (autoPush !== true || (pushResult?.success === true)),
-                action: 'daily-workflow',
-                message: `Daily workflow ${commitResult.success ? 'concluído' : 'com problemas'}`,
-                data: {
-                    backup: backupResult?.success,
-                    commit: commitResult.success,
-                    push: pushResult?.success,
-                    message: commitMessage,
-                    implementation: 'AI_WORKFLOW_v2.39.0'
-                }
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                action: 'daily-workflow',
-                message: 'Erro no workflow diário',
-                error: error instanceof Error ? error.message : String(error)
-            };
-        }
-    },
-    // NEW: Handle smart-commit - Commit inteligente com auto-detecção
-    async handleSmartCommit(params) {
-        try {
-            const { projectPath, detectChanges = true, autoCategorize = true, suggestedMessage, validateSyntax = true, autoPush = true } = params;
-            const gitOps = new git_operations_js_1.GitOperations(projectPath);
-            // 1. Verificar repositório
-            const isGitRepo = await gitOps.isGitRepository();
-            if (!isGitRepo) {
-                throw new Error(`Diretório '${projectPath}' não é um repositório Git válido`);
-            }
-            // 2. Verificar mudanças
-            const statusResult = await gitOps.status({ porcelain: true });
-            if (!statusResult.success || !statusResult.output.trim()) {
-                return {
-                    success: true,
-                    action: 'smart-commit',
-                    message: 'Nenhuma mudança detectada para commit',
-                    data: {
-                        changesDetected: false,
-                        implementation: 'SMART_COMMIT_v2.39.0'
-                    }
-                };
-            }
-            // 3. Add files
-            const addResult = await gitOps.addFiles(['.']);
-            if (!addResult.success) {
-                throw new Error(`Falha ao adicionar arquivos: ${addResult.error}`);
-            }
-            // 4. Gerar mensagem inteligente
-            let commitMessage = suggestedMessage || 'Smart commit';
-            if (detectChanges && autoCategorize) {
-                const fileGroups = await this.groupFilesByType(projectPath);
-                commitMessage = this.generateSmartCommitMessage(fileGroups);
-            }
-            // 5. Commit
-            const commitResult = await gitOps.commit(commitMessage);
-            // 6. Push se solicitado
-            let pushResult = null;
-            if (autoPush === true && commitResult.success) {
-                pushResult = await gitOps.push('origin', 'main');
-            }
-            return {
-                success: commitResult.success && (autoPush !== true || (pushResult?.success === true)),
-                action: 'smart-commit',
-                message: `Smart commit ${commitResult.success ? 'concluído' : 'com problemas'}`,
-                data: {
-                    message: commitMessage,
-                    commit: commitResult.success,
-                    push: pushResult?.success,
-                    implementation: 'SMART_COMMIT_v2.39.0'
-                }
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                action: 'smart-commit',
-                message: 'Erro no smart commit',
-                error: error instanceof Error ? error.message : String(error)
-            };
-        }
-    },
-    // NEW: Handle full-sync - Sincronização completa com resolução automática
-    async handleFullSync(params) {
-        try {
-            const { repo, projectPath, provider: providerName, pullFirst = true, resolveConflicts = 'auto', forcePush = false, createBackup = true } = params;
-            const gitOps = new git_operations_js_1.GitOperations(projectPath);
-            // 1. Backup se solicitado
-            let backupResult = null;
-            if (createBackup) {
-                backupResult = await this.handleAutoBackup({ action: 'auto-backup', projectPath, includeUntracked: true });
-            }
-            // 2. Pull primeiro se solicitado
-            let pullResult = null;
-            if (pullFirst) {
-                pullResult = await gitOps.pull('origin', 'main');
-            }
-            // 3. Verificar status após pull
-            const statusResult = await gitOps.status({ porcelain: true });
-            const hasChanges = statusResult.success && statusResult.output.trim().length > 0;
-            // 4. Add e commit se houver mudanças
-            let commitResult = null;
-            let pushResult = null;
-            if (hasChanges) {
-                const addResult = await gitOps.addFiles(['.']);
-                if (addResult.success) {
-                    const fileGroups = await this.groupFilesByType(projectPath);
-                    const message = this.generateSmartCommitMessage(fileGroups);
-                    commitResult = await gitOps.commit(message);
-                    if (commitResult.success) {
-                        pushResult = await gitOps.push('origin', 'main', forcePush ? { force: true } : {});
-                    }
-                }
-            }
-            return {
-                success: (pullFirst !== true || (pullResult?.success === true)) && (!hasChanges || (commitResult?.success === true && pushResult?.success === true)),
-                action: 'full-sync',
-                message: `Full sync ${pullResult?.success && (!hasChanges || (commitResult?.success && pushResult?.success)) ? 'concluído' : 'com problemas'}`,
-                data: {
-                    repo,
-                    provider: providerName,
-                    backup: backupResult?.success,
-                    pull: pullResult?.success,
-                    commit: commitResult?.success,
-                    push: pushResult?.success,
-                    hasChanges,
-                    implementation: 'FULL_SYNC_v2.39.0'
-                }
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                action: 'full-sync',
-                message: 'Erro no full sync',
-                error: error instanceof Error ? error.message : String(error)
-            };
-        }
-    },
-    // NEW: Handle auto-backup - Backup automático do estado atual
-    async handleAutoBackup(params) {
-        try {
-            const { projectPath, message = 'Auto backup', includeUntracked = true } = params;
-            const gitOps = new git_operations_js_1.GitOperations(projectPath);
-            // Verificar se é repositório Git
-            const isGitRepo = await gitOps.isGitRepository();
-            if (!isGitRepo) {
-                throw new Error(`Diretório '${projectPath}' não é um repositório Git válido`);
-            }
-            // Criar stash com timestamp
-            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-            const stashMessage = `${message} - ${timestamp}`;
-            const stashResult = await gitOps.stash('push', {
-                message: stashMessage,
-                includeUntracked
-            });
-            return {
-                success: stashResult.success,
-                action: 'auto-backup',
-                message: `Backup ${stashResult.success ? 'criado' : 'com problemas'}`,
-                data: {
-                    stashMessage,
-                    includeUntracked,
-                    timestamp,
-                    implementation: 'AUTO_BACKUP_v2.39.0'
-                }
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                action: 'auto-backup',
-                message: 'Erro no auto backup',
-                error: error instanceof Error ? error.message : String(error)
-            };
-        }
-    },
-    // Helper: Generate smart commit message based on file groups
-    generateSmartCommitMessage(fileGroups) {
-        const totalFiles = Object.values(fileGroups).flat().length;
-        const groups = Object.entries(fileGroups).filter(([, files]) => files.length > 0);
-        if (groups.length === 1) {
-            const [type, files] = groups[0];
-            return `${type}: ${files.length} files updated`;
-        }
-        let message = '';
-        if (fileGroups.source.length > 0)
-            message += `feat: ${fileGroups.source.length} source files`;
-        if (fileGroups.documentation.length > 0)
-            message += `${message ? ', ' : ''}${fileGroups.documentation.length} docs`;
-        if (fileGroups.config.length > 0)
-            message += `${message ? ', ' : ''}${fileGroups.config.length} config`;
-        if (fileGroups.assets.length > 0)
-            message += `${message ? ', ' : ''}${fileGroups.assets.length} assets`;
-        if (fileGroups.other.length > 0)
-            message += `${message ? ', ' : ''}${fileGroups.other.length} other`;
-        return message || `update: ${totalFiles} files`;
     }
 };
 //# sourceMappingURL=git-update-project.js.map