---

name: access-analyzer description: "Analyze, export, refactor, and re-import Microsoft Access database applications. Use when working with .accdb/.mdb files to: (1) Create backups, (2) Export all objects (tables, queries, forms, reports, macros, VBA) to text files for version control and analysis, (3) Optionally export table data or structure-only, (4) Refactor exported code in VS Code, (5) Import changes back into Access. Includes automated export module based on ExportTodoSimple.bas." license: MIT

Microsoft Access Analyzer & Refactoring Tool

Comprehensive workflow for analyzing, exporting, refactoring, and re-importing Microsoft Access database applications without manually adding export modules to each project.

When to Use This Skill

Use this skill when the user asks to:

• Analyze an Access database (.accdb or .mdb file)
• Export Access objects for version control or code review
• Refactor Access VBA code in a modern editor (VS Code)
• Apply changes back to the original Access database
• Create backups before making changes
• Understand the structure of an Access application

IMPORTANT: Always ask user if they want to export table data (Step 2) before running export scripts.

Core Workflow

Phase 1: Backup

Always create a timestamped backup before any operation:

DatabaseName_BACKUP_yyyyMMdd_HHmmss.accdb

Phase 2: Export All Objects

Export the complete Access application to a structured folder:

Exportacion_yyyyMMdd_HHmmss/
├── 00_RESUMEN_APLICACION.txt    # Overview and inventory
├── 01_Tablas/                    # Table structures (DDL)
│   ├── Access/                   # Access DDL per table
│   │   ├── CLIENTES.txt
│   │   ├── PEDIDOS.txt
│   │   └── ...
│   └── SQLServer/                # SQL Server DDL per table
│       ├── CLIENTES.txt
│       ├── PEDIDOS.txt
│       └── ...
├── 02_Consultas/                 # Queries as .sql files
├── 03_Formularios/               # Forms + VBA code
├── 04_Informes/                  # Reports + VBA code
├── 05_Macros/                    # Macro definitions
└── 06_Codigo_VBA/                # All VBA modules (.bas/.cls)

Key Features:

• UTF-8 encoding for perfect VS Code compatibility
• Spanish characters (á, é, í, ó, ú, ñ) preserved correctly
• Each table exported as individual DDL file (Access AND SQL Server formats)- Optional table data export (estructura sola o estructura + datos)- Individual .sql files for queries
• Complete VBA module extraction
• Table structure documentation with types and properties

Phase 3: Analysis & Refactoring

Once exported, analyze and refactor in VS Code:

• Review code quality and patterns
• Identify dependencies and relationships
• Apply refactoring patterns
• Add comments and documentation
• Fix bugs or improve logic
• Modernize code structure

Phase 4: Re-import (When User Requests)

Import modified code back into Access:

1. Validate exported files haven't been corrupted
2. Create new backup before import
3. Import VBA modules
4. Import query definitions
5. Import form/report code
6. Verify all imports successful

How to Execute

Step 1: Locate Access File

Ask user for the path to the .accdb or .mdb file, or search workspace.

Step 2: Ask About Table Data Export

CRITICAL: Always ask the user BEFORE running any export script:

¿Deseas exportar los DATOS de las tablas junto con la estructura?

  [S] SÍ  - Exporta estructura + datos (.table + .tabledata)
          Útil para: backups completos, migración de datos

  [N] NO  - Exporta solo estructura (.table únicamente)
          Útil para: control de versiones Git, refactorización

When to recommend each option:

• Use -ExportTableData:$false (NO) for: code analysis, refactoring, Git version control
• Use -ExportTableData:$true (SÍ) for: complete backups, data migration, archival

Step 3: Create Backup

# Example
Copy-Item "C:\path\to\database.accdb" "C:\path\to\database_BACKUP_20260128_143000.accdb"

Step 4: Export Using VBA Module (with user's data choice)

The skill includes ExportTodoSimple.bas module that handles the complete export process.

Two approaches:

A) Temporary Injection (Recommended)

1. Open Access database programmatically
2. Temporarily import ExportTodoSimple module
3. Execute ExportAll subroutine
4. Remove temporary module
5. Close database

B) PowerShell Automation with Git (RECOMENDADO) Use the access-export-git.ps1 script.

IMPORTANT: Pass the -ExportTableData parameter based on user's answer from Step 2:

# If user chose NO (solo estructura)
.\access-export-git.ps1 -DatabasePath "path\to\db.accdb" -ExportTableData:$false

# If user chose SÍ (estructura + datos)
.\access-export-git.ps1 -DatabasePath "path\to\db.accdb" -ExportTableData:$true

The script will:

• Opens AccessAnalyzer.accdb tool database
• Calls RunCompleteExport with the exportTableData parameter
• Exports to persistent folder: {DatabaseName}_Export
• Initializes Git repository in export folder (if not exists)
• Creates .gitignore (excludes .ldb, backups, errors)
• Crea automáticamente REFACTORING_PLAN.md con checklist y tracking
• Commits all changes with timestamp
• Shows git diff stats
• Pregunta si quiere abrir VS Code automáticamente

Ventajas del workflow Git:

• ✅ Historial completo de cambios
• ✅ Detección automática de archivos modificados
• ✅ Rollback a versiones anteriores
• ✅ Solo importa lo que cambió (más rápido y seguro)
• ✅ Plan de refactorización incluido

Step 5: Open in VS Code

Al exportar con access-export-git.ps1, se pregunta automáticamente:

¿Abrir en VS Code para refactorizar? (S/N)

O manualmente:

code "path\to\Exportacion_folder"

Step 6: Analyze & Refactor

• Start with REFACTORING_PLAN.md - Plan generado automáticamente con:
  • Inventario de objetos exportados
  • Checklist de refactorización por fases
  • Template para documentar cambios
  • Notas para código problemático
• Review 00_RESUMEN_APLICACION.txt for database overview
• Explore 06_Codigo_VBA/ for main business logic
• Review queries in 02_Consultas/
• Check forms/reports for UI logic

Usando control de versiones Git:

1. Modifica los archivos .bas o .txt que necesites refactorizar
2. Guarda cambios en VS Code
3. Git detectará automáticamente los archivos modificados

Step 7: Re-import Inteligente (Solo Cambios)

Use access-import-changed.ps1 para importar solo lo modificado:

# Modo dry-run (ver qué se importaría)
.\access-import-changed.ps1 -TargetDbPath "C:\path\to\db.accdb" `
                             -ExportFolder "C:\path\to\db_Export" `
                             -DryRun

# Importación real
.\access-import-changed.ps1 -TargetDbPath "C:\path\to\db.accdb" `
                             -ExportFolder "C:\path\to\db_Export"

Cómo funciona:

1. Detecta archivos modificados con git diff --name-only HEAD~1 HEAD
2. Clasifica por tipo: Consultas, Formularios, Informes, Macros, Módulos VBA
3. Crea backup automático antes de importar
4. Importa SOLO los objetos que cambiaron
5. Muestra progreso con OK/ERROR por cada objeto
6. Genera reporte final con count de importados y errores
7. Pregunta si quiere abrir Access automáticamente para verificar cambios

Ventajas:

• ✅ Solo importa lo modificado (evita errores en objetos que funcionan)
• ✅ Mucho más rápido (3 objetos vs 621 totales)
• ✅ Menor riesgo de romper objetos que no tocaste
• ✅ Backup automático por seguridad
• ✅ Apertura automática de Access para validar

REFACTORING_PLAN.md - Plan Automático

Al exportar con access-export-git.ps1, se genera automáticamente un Plan de Refactorización que incluye:

Contenido del Plan

1. 📊 Inventario - Conteo automático de todos los objetos exportados
2. 🎯 Objetivos - Checklist editable de metas de refactorización
3. ✅ Checklist por Fases:
   • Análisis (revisar resumen, identificar módulos principales)
   • Planificación (priorizar, definir estándares)
   • Ejecución (refactorizar módulos, optimizar queries)
   • Validación (dry-run, importar, probar)
4. 📝 Registro de Cambios - Template para documentar cada modificación
5. 🔝 Notas de Refactorización:
   • Código problemático encontrado
   • Dependencias identificadas
   • Queries que necesitan optimización
6. 🚀 Comandos Git - Referencia rápida de comandos útiles
7. 📌 Próximos Pasos - Guía de workflow

Uso del Plan

• Editar objetivos según necesidades
• Marcar checkboxes conforme avanza (- [x])
• Documentar cada cambio en registro
• Añadir notas sobre problemas encontrados
• Versionar con Git (historial de planificación)

Important Notes

Cuándo Exportar Datos vs Solo Estructura

Exportar SOLO estructura (-ExportTableData:$false):

• ? Control de versiones Git (archivos más pequeños)
• ? Análisis de esquema de base de datos
• ? Refactorización de código VBA y queries
• ? Documentación de estructura
• ? Comparación de versiones de esquema
• ?? Los archivos .tabledata no se versionan bien en Git (grandes, binarios)

Exportar estructura + datos (-ExportTableData:$true):

• ? Backup completo antes de migraciones
• ? Transferir datos entre entornos
• ? Archivar estado completo de la aplicación
• ? Análisis de datos reales
• ? Testing con datos de producción
• ?? Archivos más grandes, commit Git pesado

Recomendación general: Para workflows de refactorización con Git, usa -ExportTableData:$false. Solo incluye datos para backups específicos fuera de Git.

UTF-8 Encoding

All exports use UTF-8 encoding. VS Code will display Spanish characters perfectly:

• ✅ Acentos: á, é, í, ó, ú
• ✅ Ñ and other special characters
• ✅ No manual encoding changes needed

VBA Access Requirements

Access must allow programmatic access to VBA project:

• File → Options → Trust Center → Trust Center Settings
• Enable "Trust access to the VBA project object model"

Limitations

• Cannot export binary objects (images, OLE objects)
• Form/report visual layout exported as text (not editable visually)
• Macros exported as definitions (not executable outside Access)
• Linked tables show connection info only

Safety

• Always creates backup before operations
• Non-destructive exports (original database unchanged)
• Import creates new backup before applying changes
• Logs all operations for traceability

Scripts Reference

access-export-git.ps1 ⭝ RECOMENDADO

Exportación automatizada con control de versiones Git integrado.

Usage:

# Pregunta interactivamente sobre exportar datos
.\access-export-git.ps1 -DatabasePath "C:\export\test\appGraz.accdb"

# Solo estructura (sin datos) - ideal para Git
.\access-export-git.ps1 -DatabasePath "C:\export\test\appGraz.accdb" -ExportTableData:$false

# Estructura + datos - backup completo
.\access-export-git.ps1 -DatabasePath "C:\export\test\appGraz.accdb" -ExportTableData:$true

# Con idioma específico
.\access-export-git.ps1 -DatabasePath "C:\export\test\appGraz.accdb" -Language "EN"

Parámetros:

• -DatabasePath: Ruta al archivo .accdb/.mdb (obligatorio)
• -ExportTableData: $true = estructura + datos, $false = solo estructura (pregunta si se omite)
• -Language: Idioma de exportación (ES/EN/DE/FR/IT, default: ES)
• -ExportFolder: Carpeta destino (default: {DatabaseName}_Export)

Características:

• Pregunta interactivamente si exportar datos de tablas (si no se especifica parámetro)
• Exporta a carpeta persistente: {DatabaseName}_Export
• Inicializa repositorio Git automáticamente
• Crea .gitignore para archivos temporales (.ldb, backups, errors)
• Commit automático con timestamp
• Muestra estadísticas de archivos exportados

Returns: Carpeta de exportación con Git inicializado

access-import-changed.ps1 ⭝ RECOMENDADO

Importación inteligente que solo importa archivos modificados detectados por Git.

Notas recientes (importacion robusta):

• Soporta consultas en .sql (crea QueryDef directamente).
• Elimina comentarios de linea -- antes de crear la consulta.
• Permite seleccion manual con -Interactive o por nombre (-QueryNames, -ModuleNames, -FormNames, -ReportNames, -MacroNames).
• Abre Access despues de liberar COM para evitar ventana en blanco o bloqueo.
• Para modulos/clases usa VBE (requiere "Trust access to the VBA project object model").

Usage:

# Dry-run (ver qué se importaría)
.\access-import-changed.ps1 -TargetDbPath "C:\path\to\db.accdb" `
                             -ExportFolder "C:\path\to\db_Export" `
                             -DryRun

# Importación real
.\access-import-changed.ps1 -TargetDbPath "C:\path\to\db.accdb" `
                             -ExportFolder "C:\path\to\db_Export"

Características:

• Detecta cambios con git diff HEAD~1 HEAD
• Solo importa objetos modificados (no todo)
• Backup automático antes de importar
• Progreso detallado por objeto (OK/ERROR)
• Reporte final de importados/errores

Returns: Count de objetos importados y errores

access-import.ps1

Re-import all exported objects back to Access (importación completa).

Usage:

.\access-import.ps1 -TargetDbPath "C:\path\to\db.accdb" -ImportFolder "C:\export"

# Con idioma específico
.\access-import.ps1 -TargetDbPath "C:\path\to\db.accdb" -ImportFolder "C:\export" -Language "EN"

Características:

• Backup automático antes de importar
• Compatible con carpetas multiidioma
• Sin interrupciones (sin MsgBox)
• Importa completo: queries, forms, reports, macros, VBA

Returns: Import log with success/failure details

access-backup.ps1

Create timestamped backup of Access file.

Usage:

.\access-backup.ps1 -DatabasePath "C:\path\to\db.accdb"

Returns: Path to backup file

Common Patterns

Pattern 1: Workflow Completo con Git (RECOMENDADO)

# Claude pregunta PRIMERO:
# "¿Deseas exportar los DATOS de las tablas? (S/N)"
# Usuario responde: "N" (solo estructura para Git)

# 1. Primera exportación con Git (solo estructura - ideal para control de versiones)
cd C:\Users\juanjo_admin\.copilot\skills\access-analyzer\scripts
.\access-export-git.ps1 -DatabasePath "C:\export\test\appGraz.accdb" -ExportTableData:$false

# 2. Abrir en VS Code
cd C:\export\test\appGraz_Export
code .

# 3. Refactorizar archivos en VS Code
# - Edita módulos .bas en 06_Codigo_VBA/
# - Modifica consultas .txt en 02_Consultas/
# - Guarda cambios

# 4. Ver cambios detectados por Git
git status
git diff

# 5. Crear commit con cambios
git add -A
git commit -m "Refactorización: mejorar lógica de X"

# 6. Ver qué se importaría (dry-run)
cd C:\Users\juanjo_admin\.copilot\skills\access-analyzer\scripts
.\access-import-changed.ps1 -TargetDbPath "C:\export\test\appGraz.accdb" `
                             -ExportFolder "C:\export\test\appGraz_Export" `
                             -DryRun

# 7. Importar SOLO lo modificado
.\access-import-changed.ps1 -TargetDbPath "C:\export\test\appGraz.accdb" `
                             -ExportFolder "C:\export\test\appGraz_Export"

# 8. Si algo salió mal, rollback con Git
cd C:\export\test\appGraz_Export
git log --oneline              # Ver historial
git revert HEAD                # Deshacer último commit
# O restaurar backup: appGraz_BACKUP_timestamp.accdb

Pattern 2: Quick Analysis (Sin Git)

User: "Analyze this Access database: C:\project\inventory.accdb"

Claude asks: "¿Deseas exportar los DATOS de las tablas? (S/N)"
User: "N" (solo necesito analizar código)

1. Create backup
2. Export structure only (-ExportTableData:$false)
3. Open in VS Code
4. Show 00_RESUMEN_APLICACION.txt
5. Provide high-level overview

Pattern 3: Backup Completo con Datos

User: "Create a complete backup with data for migration"

Claude asks: "¿Deseas exportar los DATOS de las tablas? (S/N)"
User: "S" (necesito los datos para migración)

1. Create timestamped backup of .accdb file
2. Export with -ExportTableData:$true
3. Archive export folder for migration
4. Document table structures and data formats

Pattern 4: Refactor Specific Module

User: "Refactor the invoice calculation module"

1. Export if not already done
2. Locate module in 06_Codigo_VBA/
3. Analyze code
4. Suggest improvements
5. Apply refactoring when approved
6. Re-import when user confirms

Pattern 5: Version Control Setup

User: "Set up version control for this Access app"

1. Export complete structure
2. Initialize git repository in export folder
3. Create .gitignore for Access-specific files
4. Create initial commit
5. Document workflow for team

Pattern 6: Database Documentation

User: "Document this Access database"

1. Export all objects
2. Analyze table relationships
3. Map query dependencies
4. Document form workflows
5. Generate comprehensive markdown documentation

Reference Files

• ExportTodoSimple.bas - Complete VBA export module (original)
• AccessObjectTypes.md - Reference for Access object types and properties
• VBA-Patterns.md - Common VBA patterns and refactoring guidelines

Troubleshooting

"Cannot access VBA project"

Solution: Enable "Trust access to the VBA project object model" in Access Trust Center settings.

"Export creates garbled characters"

Solution: Verify UTF-8 encoding in exported files. Re-export if necessary.

"Import fails for specific objects"

Solution: Check import log for specific errors. Some objects may need manual intervention.

"Database is locked/in use"

Solution: Close all Access instances and try again. Check for .laccdb lock files.

Security Considerations

• Never commit database files (.accdb) to version control
• Backup before any destructive operation
• Review imported code before executing in production
• Keep backups in separate location from source
• Use source control for exported text files only