librarian-indexer: Скилл для автоматизации разработки Odoo

--- name: librarian-indexer description: Meta-skill that indexes, optimizes, and auto-generates Claude skills with GitOps automation, OCA GitHub bot integration, and Odoo developer tools. Use for skill creation, CI/CD workflows, OCA module management, and advanced Odoo development. --- # Librarian Indexer Skill v2.0 ## Purpose Advanced meta-skill that combines knowledge base optimization, skill auto-generation, GitOps automation, OCA GitHub bot workflows, and Odoo developer mode expertise for maximum development efficiency. ## Version History ```yaml v2.0.0 (2025-10-30): added: - GitOps expertise (CI/CD, GitHub Actions) - OCA GitHub bot integration and commands - Odoo Developer Mode tools and techniques - Automated workflow patterns - Advanced debugging capabilities v1.0.0 (2025-10-30): - Initial release - Core skill templates - Knowledge base optimization - Skill taxonomy ``` ## Core Functions ### 1. Skill Taxonomy & Indexing Automatically catalog all skills with metadata: - **Category**: Technical, Business, Integration, Domain-Specific - **Dependencies**: Which skills/tools/APIs this skill relies on - **Cross-references**: Related skills, overlapping functionality - **Complexity**: Beginner, Intermediate, Advanced, Expert - **Update frequency**: Static knowledge vs. rapidly evolving domains - **GitOps**: CI/CD pipeline requirements, automated testing ### 2. GitOps Expertise #### CI/CD Pipeline Architecture ```yaml github_actions_workflows: module_testing: name: "Test Odoo Module" trigger: [push, pull_request] steps: - checkout_code - setup_odoo_environment - install_dependencies - run_unit_tests - run_integration_tests - generate_coverage_report best_practices: - Use OCA's maintainer-tools for testing - Test against multiple Odoo versions - Cache dependencies for speed - Fail fast on critical errors docker_build_push: name: "Build and Push Docker Image" trigger: [push_to_main, release] steps: - checkout_code - setup_docker_buildx - login_to_registry - build_multi_arch_image # AMD64, ARM64 - push_to_dockerhub - create_github_release best_practices: - Use multi-stage builds - Tag with version + latest - Sign images for security - Use BuildKit for caching oca_bot_integration: name: "OCA Bot Automated Workflows" trigger: [pull_request_review, schedule] commands: - /ocabot merge [major|minor|patch|nobump] - /ocabot rebase - /ocabot migration <module_name> automation: - Auto-generate README.rst from fragments - Auto-generate addon icons - Auto-update setup.py - Auto-approve with 2+ approvals - Auto-merge after 5 days + green CI deployment_pipeline: name: "Deploy to Production" trigger: [release, manual_dispatch] environments: [staging, production] steps: - run_all_tests - build_docker_image - push_to_registry - deploy_to_staging - run_smoke_tests - manual_approval - deploy_to_production - rollback_on_failure ``` #### Git Workflow Patterns ```bash # OCA-compliant Git workflow # 1. Fork and clone git clone https://github.com/YOUR_USERNAME/OCA_REPO.git cd OCA_REPO git remote add upstream https://github.com/OCA/OCA_REPO.git # 2. Create feature branch from target version git checkout -b 19.0-feat-new-feature origin/19.0 # 3. Make changes following OCA conventions # - One commit per logical change # - Conventional commit messages: feat:, fix:, docs:, etc. # - Sign commits: git commit -s # 4. Pre-commit hooks (OCA maintainer-tools) pre-commit install pre-commit run --all-files # 5. Push and create PR git push origin 19.0-feat-new-feature # Create PR via GitHub UI targeting OCA/19.0 # 6. Use OCA bot commands in PR # /ocabot merge minor (auto-merge with version bump) # /ocabot rebase (rebase on target branch) # /ocabot migration module_name (track migration) # 7. After merge, sync fork git checkout 19.0 git fetch upstream git merge upstream/19.0 git push origin 19.0 ``` #### GitHub Actions Templates ```yaml # .github/workflows/test.yml name: Test Odoo Modules on: push: branches: [19.0, 18.0] pull_request: branches: [19.0, 18.0] jobs: test: runs-on: ubuntu-latest strategy: matrix: odoo-version: ['19.0'] python-version: ['3.11'] services: postgres: image: postgres:15 env: POSTGRES_PASSWORD: postgres options: >- --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5 steps: - name: Checkout code uses: actions/checkout@v4 - name: Setup Python uses: actions/setup-python@v5 with: python-version: ${{ matrix.python-version }} - name: Cache dependencies uses: actions/cache@v3 with: path: ~/.cache/pip key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }} - name: Install OCA maintainer-tools run: | git clone https://github.com/OCA/maintainer-tools.git cd maintainer-tools pip install -r requirements.txt - name: Install Odoo run: | git clone --depth=1 --branch=${{ matrix.odoo-version }} https://github.com/odoo/odoo.git pip install -r odoo/requirements.txt - name: Install module dependencies run: | # Auto-detect and install OCA dependencies python maintainer-tools/tools/install_odoo_modules.py - name: Run tests run: | export ODOO_RC=/dev/null python -m pytest tests/ --cov=. --cov-report=xml - name: Upload coverage uses: codecov/codecov-action@v3 with: file: ./coverage.xml # .github/workflows/dockerhub-publish.yml name: Build and Push Docker Image on: push: branches: [main] tags: ['v*'] release: types: [published] jobs: docker: runs-on: ubuntu-latest steps: - name: Checkout uses: actions/checkout@v4 - name: Set up QEMU uses: docker/setup-qemu-action@v3 - name: Set up Docker Buildx uses: docker/setup-buildx-action@v3 - name: Login to DockerHub uses: docker/login-action@v3 with: username: ${{ secrets.DOCKERHUB_USERNAME }} password: ${{ secrets.DOCKERHUB_TOKEN }} - name: Docker meta id: meta uses: docker/metadata-action@v5 with: images: yourorg/insightpulse-odoo tags: | type=ref,event=branch type=semver,pattern={{version}} type=semver,pattern={{major}}.{{minor}} - name: Build and push uses: docker/build-push-action@v5 with: context: . platforms: linux/amd64,linux/arm64 push: true tags: ${{ steps.meta.outputs.tags }} labels: ${{ steps.meta.outputs.labels }} cache-from: type=gha cache-to: type=gha,mode=max ``` ### 3. OCA GitHub Bot Integration #### Bot Commands ```bash # Available commands in OCA repositories # Merge with version bump /ocabot merge major # Breaking changes (1.0.0 -> 2.0.0) /ocabot merge minor # New features (1.0.0 -> 1.1.0) /ocabot merge patch # Bug fixes (1.0.0 -> 1.0.1) /ocabot merge nobump # No version change (tests, docs) # Rebase PR on target branch /ocabot rebase # Track module migration /ocabot migration account_payment_order # Links PR to migration issue for version tracking # Bot will automatically: # ✅ Merge when CI is green and approved # ✅ Bump version in __manifest__.py # ✅ Update CHANGELOG with oca-towncrier # ✅ Generate wheels and upload to PyPI # ✅ Run all post-merge operations ``` #### Bot Automated Operations **Webhooks (Real-time)**: ```yaml on_pull_request_opened: - mention_maintainers # @-mention addon maintainers - call_for_maintainers # If no maintainers, ask for volunteers on_pull_request_approved: - set_approved_label # When 2+ approvals - set_ready_to_merge_label # When >5 days old on_ci_success: - set_needs_review_label # Unless "wip:" in title on_merge: - delete_pr_branch # Auto-cleanup - bump_version # If requested - update_changelog # With oca-towncrier - generate_wheel # Upload to PyPI ``` **Scheduled Tasks (Nightly)**: ```yaml daily_maintenance: - update_readme_table # Addons table in README.md - generate_addon_readme # From readme/ fragments - generate_addon_icons # Default OCA icon if missing - update_setup_py # Via setuptools-odoo-make-defaults - generate_wheels # For all addons - upload_to_pypi # Or rsync to PEP 503 index ``` #### Setting Up OCA Bot for Your Org ```bash # 1. Clone and configure git clone https://github.com/OCA/oca-github-bot.git cd oca-github-bot # 2. Create .env file cp environment.sample .env # Edit .env with your settings: GITHUB_TOKEN=ghp_xxxxx # GitHub PAT with repo access GITHUB_SECRET=your_webhook_secret BOT_TASKS=all # Or specific tasks BOT_TASKS_DISABLED= # Tasks to disable # 3. Docker Compose deployment docker-compose up -d # Services started: # - Bot webhook server (port 8080) # - Celery worker (task processor) # - Celery beat (scheduler) # - Flower (monitoring at port 5555) # - Redis (message queue) # 4. Configure GitHub webhook # URL: https://your-bot-url.com/webhooks # Content type: application/json # Secret: [value from GITHUB_SECRET] # Events: All or specific (pull_request, push, etc.) # 5. Test locally with ngrok ngrok http 8080 # Use ngrok URL for GitHub webhook during development ``` #### Custom Bot Tasks ```python # src/oca_github_bot/tasks/custom_validation.py from celery import task from ..github import gh_call @task() def validate_module_structure(org, repo, pr_number): """Custom task: Validate Odoo module structure""" # Get PR files files = gh_call(f'repos/{org}/{repo}/pulls/{pr_number}/files') required_files = [ '__manifest__.py', '__init__.py', 'README.rst', 'security/ir.model.access.csv' ] for module_path in detect_modules(files): missing = [] for req_file in required_files: if not file_exists(module_path, req_file): missing.append(req_file) if missing: # Post comment on PR gh_call( f'repos/{org}/{repo}/issues/{pr_number}/comments', method='POST', data={ 'body': f'⚠️ Module `{module_path}` is missing: {", ".join(missing)}' } ) return False return True ``` ### 4. Odoo Developer Mode #### Activation Methods ```python # Method 1: Settings app # Settings → Developer Tools → Activate the developer mode # Method 2: URL parameter https://example.odoo.com/odoo?debug=1 # Standard mode https://example.odoo.com/odoo?debug=assets # With JS assets https://example.odoo.com/odoo?debug=tests # With test tours https://example.odoo.com/odoo?debug=0 # Deactivate # Method 3: Command palette (Ctrl+K or Cmd+K) # Type "debug" → select activation mode # Method 4: Browser extension # Chrome: https://chromewebstore.google.com/detail/odoo-debug/... # Firefox: https://addons.mozilla.org/firefox/addon/odoo-debug/ ``` #### Developer Mode Tools **View Architecture:** ```python # In any view, click "Developer Mode" menu → Edit View: Form / Tree / Kanban / etc. → View Fields: See all field definitions → View Metadata: Created, modified, version info → Manage Filters: Edit search filters → Edit Action: Modify window actions → Edit Workflow: (Legacy) View state transitions # Access technical info on any field → Hover over field → See technical name → Right-click field → "View Field" - Name: account_id - Model: account.move - Type: many2one - Widget: many2one - Required: True - Readonly: False ``` **Database Tools:** ```python # Technical Menu Access Settings → Technical # Key sections: Database Structure/ ├── Models # All Odoo models (res.partner, sale.order, etc.) ├── Fields # Field definitions across all models ├── Menu Items # Application menu structure ├── Views # Form, tree, kanban, search views ├── Actions # Window actions, server actions, reports ├── Translations # i18n strings └── Parameters # System parameters (ir.config_parameter) Sequences/ └── Sequences # Number sequences (SO001, INV/2024/0001, etc.) Automation/ ├── Scheduled Actions (Cron) # Background jobs ├── Automation Rules # Trigger-based automation └── Server Actions # Python code execution Security/ ├── Users & Companies ├── Groups # Access groups ├── Access Rights # Model-level (ir.model.access) ├── Record Rules # Row-level security └── Access Control Lists # File access ``` **Python Debugging:** ```python # In Odoo shell or code # 1. Enable debug mode programmatically self.env.user.write({'debug': True}) # 2. Debug ORM queries import logging _logger = logging.getLogger(__name__) # Log SQL queries _logger.setLevel(logging.DEBUG) self.env['sale.order'].search([('state', '=', 'draft')]) # SQL: SELECT "sale_order".id FROM "sale_order" WHERE ... # 3. Inspect recordsets order = self.env['sale.order'].browse(1) _logger.info(f"Order: {order}") _logger.info(f"Fields: {order.fields_get()}") _logger.info(f"Values: {order.read()}") # 4. Test computed fields order._compute_amount_total() # 5. Check access rights self.env['sale.order'].check_access_rights('write', raise_exception=False) order.check_access_rule('write') # 6. View active context _logger.info(f"Context: {self.env.context}") # 7. Use debugger breakpoints import pdb; pdb.set_trace() # Or use built-in debugger in IDE ``` **XML ID Inspector:** ```python # Find XML ID for any record # Method 1: Developer mode menu → View Metadata → External ID # Method 2: Python record = self.env['res.partner'].browse(1) xml_id = record.get_external_id() # Returns: {'1': 'base.main_partner'} # Method 3: Search by XML ID partner = self.env.ref('base.main_partner') # Method 4: Create with XML ID self.env['ir.model.data'].create({ 'module': 'my_module', 'name': 'partner_demo', 'model': 'res.partner', 'res_id': partner.id, }) ``` **Performance Profiling:** ```python # Enable profiling in odoo.conf [options] limit_time_cpu = 3600 limit_time_real = 7200 log_level = debug log_db = True log_db_level = debug # Or via URL ?debug=1&profile=1 # View profiles at: # /web/profiler # Python profiling import cProfile import pstats profiler = cProfile.Profile() profiler.enable() # Your code here self.env['sale.order'].search([]) profiler.disable() stats = pstats.Stats(profiler) stats.sort_stats('cumulative') stats.print_stats(20) # Top 20 slow functions ``` ### 5. Knowledge Base Optimization #### Information Architecture Patterns **Pattern 1: API-First Documentation** Best for: Odoo, OCA, Salesforce, SAP ```markdown Structure: 1. Quick Reference (most common operations) 2. API Endpoints/Methods (with examples) 3. Data Models/Schema 4. Integration Patterns 5. GitOps/CI-CD workflows 6. Troubleshooting Guide 7. Deep Reference (comprehensive docs) ``` **Pattern 2: Decision Tree Format** Best for: Module selection, architecture decisions ```markdown Structure: 1. Decision flowchart (IF/THEN logic) 2. Comparison matrices 3. Use case mappings 4. Cost/benefit analysis 5. Implementation priorities 6. GitOps automation opportunities ``` **Pattern 3: Recipe Book** Best for: Deployment, automation, scripts ```markdown Structure: 1. Prerequisites checklist 2. Step-by-step instructions (copy-paste ready) 3. Configuration templates 4. GitHub Actions workflows 5. OCA bot commands 6. Validation steps 7. Common pitfalls & solutions 8. Real examples from your stack ``` ### 6. Skill Generation Templates #### Template A: SaaS Replacement Skill ```markdown # [SaaS Product] → Odoo Replacement ## Gap Analysis - Feature comparison matrix - OCA module coverage - Custom module requirements - GitOps considerations ## Implementation Guide - Module installation order - Configuration steps - Integration points (Supabase, Superset, Notion) - CI/CD pipeline setup ## Migration Path - Data export from SaaS - Import scripts/mappings - User training plan - Rollback strategy ## GitOps Automation - GitHub Actions workflows - Automated testing - Deployment pipelines - OCA bot integration ## Cost Savings - Annual licensing: $XXX - Self-hosted cost: $XX - Net savings: $XXX ## Maintenance - Update schedule - Backup strategy - Monitoring setup - Support resources ``` #### Template B: GitOps Workflow Skill ```markdown # [Project] GitOps Automation ## Repository Structure - Branch strategy - Commit conventions - PR templates - Code review process ## CI/CD Pipeline - Test workflows - Build processes - Deployment stages - Rollback procedures ## OCA Bot Integration - Webhook configuration - Automated tasks - Bot commands - Custom workflows ## Monitoring - GitHub Actions logs - Deployment metrics - Error tracking - Performance monitoring ``` #### Template C: Odoo Development Skill ```markdown # [Module/Feature] Development Guide ## Developer Mode Setup - Activation methods - Debugging tools - Performance profiling ## Module Structure - Required files - Naming conventions - OCA compliance ## Development Workflow - Local development setup - Git workflow with OCA bot - Testing strategy - CI/CD integration ## Debugging Techniques - ORM query inspection - Computed field testing - Access rights validation - XML ID management ``` ### 7. Skill Dependency Mapping ```yaml skill_dependencies: odoo-finance-automation: requires: - odoo19-oca-devops (deployment) - supabase-rpc-manager (database) - paddle-ocr-validation (document processing) - gitops-odoo (CI/CD workflows) - oca-bot-integration (automated merges) integrates_with: - superset-dashboard-automation (reporting) - notion-workflow-sync (task management) - travel-expense-management (AP integration) gitops: - .github/workflows/test-finance-module.yml - .github/workflows/deploy-finance.yml oca-module-development: requires: - gitops-odoo (GitHub Actions) - oca-bot-integration (merge automation) - odoo-developer-mode (debugging) tools: - pre-commit hooks - OCA maintainer-tools - pytest for testing workflows: - Fork → Feature branch → PR → OCA bot → Merge ``` ### 8. GitOps Best Practices #### Repository Organization ```bash odoo-project/ ├── .github/ │ ├── workflows/ │ │ ├── test.yml # Run tests on PR │ │ ├── deploy-staging.yml # Auto-deploy to staging │ │ ├── deploy-production.yml # Manual production deploy │ │ ├── oca-bot-sync.yml # Sync with OCA upstream │ │ └── security-scan.yml # Dependency vulnerabilities │ ├── PULL_REQUEST_TEMPLATE.md │ └── ISSUE_TEMPLATE/ │ ├── bug_report.md │ └── feature_request.md ├── .pre-commit-config.yaml # Code quality checks ├── .dockerignore ├── .gitignore ├── docker-compose.yml # Local development ├── docker-compose.prod.yml # Production config ├── Dockerfile # Multi-stage build ├── odoo.conf # Odoo configuration ├── requirements.txt # Python dependencies └── addons/ # Custom and OCA modules ├── custom_module_1/ ├── custom_module_2/ └── README.md ``` #### Pre-commit Configuration ```yaml # .pre-commit-config.yaml repos: - repo: https://github.com/pre-commit/pre-commit-hooks rev: v4.5.0 hooks: - id: trailing-whitespace - id: end-of-file-fixer - id: check-yaml - id: check-added-large-files - repo: https://github.com/psf/black rev: 23.12.1 hooks: - id: black language_version: python3.11 - repo: https://github.com/PyCQA/flake8 rev: 7.0.0 hooks: - id: flake8 args: ['--max-line-length=88', '--extend-ignore=E203,W503'] - repo: https://github.com/PyCQA/isort rev: 5.13.2 hooks: - id: isort args: ['--profile', 'black'] - repo: https://github.com/OCA/pylint-odoo rev: 8.0.23 hooks: - id: pylint_odoo args: ['--load-plugins=pylint_odoo'] ``` #### Conventional Commits ```bash # Format: <type>(<scope>): <subject> # Types: feat: New feature fix: Bug fix docs: Documentation only style: Code style changes (formatting, etc.) refactor: Code refactoring perf: Performance improvement test: Add or update tests build: Build system changes ci: CI/CD changes chore: Other changes (dependencies, etc.) # Examples: git commit -m "feat(account): add BIR 1601-C report generation" git commit -m "fix(sale): correct tax calculation for multi-currency" git commit -m "docs(readme): update installation instructions" git commit -m "ci: add automated testing workflow" git commit -m "refactor(purchase): optimize RFQ performance" # Use -s to sign commits (required by OCA) git commit -s -m "feat(stock): add warehouse optimization" ``` ### 9. Advanced Debugging Techniques #### Debug Mode Shortcuts ```python # Browser console tricks (with debug mode active) # 1. Access Odoo client-side window.odoo.__DEBUG__.services # 2. Inspect current view window.odoo.__DEBUG__.services.action.currentController # 3. Call RPC from browser await window.odoo.__DEBUG__.services.rpc('/web/dataset/call_kw', { model: 'sale.order', method: 'read', args: [[1], ['name', 'amount_total']], kwargs: {} }) # 4. Reload assets without restart window.location = window.location.href.replace(/?.*/, '?debug=assets') # 5. View loaded modules window.odoo.define.modules ``` #### Server-side Debugging ```python # 1. Odoo shell access odoo-bin shell -d database_name -c /etc/odoo/odoo.conf # In shell: >>> env = api.Environment(cr, SUPERUSER_ID, {}) >>> partners = env['res.partner'].search([('is_company', '=', True)]) >>> partners.mapped('name') # 2. Remote debugging (PyCharm, VSCode) # In odoo.conf: [options] dev_mode = reload,qweb,werkzeug,xml # In code: import pydevd_pycharm pydevd_pycharm.settrace('localhost', port=5678, stdoutToServer=True) # 3. Logging import logging _logger = logging.getLogger(__name__) _logger.debug("Debug message") _logger.info("Info message") _logger.warning("Warning message") _logger.error("Error message") _logger.exception("Exception with traceback") # 4. SQL debugging self.env.cr.execute("SELECT * FROM sale_order WHERE state = %s", ('draft',)) results = self.env.cr.dictfetchall() _logger.info(f"SQL Results: {results}") ``` ### 10. Skill Quality Checklist Every skill should have: - [ ] Clear purpose statement (1-2 sentences) - [ ] When to use this skill (trigger patterns) - [ ] Prerequisites/dependencies - [ ] Quick reference section (most common operations) - [ ] Detailed reference (comprehensive) - [ ] Real examples from your stack - [ ] Integration points with other skills - [ ] GitOps automation examples - [ ] OCA bot commands (if applicable) - [ ] Debugging techniques - [ ] Common pitfalls & solutions - [ ] Update date & version info - [ ] Links to authoritative sources - [ ] CI/CD pipeline examples ### 11. Skill Optimization Techniques #### Information Density ```markdown ❌ Low Density: "You can use GitHub Actions to automate testing." ✅ High Density: "GitHub Actions workflow: .github/workflows/test.yml trigger: push, pull_request steps: checkout → setup python → install deps → pytest OCA bot auto-merges after 2 approvals + green CI + 5 days" ``` #### Actionable Focus ```markdown ❌ Vague: "Consider using OCA bot for automation." ✅ Actionable: "In PR comment: /ocabot merge minor # Auto-merge with version bump /ocabot rebase # Rebase on target branch Bot runs: tests → bump version → update changelog → generate wheels → upload PyPI" ``` #### Context Embedding ```markdown ✅ Include YOUR specific context: - "For InsightPulse-Odoo deployment..." - "In .github/workflows/deploy.yml..." - "Using OCA/account-financial-tools modules..." - "Supabase project: spdtwktxdalcfigzeqrz" - "/ocabot merge patch for hotfixes" ``` ### 12. Skill Library Structure ``` /skills/ ├── meta/ │ ├── librarian-indexer/ # This skill v2.0 │ ├── gitops-automation/ # CI/CD patterns │ └── skill-creator/ # Anthropic's skill creator ├── platform/ │ ├── odoo19-oca-devops/ # OCA bot, developer mode │ ├── github-actions/ # Workflow templates │ ├── supabase-rpc-manager/ │ └── superset-dashboard-automation/ ├── domain/ │ ├── odoo-finance-automation/ │ ├── oca-module-development/ # OCA standards │ └── philippines-tax-compliance/ ├── integration/ │ ├── oca-bot-integration/ # Bot setup & commands │ ├── notion-workflow-sync/ │ ├── paddle-ocr-validation/ │ └── multi-agency-orchestrator/ ├── saas-replacement/ │ ├── travel-expense-management/ │ ├── procurement-sourcing/ │ ├── salesforce-crm-parity/ │ └── netsuite-erp-parity/ └── templates/ ├── saas-replacement.template.md ├── gitops-workflow.template.md ├── oca-module.template.md └── domain-knowledge.template.md ``` ### 13. Auto-Generation Workflows #### Workflow 1: New OCA Module Skill ```bash Input: "Create OCA module skill for account_financial_report" Steps: 1. Clone OCA/account-financial-tools repository 2. Analyze module structure with appsrc.py 3. Extract README.rst content 4. Document dependencies from __manifest__.py 5. Generate usage examples 6. Add OCA bot workflow integration 7. Create GitHub Actions test workflow 8. Include debugging techniques 9. Output: Complete skill file ``` #### Workflow 2: GitOps Automation Skill ```bash Input: "Create CI/CD pipeline for [project]" Steps: 1. Analyze project structure 2. Generate .github/workflows/*.yml 3. Configure OCA bot (if OCA repo) 4. Set up pre-commit hooks 5. Create Docker build workflow 6. Add deployment pipelines 7. Configure monitoring 8. Output: Complete GitOps setup ``` #### Workflow 3: Debug Skill Enhancement ```bash Input: "Add debugging guide to [skill]" Steps: 1. Load existing skill 2. Add Odoo developer mode section 3. Include ORM debugging techniques 4. Add performance profiling 5. Document common issues 6. Provide troubleshooting flowchart 7. Output: Enhanced skill ``` ### 14. Skill Triggers for Auto-Loading When Jake mentions: - "Odoo", "OCA", "module" → Load odoo19-oca-devops + oca-bot-integration - "GitHub Actions", "CI/CD", "workflow" → Load gitops-automation - "debug", "developer mode", "troubleshoot" → Load odoo-developer-mode - "/ocabot", "bot command", "auto-merge" → Load oca-bot-integration - "BIR", "1601-C", "month-end" → Load odoo-finance-automation - "Supabase", "pgvector", "RPC" → Load supabase-rpc-manager - "Superset", "dashboard", "chart" → Load superset-dashboard-automation - "pre-commit", "pylint", "black" → Load gitops-automation - "pytest", "test", "coverage" → Load odoo-testing-guide - "Docker", "build", "deploy" → Load docker-deployment + gitops-automation ### 15. Best Practices Database #### Odoo Development ```python # ORM Best Practices ✅ DO: Use search_read for better performance records = self.env['sale.order'].search_read( [('state', '=', 'draft')], ['name', 'amount_total'] ) ❌ DON'T: Use search then read separately records = self.env['sale.order'].search([('state', '=', 'draft')]) for record in records: name = record.name # N+1 query problem # Computed Fields ✅ DO: Use @api.depends properly @api.depends('order_line.price_total') def _compute_amount_total(self): for order in self: order.amount_total = sum(order.order_line.mapped('price_total')) ❌ DON'T: Forget dependencies def _compute_amount_total(self): # Will not recompute! for order in self: order.amount_total = sum(order.order_line.mapped('price_total')) # Security ✅ DO: Use ir.model.access.csv + record rules # ir.model.access.csv id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink access_sale_order_user,sale.order.user,model_sale_order,sales_team.group_sale_salesman,1,1,1,0 ❌ DON'T: Use sudo() everywhere records = self.env['sale.order'].sudo().search([]) # Bypasses security! ``` #### OCA Module Compliance ```python # __manifest__.py Structure { 'name': 'Module Name', 'version': '19.0.1.0.0', # Major.Minor.Patch.Fix.Build 'category': 'Accounting', 'summary': 'Short description', 'author': 'Your Company, Odoo Community Association (OCA)', 'website': 'https://github.com/OCA/project-name', 'license': 'AGPL-3', # or LGPL-3, GPL-3 'depends': ['base', 'account'], 'data': [ 'security/ir.model.access.csv', 'views/account_views.xml', 'data/account_data.xml', ], 'demo': [ 'demo/account_demo.xml', ], 'installable': True, 'application': False, 'auto_install': False, } # Module Structure my_module/ ├── __init__.py ├── __manifest__.py ├── models/ │ ├── __init__.py │ └── account_move.py ├── views/ │ └── account_move_views.xml ├── security/ │ └── ir.model.access.csv ├── data/ │ └── account_data.xml ├── static/ │ └── description/ │ ├── index.html │ └── icon.png ├── readme/ │ ├── CONFIGURE.rst │ ├── USAGE.rst │ └── CONTRIBUTORS.rst └── tests/ ├── __init__.py └── test_account.py ``` #### GitOps Best Practices ```yaml # Workflow Optimization ✅ DO: Use caching - name: Cache pip uses: actions/cache@v3 with: path: ~/.cache/pip key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }} ✅ DO: Use matrix strategy for multiple versions strategy: matrix: odoo-version: ['18.0', '19.0'] python-version: ['3.10', '3.11'] ✅ DO: Fail fast for critical issues strategy: fail-fast: true matrix: ... ❌ DON'T: Hardcode secrets in workflows # Use GitHub Secrets instead: - name: Deploy env: API_TOKEN: ${{ secrets.API_TOKEN }} ❌ DON'T: Run expensive operations on every commit # Use path filters: on: push: paths: - 'src/**' - 'tests/**' ``` ### 16. Success Metrics Track for each skill: - **Usage frequency**: How often referenced - **Success rate**: Solves problem first time? - **Completeness**: Needs follow-up searches? - **Accuracy**: Examples/commands correct? - **Integration**: Works with other skills? - **GitOps efficiency**: Reduces manual work? - **Debugging effectiveness**: Resolves issues faster? - **OCA compliance**: Follows standards? ### 17. Meta Notes This skill v2.0 demonstrates advanced principles: - ✅ Clear purpose statement - ✅ GitOps automation integration - ✅ OCA bot command reference - ✅ Odoo developer mode techniques - ✅ Actionable templates with workflows - ✅ Real examples from CI/CD pipelines - ✅ Decision trees and debugging flowcharts - ✅ Integration with other skills - ✅ Maintenance strategy - ✅ Versioning approach **When to use this skill:** - Creating any new skill - Setting up GitOps workflows - Configuring OCA bot automation - Debugging Odoo issues - Optimizing existing skills - Planning skill architecture - Resolving skill conflicts - Maintaining skill library - Auto-generating documentation - Troubleshooting CI/CD pipelines **Success criteria:** - Reduced time to create new skills (50% faster) - Automated CI/CD reduces deployment time (80% faster) - Higher quality skills (fewer iterations) - Better debugging efficiency (70% faster issue resolution) - Easier maintenance - More effective Claude responses - OCA-compliant code by default