@mytechtoday/augment-extensions 0.1.0 → 0.1.1

package/AGENTS.md

@@ -111,7 +111,7 @@ When making architectural changes:
 3. Break down into tasks
 4. Implement and archive when complete
 
-**Learn More**: See `modules/workflows/openspec/` for comprehensive workflow documentation.
+**Learn More**: See `augment-extensions/workflows/openspec/` for comprehensive workflow documentation.
 
 ---
 
@@ -137,16 +137,96 @@ This repository uses **Beads** for task tracking and memory.
 
 When tracking work:
 1. Create tasks by appending JSON to `.beads/issues.jsonl`
-2. Use hash-based IDs: `bd-<hash>` (e.g., `bd-a1b2`)
+2. Use hash-based IDs with **"bd-" prefix**: `bd-<hash>` (e.g., `bd-a1b2`)
+   - All issue IDs MUST use "bd-" prefix (see `openspec/specs/beads/naming-convention.md`)
+   - Valid formats: `bd-<hash>`, `bd-<name>`, `bd-<hash>.<number>`
 3. Track dependencies with `blocks`/`blocked_by` fields
 4. Find ready tasks (status: "open", no blockers)
 5. Update status and add comments as work progresses
 
 **Task States**: `open`, `in-progress`, `blocked`, `closed`
 
-**Learn More**: See `modules/workflows/beads/` for comprehensive workflow documentation.
+**Naming Convention**: All issue IDs MUST use "bd-" prefix. See `openspec/specs/beads/naming-convention.md` for complete specification.
+
+**Learn More**: See `augment-extensions/workflows/beads/` for comprehensive workflow documentation.
+
+---
+
+## Coordination System
+
+This repository uses a **coordination manifest** (`.augment/coordination.json`) to harmonize OpenSpec, Beads, and `.augment/` rules.
+
+### How It Works
+
+The coordination manifest tracks relationships between:
+- **Specs** (OpenSpec) - What needs to be built
+- **Tasks** (Beads) - How it's being built
+- **Rules** (`.augment/`) - Guidelines for building
+- **Files** - What was built
+
+### For AI Agents
+
+**Before starting work**:
+1. Check `.augment/coordination.json` for active specs
+2. Find related tasks for the spec you're implementing
+3. Load applicable rules for your task
+4. Identify which files are affected
+
+**While working**:
+1. Track file creation/modification with task IDs
+2. Update coordination manifest when creating files
+3. Reference specs and rules in task comments
+
+**Query Examples**:
+
+```javascript
+// Get all active specs
+const coord = require('./.augment/coordination.json');
+const activeSpecs = Object.entries(coord.specs)
+  .filter(([id, spec]) => spec.status === 'active');
+
+// Get tasks for a spec
+const tasks = coord.specs['testing/functional-tests'].relatedTasks;
+
+// Get rules for a task
+const rules = coord.tasks['bd-xyz'].relatedRules;
+
+// Get specs governing a file
+const specsForFile = Object.entries(coord.specs)
+  .filter(([id, spec]) =>
+    spec.affectedFiles.some(pattern => filePath.match(pattern))
+  );
+```
+
+**Learn More**: See `.augment/rules/coordination-system.md` for detailed documentation.
 
 ---
 
 **Note**: This is a meta-repository for extending Augment Code AI. The actual project-specific `.augment/` folder remains in individual projects.
 
+
+## Landing the Plane (Session Completion)
+
+**When ending a work session**, you MUST complete ALL steps below. Work is NOT complete until `git push` succeeds.
+
+**MANDATORY WORKFLOW:**
+
+1. **File issues for remaining work** - Create issues for anything that needs follow-up
+2. **Run quality gates** (if code changed) - Tests, linters, builds
+3. **Update issue status** - Close finished work, update in-progress items
+4. **PUSH TO REMOTE** - This is MANDATORY:
+   ```bash
+   git pull --rebase
+   bd sync
+   git push
+   git status  # MUST show "up to date with origin"
+   ```
+5. **Clean up** - Clear stashes, prune remote branches
+6. **Verify** - All changes committed AND pushed
+7. **Hand off** - Provide context for next session
+
+**CRITICAL RULES:**
+- Work is NOT complete until `git push` succeeds
+- NEVER stop before pushing - that leaves work stranded locally
+- NEVER say "ready to push when you are" - YOU must push
+- If push fails, resolve and retry until it succeeds

package/README.md

@@ -20,14 +20,15 @@ Augment Code AI limits the `.augment/` folder to ~49,400 characters. This reposi
 
 ```bash
 # Install the CLI
-npm install -g @augment-extensions/cli
+npm install -g @mytechtoday/augment-extensions
 
 # Initialize in your project
 augx init
 
 # Link extension modules
 augx link coding-standards/typescript
-augx link domain-rules/web-development
+augx link domain-rules/api-design
+augx link domain-rules/security
 ```
 
 ### For AI Agents
@@ -41,7 +42,7 @@ Once initialized, AI agents automatically discover available extensions through:
 
 ```
 augment-extensions/
-├── modules/                    # Extension modules
+├── augment-extensions/         # Extension modules
 │   ├── coding-standards/      # Language/framework standards
 │   │   ├── typescript/
 │   │   ├── python/
@@ -68,7 +69,7 @@ augment-extensions/
 Each module is self-contained:
 
 ```
-modules/coding-standards/typescript/
+augment-extensions/coding-standards/typescript/
 ├── module.json               # Metadata (version, dependencies)
 ├── rules/                    # Rule files
 │   ├── naming-conventions.md
@@ -112,7 +113,7 @@ augx pin typescript-standards@1.2.0
 
 ## 📖 Available Modules
 
-See [MODULES.md](./MODULES.md) for a complete catalog of available extension modules.
+See [modules.md](./modules.md) for a complete catalog of available extension modules.
 
 ## 🛠 Creating Custom Modules
 

package/augment-extensions/coding-standards/python/README.md

@@ -0,0 +1,44 @@
+# Python Coding Standards
+
+Comprehensive Python coding standards and best practices for AI-assisted development.
+
+## Overview
+
+This module provides detailed guidelines for writing clean, maintainable, and Pythonic code following PEP 8 and modern Python best practices.
+
+## Key Benefits
+
+- **Type Safety**: Comprehensive type hints usage
+- **Error Handling**: Proper exception handling patterns
+- **Code Quality**: PEP 8 compliance and best practices
+- **Modern Python**: Python 3.10+ features and patterns
+
+## Installation
+
+```bash
+augx link coding-standards/python
+```
+
+## Contents
+
+### Rules
+
+- **naming-conventions.md** - PEP 8 naming standards
+- **type-hints.md** - Type hints and type checking
+- **error-handling.md** - Exception handling patterns
+- **best-practices.md** - General Python best practices
+- **code-organization.md** - Module and package structure
+
+### Examples
+
+- **type-hints-examples.md** - Type hints usage examples
+- **error-handling-examples.md** - Exception handling examples
+
+## Character Count
+
+~28,500 characters
+
+## Version
+
+1.0.0
+

package/augment-extensions/coding-standards/python/module.json

@@ -0,0 +1,26 @@
+{
+  "name": "python-standards",
+  "version": "1.0.0",
+  "displayName": "Python Coding Standards",
+  "description": "Comprehensive Python coding standards including naming conventions, type hints, and error handling",
+  "type": "coding-standards",
+  "author": "Augment Extensions",
+  "license": "MIT",
+  "augment": {
+    "characterCount": 28500,
+    "priority": "medium",
+    "category": "coding-standards"
+  },
+  "installation": {
+    "required": false,
+    "dependencies": []
+  },
+  "tags": [
+    "python",
+    "pep8",
+    "type-hints",
+    "error-handling",
+    "best-practices"
+  ]
+}
+

package/augment-extensions/coding-standards/python/rules/best-practices.md

@@ -0,0 +1,232 @@
+# Python Best Practices
+
+General Python best practices for clean, maintainable code.
+
+## Code Style
+
+Follow PEP 8 strictly. Use tools like `black`, `flake8`, and `isort`.
+
+```python
+# Good - PEP 8 compliant
+def calculate_total_price(items: List[Item], tax_rate: float = 0.1) -> float:
+    """Calculate total price including tax."""
+    subtotal = sum(item.price for item in items)
+    return subtotal * (1 + tax_rate)
+
+# Bad - Not PEP 8 compliant
+def calculateTotalPrice(items,tax_rate=0.1):
+    subtotal=sum([item.price for item in items])
+    return subtotal*(1+tax_rate)
+```
+
+## List Comprehensions
+
+Use comprehensions for simple transformations, loops for complex logic.
+
+```python
+# Good - Simple transformation
+squares = [x**2 for x in range(10)]
+even_squares = [x**2 for x in range(10) if x % 2 == 0]
+
+# Good - Dictionary comprehension
+user_ages = {user.name: user.age for user in users}
+
+# Bad - Too complex
+result = [
+    process_item(item, config)
+    for item in items
+    if item.is_valid() and item.status == 'active'
+    for config in get_configs(item)
+    if config.enabled
+]
+
+# Better - Use regular loop for complex logic
+result = []
+for item in items:
+    if item.is_valid() and item.status == 'active':
+        for config in get_configs(item):
+            if config.enabled:
+                result.append(process_item(item, config))
+```
+
+## Function Design
+
+Keep functions small, focused, and testable.
+
+```python
+# Good - Single responsibility
+def validate_email(email: str) -> bool:
+    """Validate email format."""
+    return '@' in email and '.' in email.split('@')[1]
+
+def send_email(to: str, subject: str, body: str) -> None:
+    """Send email to recipient."""
+    if not validate_email(to):
+        raise ValueError(f"Invalid email: {to}")
+    # Send email logic
+
+# Bad - Multiple responsibilities
+def send_email(to: str, subject: str, body: str) -> None:
+    # Validation
+    if '@' not in to or '.' not in to.split('@')[1]:
+        raise ValueError(f"Invalid email: {to}")
+    # Database logging
+    db.log_email(to, subject)
+    # Sending
+    smtp.send(to, subject, body)
+    # Analytics
+    analytics.track('email_sent', to)
+```
+
+## Use Dataclasses
+
+For simple data containers, use dataclasses instead of regular classes.
+
+```python
+from dataclasses import dataclass, field
+from typing import List
+
+# Good - Dataclass
+@dataclass
+class User:
+    name: str
+    email: str
+    age: int
+    tags: List[str] = field(default_factory=list)
+    
+    def is_adult(self) -> bool:
+        return self.age >= 18
+
+# Bad - Manual implementation
+class User:
+    def __init__(self, name, email, age, tags=None):
+        self.name = name
+        self.email = email
+        self.age = age
+        self.tags = tags if tags is not None else []
+    
+    def __repr__(self):
+        return f"User(name={self.name}, email={self.email}, age={self.age})"
+```
+
+## Use Enums
+
+For fixed sets of values, use Enums.
+
+```python
+from enum import Enum, auto
+
+# Good - Enum
+class Status(Enum):
+    PENDING = auto()
+    APPROVED = auto()
+    REJECTED = auto()
+
+def process_request(status: Status) -> None:
+    if status == Status.APPROVED:
+        approve()
+    elif status == Status.REJECTED:
+        reject()
+
+# Bad - String constants
+STATUS_PENDING = "pending"
+STATUS_APPROVED = "approved"
+STATUS_REJECTED = "rejected"
+```
+
+## Use Pathlib
+
+For file paths, use `pathlib` instead of string manipulation.
+
+```python
+from pathlib import Path
+
+# Good - Pathlib
+config_dir = Path.home() / '.config' / 'myapp'
+config_file = config_dir / 'config.json'
+
+if config_file.exists():
+    data = config_file.read_text()
+
+# Bad - String manipulation
+import os
+config_dir = os.path.join(os.path.expanduser('~'), '.config', 'myapp')
+config_file = os.path.join(config_dir, 'config.json')
+
+if os.path.exists(config_file):
+    with open(config_file) as f:
+        data = f.read()
+```
+
+## Use F-Strings
+
+For string formatting, use f-strings (Python 3.6+).
+
+```python
+# Good - F-strings
+name = "Alice"
+age = 30
+message = f"Hello, {name}! You are {age} years old."
+formatted = f"Price: ${price:.2f}"
+
+# Bad - Old-style formatting
+message = "Hello, %s! You are %d years old." % (name, age)
+message = "Hello, {}! You are {} years old.".format(name, age)
+```
+
+## Use Generators
+
+For large datasets, use generators to save memory.
+
+```python
+# Good - Generator
+def read_large_file(file_path: Path):
+    with file_path.open() as f:
+        for line in f:
+            yield line.strip()
+
+# Usage
+for line in read_large_file(Path('large_file.txt')):
+    process(line)
+
+# Bad - Load everything into memory
+def read_large_file(file_path: Path):
+    with file_path.open() as f:
+        return [line.strip() for line in f]
+```
+
+## Use Default Dict and Counter
+
+```python
+from collections import defaultdict, Counter
+
+# Good - defaultdict
+word_count = defaultdict(int)
+for word in words:
+    word_count[word] += 1
+
+# Good - Counter (even better)
+word_count = Counter(words)
+
+# Bad - Manual checking
+word_count = {}
+for word in words:
+    if word in word_count:
+        word_count[word] += 1
+    else:
+        word_count[word] = 1
+```
+
+## Best Practices Summary
+
+1. **Follow PEP 8** - Use automated formatters
+2. **Use type hints** - Everywhere
+3. **Keep functions small** - Single responsibility
+4. **Use dataclasses** - For data containers
+5. **Use Enums** - For fixed sets of values
+6. **Use pathlib** - For file paths
+7. **Use f-strings** - For string formatting
+8. **Use generators** - For large datasets
+9. **Use comprehensions** - For simple transformations
+10. **Write tests** - Always
+

package/augment-extensions/coding-standards/python/rules/code-organization.md

@@ -0,0 +1,220 @@
+# Python Code Organization
+
+Best practices for organizing Python modules, packages, and projects.
+
+## Module Structure
+
+```python
+"""Module docstring describing the module's purpose.
+
+This module provides utilities for user authentication.
+"""
+
+# Standard library imports
+import os
+import sys
+from pathlib import Path
+from typing import List, Dict, Optional
+
+# Third-party imports
+import requests
+from flask import Flask, request
+
+# Local imports
+from .models import User
+from .utils import validate_email
+from ..config import settings
+
+# Constants
+MAX_LOGIN_ATTEMPTS = 3
+DEFAULT_TIMEOUT = 30
+
+# Module-level variables
+_cache: Dict[str, User] = {}
+
+# Classes
+class AuthenticationManager:
+    """Manages user authentication."""
+    pass
+
+# Functions
+def authenticate_user(username: str, password: str) -> Optional[User]:
+    """Authenticate user with username and password."""
+    pass
+
+# Main execution
+if __name__ == "__main__":
+    main()
+```
+
+## Package Structure
+
+```
+myproject/
+├── README.md
+├── pyproject.toml
+├── setup.py
+├── requirements.txt
+├── .gitignore
+├── tests/
+│   ├── __init__.py
+│   ├── test_auth.py
+│   └── test_users.py
+└── myproject/
+    ├── __init__.py
+    ├── __main__.py
+    ├── config.py
+    ├── models/
+    │   ├── __init__.py
+    │   ├── user.py
+    │   └── product.py
+    ├── services/
+    │   ├── __init__.py
+    │   ├── auth.py
+    │   └── email.py
+    └── utils/
+        ├── __init__.py
+        ├── validation.py
+        └── formatting.py
+```
+
+## Import Organization
+
+```python
+# 1. Standard library imports (alphabetical)
+import json
+import os
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import List, Dict, Optional
+
+# 2. Third-party imports (alphabetical)
+import numpy as np
+import pandas as pd
+import requests
+from flask import Flask, request, jsonify
+
+# 3. Local application imports (alphabetical)
+from .config import settings
+from .models import User, Product
+from .services import AuthService, EmailService
+from .utils import validate_email, format_date
+```
+
+## __init__.py Files
+
+```python
+# myproject/__init__.py
+"""MyProject - A Python application."""
+
+__version__ = "1.0.0"
+__author__ = "Your Name"
+
+# Public API
+from .models import User, Product
+from .services import AuthService, EmailService
+
+__all__ = [
+    "User",
+    "Product",
+    "AuthService",
+    "EmailService",
+]
+```
+
+## Configuration Management
+
+```python
+# config.py
+from pathlib import Path
+from typing import Optional
+from pydantic import BaseSettings
+
+class Settings(BaseSettings):
+    """Application settings."""
+    
+    # App settings
+    app_name: str = "MyApp"
+    debug: bool = False
+    
+    # Database settings
+    database_url: str
+    database_pool_size: int = 10
+    
+    # API settings
+    api_key: Optional[str] = None
+    api_timeout: int = 30
+    
+    class Config:
+        env_file = ".env"
+        env_file_encoding = "utf-8"
+
+# Global settings instance
+settings = Settings()
+```
+
+## Dependency Injection
+
+```python
+# Good - Dependency injection
+class UserService:
+    def __init__(self, db_connection, email_service):
+        self.db = db_connection
+        self.email = email_service
+    
+    def create_user(self, user_data):
+        user = self.db.create(user_data)
+        self.email.send_welcome(user.email)
+        return user
+
+# Usage
+db = DatabaseConnection(settings.database_url)
+email = EmailService(settings.smtp_config)
+user_service = UserService(db, email)
+
+# Bad - Hard-coded dependencies
+class UserService:
+    def __init__(self):
+        self.db = DatabaseConnection("postgresql://...")
+        self.email = EmailService(smtp_config)
+```
+
+## Layered Architecture
+
+```
+myproject/
+├── api/              # API layer (Flask/FastAPI routes)
+│   ├── __init__.py
+│   ├── users.py
+│   └── products.py
+├── services/         # Business logic layer
+│   ├── __init__.py
+│   ├── user_service.py
+│   └── product_service.py
+├── repositories/     # Data access layer
+│   ├── __init__.py
+│   ├── user_repository.py
+│   └── product_repository.py
+├── models/           # Domain models
+│   ├── __init__.py
+│   ├── user.py
+│   └── product.py
+└── utils/            # Utilities
+    ├── __init__.py
+    └── validators.py
+```
+
+## Best Practices
+
+1. **One class per file** - For large classes
+2. **Group related functions** - In modules
+3. **Use __all__** - To define public API
+4. **Avoid circular imports** - Restructure if needed
+5. **Use absolute imports** - For clarity
+6. **Keep modules focused** - Single responsibility
+7. **Use packages** - For large projects
+8. **Document structure** - In README.md
+9. **Follow conventions** - tests/, docs/, src/
+10. **Use pyproject.toml** - For modern projects
+