ma-agents 2.19.2 → 2.20.0

package/.github/copilot/skills/MANIFEST.yaml

@@ -0,0 +1,204 @@
+# MANIFEST.yaml
+
+skills:
+  - id: ai-audit-trail
+    file: ai-audit-trail/SKILL.md
+    description: Tracks AI agent session activity, time spent, and token usage in a project-level AiAudit.md log file.
+    applies_when:
+      - starting a new agent task or workflow
+      - completing a document generation session
+      - finishing any multi-step agent workflow
+    always_load: true
+
+  - id: cmake-best-practices
+    file: cmake-best-practices/SKILL.md
+    description: Enforce target-based, property-oriented CMake patterns (CMake 3.0+).
+    applies_when:
+      - creating or modifying CMakeLists.txt files
+      - managing C++ project dependencies via CMake
+      - defining C++ build configurations
+    always_load: true
+
+  - id: code-documentation
+    file: code-documentation/SKILL.md
+    description: Standardize file headers and method documentation across C++, C#, JS, TS, and Python.
+    applies_when:
+      - creating or modifying source code files
+      - defining new functions, methods, or classes
+      - refactoring code logic
+      - documenting APIs
+    always_load: true
+
+  - id: code-review
+    file: code-review/SKILL.md
+    description: Performs comprehensive code reviews with best practices
+
+  - id: commit-message
+    file: commit-message/SKILL.md
+    description: Generates conventional commit messages from code changes
+
+  - id: cpp-concurrency-safety
+    file: cpp-concurrency-safety/SKILL.md
+    description: Enforce safe multi-threading patterns using RAII locking and task-based parallelism (C++14+).
+    applies_when:
+      - working with C++ threads
+      - using C++ mutexes or locking primitives
+      - performing C++ asynchronous operations
+      - designing multi-threaded C++ systems
+
+  - id: cpp-const-correctness
+    file: cpp-const-correctness/SKILL.md
+    description: Enforce immutability-by-default and push logic to compile-time using constexpr (C++14+).
+    applies_when:
+      - declaring C++ variables
+      - defining C++ member functions
+      - performing C++ compile-time calculations
+      - optimizing C++ logic
+
+  - id: cpp-memory-handling
+    file: cpp-memory-handling/SKILL.md
+    description: Enforces Modern C++ practices (RAII, Smart Pointers) to prevent memory leaks, dangling pointers, and buffer overflows.
+    applies_when:
+      - writing c++ code
+      - modifying memory-intensive C++ logic
+      - debugging memory leaks in c++
+      - implementing new c++ classes
+
+  - id: cpp-modern-composition
+    file: cpp-modern-composition/SKILL.md
+    description: Replace legacy C patterns with STL, Ranges, and modern C++ abstractions (C++14+).
+    applies_when:
+      - writing C++ logic or algorithms
+      - performing C++ refactoring
+      - handling C++ data transformations
+      - working with C++ collections
+    always_load: true
+
+  - id: cpp-robust-interfaces
+    file: cpp-robust-interfaces/SKILL.md
+    description: Enforce contract-based design and strong typing in C++ interfaces (C++14+).
+    applies_when:
+      - creating or modifying C++ header files
+      - designing C++ function signatures
+      - defining C++ APIs or public interfaces
+
+  - id: create-hardened-docker-skill
+    file: create-hardened-docker-skill/SKILL.md
+    description: Creates production-ready hardened Docker configurations following CIS, OWASP, and NIST standards
+
+  - id: docker-hardening-verification
+    file: docker-hardening-verification/SKILL.md
+    description: Audits Docker images for security best practices, least privilege, and OpenShift compliance.
+
+  - id: docker-image-signing
+    file: docker-image-signing/SKILL.md
+    description: Automates the signing of Docker images using certificates and Cosign/Notary.
+
+  - id: document-revision-history
+    file: document-revision-history/SKILL.md
+    description: Manages a revision history table at the beginning of generated documents, tracking changes per version.
+    applies_when:
+      - generating or updating planning documents
+      - creating specification or design documents
+      - modifying existing markdown documents that have a revision history table
+
+  - id: git-workflow-skill
+    file: git-workflow-skill/SKILL.md
+    description: MANDATORY worktree-based workflow for ALL file-changing activities. Enforces isolated feature branches, conventional commits, and PR-based merging.
+    applies_when:
+      - committing changes
+      - creating branches or PRs
+      - any code writing or modification task
+    always_load: true
+
+  - id: js-ts-dependency-mgmt
+    file: js-ts-dependency-mgmt/SKILL.md
+    description: Standardize package management and security across NPM, Yarn, and PNPM.
+    applies_when:
+      - managing JavaScript or TypeScript project dependencies
+      - configuring package.json, npmrc, or lockfiles
+      - updating NPM/Yarn/PNPM packages
+      - auditing JS/TS supply chain security
+    always_load: true
+
+  - id: js-ts-security-skill
+    file: js-ts-security-skill/SKILL.md
+    description: Verify security of JavaScript and TypeScript codebases against OWASP Top 10 2025 standards
+    applies_when:
+      - writing or reviewing security-critical code
+      - analyzing third-party dependencies
+      - performing security audits
+
+  - id: logging-best-practices
+    file: logging-best-practices/SKILL.md
+    description: Standardizes structured logging across Backend, Frontend, Realtime, and Algorithmic domains with mandatory exception handling.
+    applies_when:
+      - writing new service classes
+      - reviewing or modifying existing log statements
+      - adding error handling
+
+  - id: opentelemetry-best-practices
+    file: opentelemetry-best-practices/SKILL.md
+    description: Standardizes distributed tracing, metrics, and semantic conventions for high-quality system observability.
+    applies_when:
+      - implementing api endpoints
+      - handling distributed requests
+      - optimizing performance
+      - adding monitoring
+
+  - id: python-dependency-mgmt
+    file: python-dependency-mgmt/SKILL.md
+    description: Standardize Python dependency handling using uv and pip (requirements.txt).
+    applies_when:
+      - managing Python project dependencies
+      - configuring Python build systems
+      - updating requirements.txt or uv.lock
+      - setting up Python development environments
+    always_load: true
+
+  - id: python-security-skill
+    file: python-security-skill/SKILL.md
+    description: Enforce secure Python coding standards following OWASP Top 10 2025.
+    applies_when:
+      - writing or reviewing Python code
+      - managing Python dependencies
+      - configuring Python application environments
+      - handling sensitive data in Python
+    always_load: true
+
+  - id: self-signed-cert
+    file: self-signed-cert/SKILL.md
+    description: Generates secure self-signed certificates and Root CAs using OpenSSL.
+
+  - id: skill-creator
+    file: skill-creator/SKILL.md
+    description: Guide for creating effective skills that extend Claude's capabilities with specialized knowledge, workflows, and tool integrations
+
+  - id: test-accompanied-development
+    file: test-accompanied-development/SKILL.md
+    description: Enforces writing unit tests for every new public method created by the agent.
+    applies_when:
+      - writing or reviewing public APIs
+      - adding new public methods to a class
+      - code review tasks
+
+  - id: test-generator
+    file: test-generator/SKILL.md
+    description: Generates comprehensive unit and integration tests
+    applies_when:
+      - creating new code files
+      - adding complex logic
+      - refactoring existing code
+
+  - id: vercel-react-best-practices
+    file: vercel-react-best-practices/SKILL.md
+    description: Performance optimization framework for React and Next.js projects with 57 actionable rules across 8 categories
+    applies_when:
+      - working on React or Next.js components
+      - optimizing page performance
+      - reviewing frontend code architecture
+
+  - id: verify-hardened-docker-skill
+    file: verify-hardened-docker-skill/SKILL.md
+    description: Comprehensive security verification for Docker configurations against CIS, OWASP, and NIST standards
+

package/.github/copilot/skills/ai-audit-trail/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: AI Audit Trail
+description: Tracks AI agent session activity, time spent, and token usage in a project-level AiAudit.md log file.
+---
+# AI Audit Trail
+
+At the end of every significant agent session, append an entry to `{project_root}/AiAudit.md`. If the file does not exist, create it with a `# AI Audit Trail` header first.
+
+## Entry Format
+
+```markdown
+| Date | Task | Tokens (est.) |
+|------|------|---------------|
+| YYYY-MM-DD | Brief task description | In: ~X / Out: ~Y |
+```
+
+## Rules
+
+- **Append only** — never delete or modify previous entries
+- **One row per session** — combine multiple tasks in the same session into one entry
+- **Estimate tokens** — round to nearest thousand, prefix with `~`. Write `N/A` if unknown
+- Write the entry as the **last action** before presenting results to the user
+- Skip trivial interactions (single-question answers, quick lookups)

package/.github/copilot/skills/cmake-best-practices/SKILL.md

@@ -0,0 +1,64 @@
+---
+name: Modern CMake Best Practices
+description: Enforce target-based, property-oriented CMake patterns (CMake 3.0+).
+---
+# Modern CMake Best Practices (Target-Based Approach)
+
+This skill ensures that CMake definitions follow the "Modern CMake" philosophy (3.0+), focusing on targets and properties rather than global variables.
+
+## Policies
+
+### 1. Target-Centric Philosophy
+*   **Rule**: Treat targets as objects. Use `target_*` commands instead of global commands.
+*   **Action**: 
+    - **Forbidden**: `include_directories()`, `link_libraries()`, `add_definitions()`.
+    - **Mandatory**: `target_include_directories()`, `target_link_libraries()`, `target_compile_definitions()`.
+*   **Rationale**: Encapsulates requirements and prevents property leakage to unrelated targets.
+
+### 2. Visibility Hygiene (`PUBLIC`, `PRIVATE`, `INTERFACE`)
+*   **Rule**: Always specify the scope of target properties.
+*   **Action**:
+    - `PRIVATE`: Requirement only for building the target.
+    - `INTERFACE`: Requirement only for consumers of the target.
+    - `PUBLIC`: Requirement for both.
+*   **Rationale**: Ensures that internal dependencies (like a private logging library) don't bleed into the usage requirements of your high-level API.
+
+### 3. Feature-Based C++ Standards
+*   **Rule**: Do not manually set `CMAKE_CXX_STANDARD` or `-std=c++XX` flags.
+*   **Action**: Use `target_compile_features(my_target PUBLIC cxx_std_17)`.
+*   **Rationale**: Allows CMake to handle compiler-specific flags and ensures the compiler actually supports the requested features.
+
+### 4. No Global Variable Manipulation
+*   **Rule**: Ban direct modification of `CMAKE_CXX_FLAGS` or `CMAKE_EXE_LINKER_FLAGS`.
+*   **Action**: Use `target_compile_options()` for specific compiler warnings or flags.
+*   **Rationale**: Global flags make it impossible to have different settings for different targets in the same project.
+
+### 5. Namespaced Alias Targets
+*   **Rule**: Always provide an alias for library targets using a namespace.
+*   **Action**: `add_library(MyLib::MyLib ALIAS my_lib_target)`.
+*   **Rationale**: Makes exported targets look consistent with external dependencies (like those found via `find_package`).
+
+## Examples
+
+### Before (Legacy Procedural CMake)
+```cmake
+include_directories(${PROJECT_SOURCE_DIR}/include)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17 -Wall")
+add_library(mylib mylib.cpp)
+```
+
+### After (Modern Target-Based CMake)
+```cmake
+add_library(mylib mylib.cpp)
+
+target_compile_features(mylib PUBLIC cxx_std_17)
+target_compile_options(mylib PRIVATE -Wall)
+
+target_include_directories(mylib 
+    PUBLIC 
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:include>
+)
+
+add_library(MyProject::MyLib ALIAS mylib)
+```

package/.github/copilot/skills/cmake-best-practices/examples/cmake.md

@@ -0,0 +1,59 @@
+# Modern CMake Examples
+
+### 1. Project Structure and App
+```cmake
+cmake_minimum_required(VERSION 3.14)
+project(MyAwesomeApp VERSION 1.0 LANGUAGES CXX)
+
+# Use target_compile_features for the whole project standard if needed
+# but target-specific is better.
+add_executable(app main.cpp)
+
+target_compile_features(app PRIVATE cxx_std_17)
+target_link_libraries(app PRIVATE MyProject::Core)
+```
+
+### 2. Library with Internal/External Dependencies
+```cmake
+add_library(core src/core.cpp)
+
+# Internal include dir
+target_include_directories(core 
+    PUBLIC  include
+    PRIVATE src
+)
+
+# Link against a 3rd party library found via find_package
+find_package(fmt REQUIRED)
+target_link_libraries(core 
+    PUBLIC  fmt::fmt
+    PRIVATE Threads::Threads
+)
+
+add_library(MyProject::Core ALIAS core)
+```
+
+### 3. Proper Header-Only Library
+```cmake
+add_library(utils INTERFACE)
+
+target_include_directories(utils 
+    INTERFACE 
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:include>
+)
+
+# Requirement: anyone using utils MUST have C++14
+target_compile_features(utils INTERFACE cxx_std_14)
+
+add_library(MyProject::Utils ALIAS utils)
+```
+
+### 4. Compiler-Specific Options Safely
+```cmake
+if(MSVC)
+    target_compile_options(core PRIVATE /W4 /WX)
+else()
+    target_compile_options(core PRIVATE -Wall -Wextra -Werror)
+endif()
+```

package/.github/copilot/skills/code-documentation/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: Code Documentation Best Practices
+description: Standardize file headers and method documentation across C++, C#, JS, TS, and Python.
+---
+# Code Documentation Best Practices
+
+This skill enforces high-quality, standardized documentation for source code files and methods. It ensures consistent metadata and clear explanations of intent across different programming languages.
+
+## Policies
+
+### 1. Mandatory File Headers
+*   **Rule**: Every source file must begin with a standardized header block.
+*   **Contents**:
+    - **Purpose**: A brief description of what the file contains/solves.
+    - **Author/Project**: Project name or author information.
+    - **Metadata**: Date created/modified and version if applicable.
+
+### 2. Mandatory Method Documentation
+*   **Rule**: Every public or non-trivial internal function/method must have a documentation block immediately preceding it.
+*   **Standards**:
+    - **C++**: Use Doxygen style (`/** ... */`).
+    - **C#**: Use XML Documentation style (`/// <summary> ...`).
+    - **JS/TS**: Use JSDoc style (`/** ... */`).
+    - **Python**: Use PEP 257 Docstrings (`""" ... """`).
+*   **Required Fields**:
+    - **Summary**: Concise description of what the method does.
+    - **Parameters**: Name and purpose of each argument.
+    - **Return Value**: Description of the output.
+    - **Exceptions/Errors**: Document significant error states or exceptions thrown.
+
+### 3. Focus on "Why" and "What"
+*   **Rule**: Do not document trivial code (e.g., `i++ // increment i`).
+*   **Action**: Document the **intent** and **usage constraints**. If the code is complex, explain the high-level logic rather than line-by-line mechanics.
+
+### 4. Semantic Linking
+*   **Rule**: Use language-specific linking features (e.g., `@see`, `{@link}`, `<see cref=.../>`) to refer to related types or methods.
+
+## Language Specifics
+
+| Language | Format | Key Tags |
+| :--- | :--- | :--- |
+| **C++** | Doxygen | `\brief`, `\param`, `\return`, `\throw` |
+| **C#** | XML Doc | `<summary>`, `<param>`, `<returns>`, `<exception>` |
+| **JS/TS** | JSDoc | `@description`, `@param`, `@returns`, `@throws` |
+| **Python** | Docstrings | `Args:`, `Returns:`, `Raises:` (Google/NumPy style) |
+
+---
+
+## Example (Generic Pattern)
+
+```text
+[File Header]
+[Imports]
+
+[Component Documentation]
+[Implementation]
+```

package/.github/copilot/skills/code-documentation/examples/cpp.md

@@ -0,0 +1,29 @@
+# C++ Documentation (Doxygen Style)
+
+### File Header
+```cpp
+/**
+ * @file DataProcessor.hpp
+ * @brief Handles high-performance transformation of raw sensor data.
+ * @author Antigravity / ma-agents
+ * @date 2026-02-22
+ * @version 1.0.0
+ */
+```
+
+### Method Documentation
+```cpp
+/**
+ * @brief Calculates the moving average of a dataset.
+ * 
+ * This method uses a sliding window algorithm to smooth out volatility 
+ * in sensor inputs.
+ * 
+ * @param data A span of float values to process.
+ * @param windowSize The size of the averaging window (must be > 0).
+ * @return The calculated moving average as a float.
+ * @throw std::invalid_argument If data is empty or windowSize is invalid.
+ * @see SignalFilter
+ */
+float calculateMovingAverage(gsl::span<const float> data, size_t windowSize);
+```

package/.github/copilot/skills/code-documentation/examples/csharp.md

@@ -0,0 +1,28 @@
+# C# Documentation (XML Style)
+
+### File Header
+```csharp
+/*
+ * File: AuthenticationService.cs
+ * Purpose: Manages user login, token validation, and multi-factor authentication.
+ * Author: Antigravity / ma-agents
+ * Date: 2026-02-22
+ */
+```
+
+### Method Documentation
+```csharp
+/// <summary>
+/// Validates a user's credentials against the secure identity store.
+/// </summary>
+/// <param name="username">The unique identifier for the user.</param>
+/// <param name="password">The plain-text password (will be hashed internally).</param>
+/// <returns>
+/// An <see cref="AuthResult"/> indicating success or failure with a details message.
+/// </returns>
+/// <exception cref="SecurityException">Thrown if the account is locked.</exception>
+public async Task<AuthResult> LoginAsync(string username, string password)
+{
+    // ...
+}
+```

package/.github/copilot/skills/code-documentation/examples/javascript_typescript.md

@@ -0,0 +1,28 @@
+# JavaScript & TypeScript Documentation (JSDoc Style)
+
+### File Header
+```typescript
+/**
+ * @file api-client.ts
+ * @description Centralized HTTP client with automatic retry and error handling.
+ * @author Antigravity / ma-agents
+ * @version 1.2.0
+ */
+```
+
+### Method Documentation
+```typescript
+/**
+ * Fetches data from a specific endpoint with optional caching.
+ * 
+ * @template T The expected type of the response data.
+ * @param {string} url The target URL (must be absolute).
+ * @param {RequestOptions} [options] Optional configuration for headers and timeouts.
+ * @returns {Promise<T>} A promise that resolves to the parsed JSON response.
+ * @throws {NetworkError} If the server is unreachable.
+ * @throws {ValidationError} If the response schema does not match T.
+ */
+async function fetchData<T>(url: string, options?: RequestOptions): Promise<T> {
+  // ...
+}
+```

package/.github/copilot/skills/code-documentation/examples/python.md

@@ -0,0 +1,57 @@
+# Python Documentation (Google/NumPy Style)
+
+### File Header
+Every module should start with a docstring that provides a high-level overview.
+
+```python
+"""
+data_processor.py
+~~~~~~~~~~~~~~~~~
+Handles high-performance transformation of raw sensor data using NumPy.
+
+:copyright: (c) 2026 by Antigravity.
+:license: MIT, see LICENSE for more details.
+"""
+```
+
+### Method Documentation
+Preferred style is Google or NumPy style for readability and integration with tools like Sphinx.
+
+```python
+def calculate_moving_average(data, window_size):
+    """Calculates the moving average of a dataset.
+
+    This method uses a sliding window algorithm to smooth out volatility 
+    in sensor inputs.
+
+    Args:
+        data (list[float]): A list or array of float values to process.
+        window_size (int): The size of the averaging window (must be > 0).
+
+    Returns:
+        float: The calculated moving average.
+
+    Raises:
+        ValueError: If data is empty or window_size is invalid.
+
+    Note:
+        This implementation assumes data is already cleaned.
+    """
+    if not data or window_size <= 0:
+        raise ValueError("Invalid data or window_size")
+    # ... implementation
+```
+
+### Class Documentation
+```python
+class SignalFilter:
+    """A collection of signal processing utilities.
+    
+    Attributes:
+        sampling_rate (int): The frequency at which signals are sampled.
+    """
+    
+    def __init__(self, sampling_rate):
+        """Initializes the SignalFilter with a specific sampling rate."""
+        self.sampling_rate = sampling_rate
+```

package/.github/copilot/skills/code-review/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: Code Review
+description: Performs comprehensive code reviews with best practices
+---
+# Code Review
+
+Perform comprehensive code reviews following industry best practices.
+
+## What to Review
+
+1. **Code Quality**: Readability, naming conventions, structure
+2. **Best Practices**: Language-specific patterns, error handling, performance
+3. **Security**: Common vulnerabilities (SQL injection, XSS, CSRF, etc.)
+4. **Testing**: Coverage, edge cases, test quality
+5. **Documentation**: Comments, API docs, clarity
+
+## Review Process
+
+- Analyze code for bugs and logical errors
+- Check adherence to coding standards
+- Identify security vulnerabilities
+- Suggest refactoring opportunities
+- Assess test coverage and documentation
+
+## Output Format
+
+```
+## Code Review Summary
+
+### Strengths
+- [Positive aspects]
+
+### Issues Found
+- **[High/Medium/Low]** [Issue description]
+  - Location: [file:line]
+  - Fix: [recommendation]
+
+### Suggestions
+- [Improvements]
+
+### Overall Assessment
+[Summary and rating]
+```

package/.github/copilot/skills/commit-message/SKILL.md

@@ -0,0 +1,79 @@
+---
+name: Commit Message Generator
+description: Generates conventional commit messages from code changes
+---
+# Commit Message Generator
+
+Generate meaningful commit messages following Conventional Commits specification.
+
+## Format
+
+```
+<type>(<scope>): <subject>
+
+<body>
+
+<footer>
+```
+
+## Types
+
+- `feat`: New feature
+- `fix`: Bug fix
+- `docs`: Documentation changes
+- `style`: Code style/formatting
+- `refactor`: Code refactoring
+- `test`: Adding/updating tests
+- `chore`: Maintenance tasks
+- `perf`: Performance improvements
+- `ci`: CI/CD changes
+- `build`: Build system changes
+- `revert`: Revert previous commit
+
+## Guidelines
+
+1. **Subject line** (max 50 chars):
+   - Use imperative mood ("Add" not "Added")
+   - Don't capitalize first letter
+   - No period at the end
+
+2. **Body** (optional):
+   - Explain what and why, not how
+   - Wrap at 72 characters
+
+3. **Footer** (optional):
+   - Breaking changes: `BREAKING CHANGE: description`
+   - Issue references: `Fixes #123`
+
+## Examples
+
+```
+feat(auth): add JWT token refresh mechanism
+
+Implement automatic token refresh to improve user experience
+and reduce re-authentication prompts.
+
+Fixes #456
+```
+
+```
+fix(api): resolve memory leak in user service
+
+The user cache was not being cleared properly, causing
+memory to grow over time.
+```
+
+```
+docs: update installation instructions
+
+Add steps for Windows users and clarify dependency requirements.
+```
+
+## Process
+
+1. Analyze the code changes
+2. Determine the type of change
+3. Identify the scope (component/module affected)
+4. Write clear, concise subject
+5. Add body if changes need explanation
+6. Add footer for breaking changes or issue refs