@mytechtoday/augment-extensions 1.4.0 → 1.5.0

package/augment-extensions/coding-standards/go/templates/prompts/web.md

@@ -0,0 +1,181 @@
+# Web Service Project Template
+
+## Context
+
+You are generating Go code for a **web service** project. This includes HTTP servers, RESTful APIs, web applications, and API gateways.
+
+## Standards
+
+Follow these Go coding standards for web services:
+
+### Universal Rules
+
+1. **Naming Conventions**: Use MixedCaps for exported names, mixedCaps for unexported
+2. **Error Handling**: Return errors explicitly, use `errors.Is/As` for error inspection
+3. **Concurrency**: Use goroutines and channels properly, always pass context
+4. **Testing**: Write table-driven tests, use `httptest` for HTTP testing
+5. **Code Organization**: Keep packages flat and focused
+6. **Documentation**: Add godoc comments for all exported functions
+7. **Performance**: Minimize allocations, use `sync.Pool` for reusable objects
+
+### Web Services Rules
+
+#### HTTP Handlers
+- Use standard `http.Handler` and `http.HandlerFunc` interfaces
+- Always use `context.Context` from `r.Context()` for request-scoped values
+- Return appropriate HTTP status codes (2xx, 4xx, 5xx)
+- Validate all inputs before processing
+- Use `http.Error` for error responses
+
+#### Middleware
+- Implement middleware using `func(http.Handler) http.Handler` pattern
+- Chain middleware for logging, authentication, metrics, recovery
+- Use context to pass values between middleware layers
+- Always include panic recovery middleware
+- Instrument with Prometheus metrics
+
+#### Routing
+- Use established routing libraries (`chi`, `gorilla/mux`, `echo`)
+- Follow RESTful resource naming (plural nouns, standard HTTP methods)
+- Extract and validate URL parameters safely
+- Implement API versioning (e.g., `/api/v1`, `/api/v2`)
+- Use query parameters for filtering, sorting, pagination
+
+#### Graceful Shutdown
+- Implement signal-based shutdown (SIGINT, SIGTERM)
+- Set appropriate shutdown timeout (typically 30 seconds)
+- Clean up resources (database connections, file handles)
+- Update health checks to mark service as unhealthy during shutdown
+
+## Key Requirements
+
+### HTTP Server Setup
+```go
+srv := &http.Server{
+    Addr:         ":8080",
+    Handler:      routes(),
+    ReadTimeout:  15 * time.Second,
+    WriteTimeout: 15 * time.Second,
+    IdleTimeout:  60 * time.Second,
+}
+```
+
+### Handler Pattern
+```go
+func handleResource(w http.ResponseWriter, r *http.Request) {
+    ctx := r.Context()
+    
+    // Extract parameters
+    id := chi.URLParam(r, "id")
+    
+    // Validate input
+    if id == "" {
+        http.Error(w, "Missing ID", http.StatusBadRequest)
+        return
+    }
+    
+    // Process request
+    result, err := processRequest(ctx, id)
+    if err != nil {
+        http.Error(w, err.Error(), http.StatusInternalServerError)
+        return
+    }
+    
+    // Return response
+    w.Header().Set("Content-Type", "application/json")
+    json.NewEncoder(w).Encode(result)
+}
+```
+
+### Middleware Pattern
+```go
+func loggingMiddleware(next http.Handler) http.Handler {
+    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+        start := time.Now()
+        next.ServeHTTP(w, r)
+        log.Printf("%s %s %v", r.Method, r.URL.Path, time.Since(start))
+    })
+}
+```
+
+### Graceful Shutdown
+```go
+func main() {
+    srv := &http.Server{Addr: ":8080", Handler: routes()}
+    
+    go func() {
+        if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+            log.Fatal(err)
+        }
+    }()
+    
+    quit := make(chan os.Signal, 1)
+    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+    <-quit
+    
+    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+    defer cancel()
+    
+    if err := srv.Shutdown(ctx); err != nil {
+        log.Fatal(err)
+    }
+}
+```
+
+## Common Patterns
+
+### RESTful API Structure
+```
+GET    /api/v1/users          - List users
+POST   /api/v1/users          - Create user
+GET    /api/v1/users/{id}     - Get user
+PUT    /api/v1/users/{id}     - Update user
+DELETE /api/v1/users/{id}     - Delete user
+```
+
+### Error Response Format
+```go
+type ErrorResponse struct {
+    Error   string `json:"error"`
+    Message string `json:"message"`
+    Code    int    `json:"code"`
+}
+```
+
+### Pagination Response
+```go
+type PaginatedResponse struct {
+    Data  interface{} `json:"data"`
+    Total int         `json:"total"`
+    Page  int         `json:"page"`
+    Limit int         `json:"limit"`
+}
+```
+
+## Tools
+
+Ensure generated code passes:
+- `go build` - Compiles without errors
+- `golangci-lint run` - Passes all linters
+- `go vet` - No suspicious constructs
+- `gofmt -d .` - Properly formatted
+- `go test -race` - No race conditions
+
+## Output Format
+
+Generate complete, production-ready Go code with:
+- Package declaration and imports
+- Struct definitions with JSON tags
+- HTTP handlers with proper error handling
+- Middleware for cross-cutting concerns
+- Graceful shutdown implementation
+- Comprehensive godoc comments
+- Example usage in comments
+
+## References
+
+- [Effective Go](https://golang.org/doc/effective_go)
+- [Go net/http package](https://pkg.go.dev/net/http)
+- [chi router](https://github.com/go-chi/chi)
+- [Uber Go Style Guide](https://github.com/uber-go/guide)
+

package/augment-extensions/coding-standards/go/tests/integration/module-integration.test.ts

@@ -0,0 +1,164 @@
+/**
+ * Integration Tests: Go Module Integration
+ * 
+ * Tests for end-to-end module integration with Augment Extensions.
+ * Covers GOL.4.2 - Integration Tests
+ */
+
+import { describe, it, expect } from 'vitest';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+const MODULE_ROOT = join(__dirname, '../..');
+const AUGMENT_ROOT = join(__dirname, '../../../..');
+
+describe('Module Integration', () => {
+  describe('Single Category Selection', () => {
+    it('should load web category successfully', () => {
+      const webRulesPath = join(MODULE_ROOT, 'rules/web');
+      const universalRulesPath = join(MODULE_ROOT, 'rules/universal');
+      
+      expect(existsSync(webRulesPath)).toBe(true);
+      expect(existsSync(universalRulesPath)).toBe(true);
+    });
+
+    it('should load microservices category successfully', () => {
+      const microRulesPath = join(MODULE_ROOT, 'rules/microservices');
+      const universalRulesPath = join(MODULE_ROOT, 'rules/universal');
+      
+      expect(existsSync(microRulesPath)).toBe(true);
+      expect(existsSync(universalRulesPath)).toBe(true);
+    });
+
+    it('should load cli category successfully', () => {
+      const cliRulesPath = join(MODULE_ROOT, 'rules/cli');
+      const universalRulesPath = join(MODULE_ROOT, 'rules/universal');
+      
+      expect(existsSync(cliRulesPath)).toBe(true);
+      expect(existsSync(universalRulesPath)).toBe(true);
+    });
+  });
+
+  describe('Multiple Category Combinations', () => {
+    it('should support web + api combination', () => {
+      const webPath = join(MODULE_ROOT, 'rules/web');
+      const apiPath = join(MODULE_ROOT, 'rules/api');
+      
+      expect(existsSync(webPath)).toBe(true);
+      expect(existsSync(apiPath)).toBe(true);
+    });
+
+    it('should support microservices + distributed combination', () => {
+      const microPath = join(MODULE_ROOT, 'rules/microservices');
+      const distPath = join(MODULE_ROOT, 'rules/distributed');
+      
+      expect(existsSync(microPath)).toBe(true);
+      expect(existsSync(distPath)).toBe(true);
+    });
+
+    it('should support cli + devops combination', () => {
+      const cliPath = join(MODULE_ROOT, 'rules/cli');
+      const devopsPath = join(MODULE_ROOT, 'rules/devops');
+      
+      expect(existsSync(cliPath)).toBe(true);
+      expect(existsSync(devopsPath)).toBe(true);
+    });
+  });
+
+  describe('Rule Application Workflow', () => {
+    it('should have accessible universal rules', () => {
+      const universalPath = join(MODULE_ROOT, 'rules/universal');
+      const namingPath = join(universalPath, 'naming-conventions.md');
+      const errorPath = join(universalPath, 'error-handling.md');
+      
+      expect(existsSync(namingPath)).toBe(true);
+      expect(existsSync(errorPath)).toBe(true);
+      
+      const namingContent = readFileSync(namingPath, 'utf-8');
+      expect(namingContent).toContain('MixedCaps');
+    });
+
+    it('should have accessible category rules', () => {
+      const webPath = join(MODULE_ROOT, 'rules/web');
+      const files = require('fs').readdirSync(webPath);
+      
+      expect(files.length).toBeGreaterThan(0);
+      files.forEach((file: string) => {
+        const filePath = join(webPath, file);
+        const content = readFileSync(filePath, 'utf-8');
+        expect(content.length).toBeGreaterThan(0);
+      });
+    });
+  });
+
+  describe('AI Prompt Generation', () => {
+    it('should have web-service template for AI', () => {
+      const templatePath = join(MODULE_ROOT, 'templates/web-service.md');
+      expect(existsSync(templatePath)).toBe(true);
+      
+      const content = readFileSync(templatePath, 'utf-8');
+      expect(content).toContain('## Context');
+      expect(content).toContain('## Standards');
+      expect(content).toContain('## Examples');
+    });
+
+    it('should have microservice template for AI', () => {
+      const templatePath = join(MODULE_ROOT, 'templates/microservice.md');
+      expect(existsSync(templatePath)).toBe(true);
+      
+      const content = readFileSync(templatePath, 'utf-8');
+      expect(content).toContain('gRPC');
+      expect(content).toContain('service discovery');
+    });
+
+    it('should have cli-tool template for AI', () => {
+      const templatePath = join(MODULE_ROOT, 'templates/cli-tool.md');
+      expect(existsSync(templatePath)).toBe(true);
+      
+      const content = readFileSync(templatePath, 'utf-8');
+      expect(content).toContain('Cobra');
+      expect(content).toContain('command-line');
+    });
+
+    it('should reference universal rules in templates', () => {
+      const templatePath = join(MODULE_ROOT, 'templates/web-service.md');
+      const content = readFileSync(templatePath, 'utf-8');
+      
+      expect(content).toContain('Naming Conventions');
+      expect(content).toContain('Error Handling');
+      expect(content).toContain('Testing');
+    });
+  });
+
+  describe('Module Catalog Integration', () => {
+    it('should be listed in augment-extensions', () => {
+      const modulePath = join(MODULE_ROOT, 'module.json');
+      expect(existsSync(modulePath)).toBe(true);
+    });
+
+    it('should have proper module type', () => {
+      const modulePath = join(MODULE_ROOT, 'module.json');
+      const module = JSON.parse(readFileSync(modulePath, 'utf-8'));
+      
+      expect(module.type).toBe('coding-standards');
+      expect(module.language).toBe('go');
+    });
+  });
+
+  describe('Configuration Integration', () => {
+    it('should have valid configuration schema', () => {
+      const schemaPath = join(MODULE_ROOT, 'config/schema.json');
+      const schema = JSON.parse(readFileSync(schemaPath, 'utf-8'));
+      
+      expect(schema.type).toBe('object');
+      expect(schema.properties).toBeDefined();
+      expect(schema.properties.categories).toBeDefined();
+    });
+
+    it('should have example configurations', () => {
+      const examplesPath = join(MODULE_ROOT, 'config/examples');
+      expect(existsSync(examplesPath)).toBe(true);
+    });
+  });
+});
+

package/augment-extensions/coding-standards/go/tests/unit/category-selection.test.ts

@@ -0,0 +1,147 @@
+/**
+ * Unit Tests: Category Selection
+ * 
+ * Tests for category selection mechanism and rule loading.
+ * Covers GOL.4.1.2 - Category Selection Tests
+ */
+
+import { describe, it, expect } from 'vitest';
+import { existsSync, readdirSync } from 'fs';
+import { join } from 'path';
+
+const MODULE_ROOT = join(__dirname, '../..');
+
+describe('Category Selection', () => {
+  const categories = [
+    'web',
+    'microservices',
+    'cli',
+    'cloud',
+    'distributed',
+    'devops',
+    'api'
+  ];
+
+  describe('Category Directories', () => {
+    categories.forEach(category => {
+      it(`should have ${category} rules directory`, () => {
+        const categoryPath = join(MODULE_ROOT, 'rules', category);
+        expect(existsSync(categoryPath)).toBe(true);
+      });
+    });
+  });
+
+  describe('Category Rules', () => {
+    it('should have web category rules', () => {
+      const webPath = join(MODULE_ROOT, 'rules/web');
+      const files = readdirSync(webPath);
+      expect(files.length).toBeGreaterThan(0);
+      expect(files.some(f => f.endsWith('.md'))).toBe(true);
+    });
+
+    it('should have microservices category rules', () => {
+      const microPath = join(MODULE_ROOT, 'rules/microservices');
+      const files = readdirSync(microPath);
+      expect(files.length).toBeGreaterThan(0);
+      expect(files.some(f => f.endsWith('.md'))).toBe(true);
+    });
+
+    it('should have cli category rules', () => {
+      const cliPath = join(MODULE_ROOT, 'rules/cli');
+      const files = readdirSync(cliPath);
+      expect(files.length).toBeGreaterThan(0);
+      expect(files.some(f => f.endsWith('.md'))).toBe(true);
+    });
+  });
+
+  describe('Category Examples', () => {
+    it('should have web examples', () => {
+      const webExamplePath = join(MODULE_ROOT, 'examples/web');
+      expect(existsSync(webExamplePath)).toBe(true);
+    });
+
+    it('should have microservices examples', () => {
+      const microExamplePath = join(MODULE_ROOT, 'examples/microservices');
+      expect(existsSync(microExamplePath)).toBe(true);
+    });
+
+    it('should have cli examples', () => {
+      const cliExamplePath = join(MODULE_ROOT, 'examples/cli');
+      expect(existsSync(cliExamplePath)).toBe(true);
+    });
+  });
+
+  describe('Category Templates', () => {
+    it('should have web-service template', () => {
+      const templatePath = join(MODULE_ROOT, 'templates/web-service.md');
+      expect(existsSync(templatePath)).toBe(true);
+    });
+
+    it('should have microservice template', () => {
+      const templatePath = join(MODULE_ROOT, 'templates/microservice.md');
+      expect(existsSync(templatePath)).toBe(true);
+    });
+
+    it('should have cli-tool template', () => {
+      const templatePath = join(MODULE_ROOT, 'templates/cli-tool.md');
+      expect(existsSync(templatePath)).toBe(true);
+    });
+  });
+
+  describe('Category Metadata', () => {
+    it('should have category descriptions in module.json', () => {
+      const modulePath = join(MODULE_ROOT, 'module.json');
+      const content = require(modulePath);
+
+      categories.forEach(category => {
+        expect(content.categories).toContain(category);
+      });
+    });
+  });
+
+  describe('Rule Loading', () => {
+    it('should load universal rules for all categories', () => {
+      const universalPath = join(MODULE_ROOT, 'rules/universal');
+      const files = readdirSync(universalPath);
+      
+      const expectedRules = [
+        'naming-conventions.md',
+        'error-handling.md',
+        'concurrency.md',
+        'testing.md',
+        'code-organization.md',
+        'documentation.md',
+        'performance.md'
+      ];
+
+      expectedRules.forEach(rule => {
+        expect(files).toContain(rule);
+      });
+    });
+
+    it('should have category-specific rules separate from universal', () => {
+      const webPath = join(MODULE_ROOT, 'rules/web');
+      const webFiles = readdirSync(webPath);
+      
+      const universalPath = join(MODULE_ROOT, 'rules/universal');
+      const universalFiles = readdirSync(universalPath);
+
+      // Web rules should not duplicate universal rules
+      const overlap = webFiles.filter(f => universalFiles.includes(f));
+      expect(overlap.length).toBe(0);
+    });
+  });
+
+  describe('Multi-Category Support', () => {
+    it('should support selecting multiple categories', () => {
+      // Test that multiple category directories can coexist
+      const selectedCategories = ['web', 'microservices', 'api'];
+      
+      selectedCategories.forEach(category => {
+        const categoryPath = join(MODULE_ROOT, 'rules', category);
+        expect(existsSync(categoryPath)).toBe(true);
+      });
+    });
+  });
+});
+

package/augment-extensions/coding-standards/go/tests/unit/module-structure.test.ts

@@ -0,0 +1,154 @@
+/**
+ * Unit Tests: Go Module Structure
+ * 
+ * Tests for module structure validation, file existence, and metadata correctness.
+ * Covers GOL.4.1.1 - Configuration Loading Tests
+ */
+
+import { describe, it, expect } from 'vitest';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+const MODULE_ROOT = join(__dirname, '../..');
+
+describe('Go Module Structure', () => {
+  describe('Required Files', () => {
+    it('should have module.json', () => {
+      const modulePath = join(MODULE_ROOT, 'module.json');
+      expect(existsSync(modulePath)).toBe(true);
+    });
+
+    it('should have README.md', () => {
+      const readmePath = join(MODULE_ROOT, 'README.md');
+      expect(existsSync(readmePath)).toBe(true);
+    });
+
+    it('should have config/schema.json', () => {
+      const schemaPath = join(MODULE_ROOT, 'config/schema.json');
+      expect(existsSync(schemaPath)).toBe(true);
+    });
+  });
+
+  describe('Module Metadata', () => {
+    it('should have valid module.json structure', () => {
+      const modulePath = join(MODULE_ROOT, 'module.json');
+      const content = readFileSync(modulePath, 'utf-8');
+      const module = JSON.parse(content);
+
+      expect(module.name).toBe('go-coding-standards');
+      expect(module.version).toBe('1.0.0');
+      expect(module.description).toBeTruthy();
+      expect(module.type).toBe('coding-standards');
+      expect(module.language).toBe('go');
+    });
+
+    it('should have all required categories', () => {
+      const modulePath = join(MODULE_ROOT, 'module.json');
+      const content = readFileSync(modulePath, 'utf-8');
+      const module = JSON.parse(content);
+
+      const expectedCategories = [
+        'web',
+        'microservices',
+        'cli',
+        'cloud',
+        'distributed',
+        'devops',
+        'api'
+      ];
+
+      expect(module.categories).toBeDefined();
+      expectedCategories.forEach(cat => {
+        expect(module.categories).toContain(cat);
+      });
+    });
+
+    it('should have configuration schema reference', () => {
+      const modulePath = join(MODULE_ROOT, 'module.json');
+      const content = readFileSync(modulePath, 'utf-8');
+      const module = JSON.parse(content);
+
+      expect(module.configSchema).toBe('./config/schema.json');
+    });
+  });
+
+  describe('Directory Structure', () => {
+    it('should have rules directory', () => {
+      const rulesPath = join(MODULE_ROOT, 'rules');
+      expect(existsSync(rulesPath)).toBe(true);
+    });
+
+    it('should have examples directory', () => {
+      const examplesPath = join(MODULE_ROOT, 'examples');
+      expect(existsSync(examplesPath)).toBe(true);
+    });
+
+    it('should have templates directory', () => {
+      const templatesPath = join(MODULE_ROOT, 'templates');
+      expect(existsSync(templatesPath)).toBe(true);
+    });
+
+    it('should have config directory', () => {
+      const configPath = join(MODULE_ROOT, 'config');
+      expect(existsSync(configPath)).toBe(true);
+    });
+
+    it('should have universal rules directory', () => {
+      const universalPath = join(MODULE_ROOT, 'rules/universal');
+      expect(existsSync(universalPath)).toBe(true);
+    });
+  });
+
+  describe('Universal Rules', () => {
+    const universalRules = [
+      'naming-conventions.md',
+      'error-handling.md',
+      'concurrency.md',
+      'testing.md',
+      'code-organization.md',
+      'documentation.md',
+      'performance.md'
+    ];
+
+    universalRules.forEach(rule => {
+      it(`should have ${rule}`, () => {
+        const rulePath = join(MODULE_ROOT, 'rules/universal', rule);
+        expect(existsSync(rulePath)).toBe(true);
+      });
+    });
+  });
+
+  describe('Configuration Schema', () => {
+    it('should have valid JSON schema', () => {
+      const schemaPath = join(MODULE_ROOT, 'config/schema.json');
+      const content = readFileSync(schemaPath, 'utf-8');
+      const schema = JSON.parse(content);
+
+      expect(schema.$schema).toBeTruthy();
+      expect(schema.type).toBe('object');
+      expect(schema.properties).toBeDefined();
+    });
+
+    it('should define categories property', () => {
+      const schemaPath = join(MODULE_ROOT, 'config/schema.json');
+      const content = readFileSync(schemaPath, 'utf-8');
+      const schema = JSON.parse(content);
+
+      expect(schema.properties.categories).toBeDefined();
+      expect(schema.properties.categories.type).toBe('array');
+    });
+  });
+
+  describe('README Content', () => {
+    it('should have comprehensive README', () => {
+      const readmePath = join(MODULE_ROOT, 'README.md');
+      const content = readFileSync(readmePath, 'utf-8');
+
+      expect(content.length).toBeGreaterThan(500);
+      expect(content).toContain('# Go Coding Standards');
+      expect(content).toContain('## Overview');
+      expect(content).toContain('## Categories');
+    });
+  });
+});
+

package/augment-extensions/coding-standards/go/tests/validate-character-count.ps1

@@ -0,0 +1,13 @@
+# Validate Character Count
+$MODULE_ROOT = Split-Path -Parent $PSScriptRoot
+$totalChars = 0
+Get-ChildItem -Path $MODULE_ROOT -Recurse -Include *.md,*.go,*.json -File | ForEach-Object {
+    $content = Get-Content $_.FullName -Raw -ErrorAction SilentlyContinue
+    if ($content) { $totalChars += $content.Length }
+}
+Write-Host "Total Characters: $totalChars"
+if ($totalChars -ge 20000 -and $totalChars -le 30000) {
+    Write-Host "PASS: Within target range (20,000-30,000)" -ForegroundColor Green
+} else {
+    Write-Host "WARNING: Outside target range" -ForegroundColor Yellow
+}