@mytechtoday/augment-extensions 0.1.2 → 0.4.0

package/augment-extensions/workflows/database/rules/workflow.md

@@ -0,0 +1,458 @@
+# Database Design and Development Workflow
+
+## Overview
+
+This workflow provides comprehensive guidance for AI agents working on database-related tasks, from initial database selection through schema design, implementation, migration, optimization, and testing.
+
+## Core Workflow
+
+```
+┌─────────────────────┐
+│ Database Selection  │
+│ Choose DB type      │
+└──────────┬──────────┘
+           │
+           ▼
+┌─────────────────────┐
+│ Schema Design       │
+│ Model entities      │
+└──────────┬──────────┘
+           │
+           ▼
+┌─────────────────────┐
+│ Implementation      │
+│ Create schema       │
+└──────────┬──────────┘
+           │
+           ▼
+┌─────────────────────┐
+│ Migration           │
+│ Version changes     │
+└──────────┬──────────┘
+           │
+           ▼
+┌─────────────────────┐
+│ Optimization        │
+│ Tune performance    │
+└──────────┬──────────┘
+           │
+           ▼
+┌─────────────────────┐
+│ Testing             │
+│ Validate behavior   │
+└─────────────────────┘
+```
+
+## Coordination with OpenSpec and Beads
+
+Database work should be tracked using OpenSpec specifications and Beads tasks:
+
+**OpenSpec Integration**:
+- Create specs in `openspec/specs/database/`
+- Document schema requirements and design decisions
+- Track breaking changes and migration strategies
+
+**Beads Integration**:
+- Create tasks with `bd create "Task description"`
+- Reference specs: `"spec": "database/schema-design"`
+- Track dependencies between schema changes
+
+**Example Task**:
+```json
+{
+  "id": "bd-db01",
+  "title": "Design user authentication schema",
+  "spec": "database/user-auth-schema",
+  "rules": ["schema-design-workflow.md"],
+  "status": "open",
+  "priority": 0
+}
+```
+
+## Workflow Steps
+
+### Step 1: Database Selection
+
+**Purpose**: Choose the right database type for your use case
+
+**Decision Framework**:
+
+1. **Analyze Data Structure**:
+   - Structured (tables, rows) → Relational (PostgreSQL, MySQL)
+   - Semi-structured (documents) → NoSQL (MongoDB, DynamoDB)
+   - Graph relationships → Graph DB (Neo4j, ArangoDB)
+   - Vector embeddings → Vector DB (Pinecone, Milvus)
+   - Simple key-value → Redis, DynamoDB
+   - Flat files → CSV, JSON
+
+2. **Analyze Query Patterns**:
+   - Complex joins and aggregations → Relational
+   - Document retrieval → NoSQL
+   - Graph traversal → Graph DB
+   - Similarity search → Vector DB
+   - Simple lookups → Key-value store
+
+3. **Analyze Scale Requirements**:
+   - < 1M records → SQLite, PostgreSQL, MySQL
+   - 1M - 100M records → PostgreSQL, MySQL, MongoDB
+   - > 100M records → Distributed DB (DynamoDB, Cassandra)
+
+4. **Consider Operational Requirements**:
+   - ACID guarantees needed → Relational
+   - Eventual consistency acceptable → NoSQL
+   - Managed service preferred → Cloud-native (RDS, DynamoDB)
+   - Self-hosted required → PostgreSQL, MySQL, MongoDB
+
+**Output**: Database selection with documented rationale
+
+**AI Prompt Template**:
+```
+I need to select a database for [use case]. Requirements:
+- Data structure: [structured/semi-structured/unstructured]
+- Query patterns: [describe common queries]
+- Scale: [number of records, growth rate]
+- Consistency needs: [strong/eventual]
+- Operational constraints: [managed/self-hosted, budget]
+
+Please recommend a database type and specific database, with rationale.
+```
+
+### Step 2: Schema Design
+
+**Purpose**: Design optimal database schema
+
+See `schema-design-workflow.md` for detailed guidance.
+
+**Quick Steps**:
+1. Identify entities and attributes
+2. Map relationships between entities
+3. Apply normalization (relational) or denormalization (NoSQL)
+4. Define constraints and validation rules
+5. Plan indexes for common queries
+6. Review and validate design
+
+**Output**: Schema design document with ERD or data model
+
+### Step 3: Implementation
+
+**Purpose**: Create database schema in target database
+
+**Steps**:
+
+1. **Set Up Database Environment**:
+   - Install database locally or provision cloud instance
+   - Configure connection settings
+   - Set up database users and permissions
+
+2. **Create Schema**:
+   - Write DDL (Data Definition Language) scripts
+   - Include comments for documentation
+   - Add constraints and indexes
+   - Version control schema files
+
+3. **Seed Initial Data** (if needed):
+   - Create seed data scripts
+   - Include reference data (countries, categories, etc.)
+   - Document data sources
+
+**Output**: Executable schema scripts in version control
+
+**AI Prompt Template**:
+```
+Create database schema for [database type] based on this design:
+
+[paste schema design]
+
+Requirements:
+- Include table/collection definitions
+- Add appropriate constraints
+- Create indexes for common queries
+- Add comments for documentation
+- Make scripts idempotent
+
+Please generate DDL/schema creation scripts.
+```
+
+### Step 4: Migration Management
+
+**Purpose**: Safely evolve database schema over time
+
+See `data-migration.md` for detailed guidance.
+
+**Quick Steps**:
+1. Plan migration (what changes, impact, rollback)
+2. Create up and down migration scripts
+3. Test on staging data
+4. Execute migration with monitoring
+5. Verify success and data integrity
+
+**Output**: Versioned migration scripts with rollback plans
+
+### Step 5: Optimization
+
+**Purpose**: Improve database performance
+
+See `optimization-workflow.md` for detailed guidance.
+
+**Quick Steps**:
+1. Identify slow queries (profiling, logs)
+2. Analyze query execution plans
+3. Add or optimize indexes
+4. Refactor queries
+5. Consider denormalization or caching
+6. Measure improvements
+
+**Output**: Optimized queries and schema with performance metrics
+
+### Step 6: Testing
+
+**Purpose**: Validate database behavior and performance
+
+See `testing-patterns.md` for detailed guidance.
+
+**Quick Steps**:
+1. Set up test database environment
+2. Create test fixtures and seed data
+3. Write unit tests (constraints, validation)
+4. Write integration tests (queries, transactions)
+5. Write performance tests (load, stress)
+6. Run tests in CI/CD pipeline
+
+**Output**: Comprehensive test suite with fixtures
+
+---
+
+## Database Type-Specific Workflows
+
+### Relational Databases (PostgreSQL, MySQL, SQL Server)
+
+**Schema Design**:
+- Normalize to 3NF (Third Normal Form)
+- Use foreign keys for referential integrity
+- Add check constraints for validation
+- Create indexes on foreign keys and query columns
+
+**Migration Tools**:
+- **PostgreSQL**: Flyway, Liquibase, Alembic (Python), Knex (Node.js)
+- **MySQL**: Flyway, Liquibase, Laravel Migrations (PHP)
+- **SQL Server**: Entity Framework Migrations, Flyway
+
+**Best Practices**:
+- Use transactions for data consistency
+- Add indexes carefully (balance read vs write performance)
+- Use EXPLAIN/EXPLAIN ANALYZE to understand query plans
+- Monitor connection pool usage
+
+### NoSQL Databases (MongoDB, DynamoDB)
+
+**Schema Design**:
+- Denormalize for query efficiency
+- Embed related data in documents
+- Use references for large or frequently updated data
+- Design for access patterns, not normalization
+
+**Migration Strategies**:
+- Schema-less doesn't mean schema-free
+- Version documents with schema version field
+- Migrate data lazily (on read) or in batches
+- Use application-level schema validation
+
+**Best Practices**:
+- Design for your query patterns
+- Avoid large documents (> 16MB in MongoDB)
+- Use indexes on query fields
+- Monitor document size and collection growth
+
+### Vector Databases (Pinecone, Milvus, Weaviate)
+
+**Schema Design**:
+- Define vector dimensions (match embedding model)
+- Choose distance metric (cosine, euclidean, dot product)
+- Plan metadata fields for filtering
+- Consider hybrid search (vector + keyword)
+
+**Index Configuration**:
+- Choose index type (HNSW, IVF, etc.)
+- Tune index parameters (ef_construction, M)
+- Balance accuracy vs speed
+- Plan for index rebuild time
+
+**Best Practices**:
+- Normalize vectors before insertion
+- Use metadata filtering to reduce search space
+- Batch insertions for better performance
+- Monitor index size and query latency
+
+### Flat Databases (CSV, JSON files)
+
+**Schema Design**:
+- Define clear column/field names
+- Document data types and formats
+- Use consistent date/time formats (ISO 8601)
+- Plan for schema evolution
+
+**File Management**:
+- Use version control for schema definitions
+- Validate data on read/write
+- Consider file size limits (split large files)
+- Use compression for storage efficiency
+
+**Best Practices**:
+- Validate data with JSON Schema or CSV schema
+- Use streaming for large files
+- Implement proper error handling
+- Consider migration to database if data grows
+
+---
+
+## AI Prompt Templates
+
+### Database Selection
+
+```
+I need to select a database for [application type]. Requirements:
+
+**Data Characteristics**:
+- Structure: [structured/semi-structured/unstructured]
+- Volume: [current size, growth rate]
+- Relationships: [simple/complex graph]
+
+**Query Patterns**:
+- [Query pattern 1]: [frequency, complexity]
+- [Query pattern 2]: [frequency, complexity]
+
+**Non-Functional Requirements**:
+- Consistency: [strong ACID / eventual consistency]
+- Availability: [uptime requirements]
+- Scale: [read/write throughput]
+- Budget: [constraints]
+- Expertise: [team skills]
+
+Please recommend a database with rationale and trade-offs.
+```
+
+### Schema Design
+
+```
+Design a database schema for [application type].
+
+**Entities**:
+- [Entity 1]: [attributes and types]
+- [Entity 2]: [attributes and types]
+
+**Relationships**:
+- [Entity 1] [relationship type] [Entity 2]
+
+**Common Queries**:
+- [Query 1]: [description]
+- [Query 2]: [description]
+
+**Constraints**:
+- [Constraint 1]
+- [Constraint 2]
+
+Please design an optimal schema with normalization, constraints, and indexes.
+```
+
+### Migration Planning
+
+```
+Plan a database migration for [describe change].
+
+**Current Schema**:
+[paste current schema]
+
+**Desired Schema**:
+[paste desired schema or describe changes]
+
+**Constraints**:
+- Zero downtime: [yes/no]
+- Backward compatibility: [yes/no]
+- Data volume: [number of rows]
+- Database: [type and version]
+
+Please create a migration plan with up/down scripts and rollback strategy.
+```
+
+### Query Optimization
+
+```
+Optimize this slow query:
+
+**Query**:
+[paste query]
+
+**Execution Plan**:
+[paste EXPLAIN output]
+
+**Schema**:
+[paste relevant table definitions]
+
+**Performance Issue**:
+- Current execution time: [time]
+- Target execution time: [time]
+- Data volume: [number of rows]
+
+Please suggest optimizations (indexes, query rewrite, schema changes).
+```
+
+---
+
+## Best Practices
+
+### DO
+
+✅ Document database selection rationale
+✅ Version control all schema and migration scripts
+✅ Test migrations on production-like data
+✅ Monitor database performance metrics
+✅ Use transactions for data consistency
+✅ Add indexes based on query patterns
+✅ Plan for rollback before executing migrations
+✅ Use connection pooling in applications
+
+### DON'T
+
+❌ Choose database without analyzing requirements
+❌ Make schema changes without migration scripts
+❌ Skip testing migrations before production
+❌ Add indexes without measuring impact
+❌ Store sensitive data without encryption
+❌ Ignore database performance metrics
+❌ Deploy code and schema changes simultaneously
+❌ Forget to document design decisions
+
+---
+
+## Common Pitfalls
+
+**Pitfall 1: Premature Optimization**
+- ❌ Adding indexes before understanding query patterns
+- ✅ Profile queries first, then optimize based on data
+
+**Pitfall 2: Over-Normalization**
+- ❌ Normalizing to 5NF causing excessive joins
+- ✅ Balance normalization with query performance
+
+**Pitfall 3: Under-Indexing**
+- ❌ No indexes on foreign keys or query columns
+- ✅ Add indexes for common query patterns
+
+**Pitfall 4: Ignoring Migrations**
+- ❌ Making schema changes directly in production
+- ✅ Use versioned migration scripts with rollback
+
+**Pitfall 5: Not Testing at Scale**
+- ❌ Testing with small datasets
+- ✅ Test with production-like data volumes
+
+---
+
+## Next Steps
+
+- See `schema-design-workflow.md` for detailed schema design process
+- See `data-migration.md` for migration management strategies
+- See `optimization-workflow.md` for performance tuning guidance
+- See `testing-patterns.md` for database testing approaches
+- See `documentation-standards.md` for documenting database designs
+

package/augment-extensions/workflows/openspec/module.json

@@ -3,7 +3,7 @@
   "version": "1.0.0",
   "displayName": "OpenSpec Workflow",
   "description": "Spec-driven development (SDD) workflow for AI coding assistants. Provides structured change management with proposals, specs, and tasks.",
-  "type": "workflow",
+  "type": "workflows",
   "author": "Augment Extensions",
   "license": "MIT",
   "keywords": [
@@ -16,9 +16,10 @@
     "change-management"
   ],
   "augment": {
-    "characterCount": 30509,
+    "characterCount": 32661,
     "priority": "high",
-    "category": "workflow",
+    "category": "workflows",
+    "tags": ["openspec", "spec-driven-development", "workflow", "change-management"],
     "compatibleWith": [
       "Claude Code",
       "CodeBuddy",

package/augment-extensions/workflows/wordpress-plugin/README.md

@@ -0,0 +1,232 @@
+# WordPress Plugin Development Workflow Module
+
+## Overview
+
+This module provides complete workflows for WordPress plugin development, optimized for AI-assisted development using Augment Code AI, OpenSpec, and Beads task management.
+
+## Key Benefits
+
+- **Scaffolding Workflow**: Automated plugin structure creation with proper headers and boilerplate
+- **Development Workflow**: Feature development cycle with testing and validation
+- **Testing Workflow**: PHPUnit setup, integration tests, and WordPress test suite
+- **Submission Workflow**: WordPress.org submission preparation and process
+- **AI-Optimized**: Structured workflows with clear prompts and task breakdowns
+- **Beads Integration**: Task templates for plugin development phases
+
+## Installation
+
+### With CLI (Future)
+```bash
+augx link workflows/wordpress-plugin
+```
+
+### Manual Installation
+Copy the contents of this module to your project's `.augment/` directory or reference it from the Augment Extensions repository.
+
+## Directory Structure
+
+```
+augment-extensions/workflows/wordpress-plugin/
+├── module.json                          # Module metadata
+├── README.md                            # This file
+├── rules/                               # Workflow documentation
+│   ├── scaffolding-workflow.md          # Plugin creation workflow
+│   ├── development-workflow.md          # Feature development cycle
+│   ├── testing-workflow.md              # Testing setup and execution
+│   ├── submission-workflow.md           # WordPress.org submission
+│   └── best-practices.md                # Workflow best practices
+└── examples/                            # Workflow examples
+    ├── plugin-creation-workflow.md      # Complete plugin creation example
+    ├── feature-addition-workflow.md     # Adding features to existing plugin
+    ├── security-audit-workflow.md       # Security audit process
+    └── wordpress-org-submission-workflow.md  # Real submission example
+```
+
+## Core Workflows
+
+### 1. Scaffolding Workflow
+
+**Purpose**: Create new WordPress plugin from scratch
+
+**Steps**:
+1. Define plugin requirements (OpenSpec)
+2. Create Beads tasks for implementation
+3. Generate plugin structure
+4. Add plugin header and metadata
+5. Create initial files (main plugin file, readme.txt)
+6. Set up version control
+
+**AI Prompt Template**:
+```
+Create a WordPress plugin called [Plugin Name] that [description].
+
+Requirements:
+- Plugin slug: [slug]
+- Text domain: [text-domain]
+- Minimum WordPress version: 6.0
+- PHP version: 7.4+
+
+Features:
+- [Feature 1]
+- [Feature 2]
+
+Use [architecture pattern] architecture.
+```
+
+### 2. Development Workflow
+
+**Purpose**: Add features to existing plugin
+
+**Steps**:
+1. Create OpenSpec spec for feature
+2. Break down into Beads tasks
+3. Implement feature with security checks
+4. Add tests
+5. Update documentation
+6. Test in WordPress environment
+
+**AI Prompt Template**:
+```
+Add [feature name] to the [plugin name] plugin.
+
+Feature requirements:
+- [Requirement 1]
+- [Requirement 2]
+
+Security requirements:
+- Nonce verification
+- Capability checks
+- Input sanitization
+- Output escaping
+
+Follow the [architecture pattern] pattern used in the plugin.
+```
+
+### 3. Testing Workflow
+
+**Purpose**: Set up and run plugin tests
+
+**Steps**:
+1. Install WordPress test suite
+2. Configure PHPUnit
+3. Write unit tests
+4. Write integration tests
+5. Run tests locally
+6. Set up CI/CD (optional)
+
+**AI Prompt Template**:
+```
+Set up PHPUnit testing for [plugin name].
+
+Test coverage needed:
+- [Feature 1] unit tests
+- [Feature 2] integration tests
+- Security validation tests
+
+Use WordPress test suite and mock WordPress functions.
+```
+
+### 4. Submission Workflow
+
+**Purpose**: Prepare plugin for WordPress.org submission
+
+**Steps**:
+1. Security audit
+2. Code standards check (WPCS)
+3. Create/update readme.txt
+4. Add screenshots
+5. Test in clean WordPress install
+6. Submit to WordPress.org
+7. Respond to review feedback
+
+**AI Prompt Template**:
+```
+Prepare [plugin name] for WordPress.org submission.
+
+Checklist:
+- Security audit (nonces, sanitization, escaping)
+- WPCS compliance
+- readme.txt with proper format
+- Screenshots (if applicable)
+- Tested up to WordPress [version]
+
+Generate submission-ready package.
+```
+
+## Beads Task Breakdown Patterns
+
+### Plugin Creation Tasks
+
+```bash
+bd create "Create plugin structure" -p 1
+bd create "Add plugin header and metadata" -p 1
+bd create "Create main plugin file" -p 1
+bd create "Create readme.txt" -p 1
+bd create "Set up activation/deactivation hooks" -p 1
+```
+
+### Feature Addition Tasks
+
+```bash
+bd create "Create OpenSpec spec for [feature]" -p 1
+bd create "Implement [feature] core logic" -p 1
+bd create "Add security checks (nonces, caps)" -p 1
+bd create "Add tests for [feature]" -p 1
+bd create "Update documentation" -p 2
+```
+
+## Usage
+
+### For AI Agents
+
+When working on WordPress plugin development:
+
+1. **Start with scaffolding workflow** for new plugins
+2. **Use development workflow** for adding features
+3. **Apply testing workflow** before releases
+4. **Follow submission workflow** for WordPress.org
+
+### Integration with OpenSpec
+
+Create specs in `openspec/specs/plugin-features/[feature-name].md` with:
+- Feature requirements
+- Security requirements
+- Performance considerations
+- Testing requirements
+
+### Integration with Beads
+
+Track all plugin development tasks in Beads with labels:
+- `wordpress`
+- `plugin`
+- `[feature-name]`
+- `security` (for security-related tasks)
+- `testing` (for test tasks)
+
+## Character Count
+
+**Total**: ~81,445 characters
+
+## Contents
+
+- **4 Workflow Files**: Complete workflows for plugin development lifecycle
+  - `development-workflow.md` - Feature development cycle with security-first approach
+  - `testing-workflow.md` - PHPUnit setup, TDD workflow, and CI/CD integration
+  - `submission-workflow.md` - WordPress.org submission process and review response
+  - `best-practices.md` - Comprehensive best practices for code organization, security, performance, and accessibility
+- **Beads Integration**: Task templates and breakdown patterns
+- **OpenSpec Integration**: Spec templates for plugin features
+- **AI Prompt Templates**: Ready-to-use prompts for each workflow phase
+
+## Dependencies
+
+- `domain-rules/wordpress-plugin` - WordPress plugin development rules
+
+## Version
+
+**1.1.0** - Added development, testing, and submission workflows
+
+## License
+
+MIT
+