ma-agents 3.4.9 → 3.5.0

package/.opencode/skills/skill-creator/scripts/init_skill.py

@@ -1,208 +0,0 @@
-#!/usr/bin/env python3
-"""
-Skill Initializer - Creates a new skill from template
-
-Usage:
-    init_skill.py <skill-name> --path <path>
-
-Examples:
-    init_skill.py my-new-skill --path skills/public
-    init_skill.py my-api-helper --path skills/private
-    init_skill.py custom-skill --path /custom/location
-"""
-
-import sys
-from pathlib import Path
-
-
-SKILL_TEMPLATE = """---
-name: {skill_name}
-description: [TODO: Complete and informative explanation of what the skill does and when to use it. Include WHEN to use this skill - specific scenarios, file types, or tasks that trigger it.]
----
-
-# {skill_title}
-
-## Overview
-
-[TODO: 1-2 sentences explaining what this skill enables]
-
-## Structuring This Skill
-
-[TODO: Choose the structure that best fits this skill's purpose. Common patterns:
-
-**1. Workflow-Based** (best for sequential processes)
-- Works well when there are clear step-by-step procedures
-- Structure: ## Overview -> ## Workflow Decision Tree -> ## Step 1 -> ## Step 2...
-
-**2. Task-Based** (best for tool collections)
-- Works well when the skill offers different operations/capabilities
-- Structure: ## Overview -> ## Quick Start -> ## Task Category 1 -> ## Task Category 2...
-
-**3. Reference/Guidelines** (best for standards or specifications)
-- Works well for brand guidelines, coding standards, or requirements
-- Structure: ## Overview -> ## Guidelines -> ## Specifications -> ## Usage...
-
-**4. Capabilities-Based** (best for integrated systems)
-- Works well when the skill provides multiple interrelated features
-- Structure: ## Overview -> ## Core Capabilities -> ### 1. Feature -> ### 2. Feature...
-
-Patterns can be mixed and matched as needed.
-
-Delete this entire "Structuring This Skill" section when done - it's just guidance.]
-
-## [TODO: Replace with the first main section based on chosen structure]
-
-[TODO: Add content here]
-
-## Resources
-
-### scripts/
-Executable code (Python/Bash/etc.) that can be run directly.
-
-### references/
-Documentation and reference material intended to be loaded into context as needed.
-
-### assets/
-Files not intended to be loaded into context, but used within output Claude produces.
-
----
-**Any unneeded directories can be deleted.** Not every skill requires all three types of resources.
-"""
-
-EXAMPLE_SCRIPT = '''#!/usr/bin/env python3
-"""
-Example helper script for {skill_name}
-
-This is a placeholder script. Replace with actual implementation or delete if not needed.
-"""
-
-def main():
-    print("This is an example script for {skill_name}")
-    # TODO: Add actual script logic here
-
-if __name__ == "__main__":
-    main()
-'''
-
-EXAMPLE_REFERENCE = """# Reference Documentation for {skill_title}
-
-This is a placeholder for detailed reference documentation.
-Replace with actual reference content or delete if not needed.
-
-## When Reference Docs Are Useful
-
-- Comprehensive API documentation
-- Detailed workflow guides
-- Complex multi-step processes
-- Information too lengthy for main SKILL.md
-- Content that's only needed for specific use cases
-"""
-
-EXAMPLE_ASSET = """# Example Asset File
-
-This placeholder represents where asset files would be stored.
-Replace with actual asset files (templates, images, fonts, etc.) or delete if not needed.
-
-Asset files are NOT intended to be loaded into context, but rather used within
-the output Claude produces.
-"""
-
-
-def title_case_skill_name(skill_name):
-    """Convert hyphenated skill name to Title Case for display."""
-    return ' '.join(word.capitalize() for word in skill_name.split('-'))
-
-
-def init_skill(skill_name, path):
-    """
-    Initialize a new skill directory with template SKILL.md.
-
-    Args:
-        skill_name: Name of the skill
-        path: Path where the skill directory should be created
-
-    Returns:
-        Path to created skill directory, or None if error
-    """
-    skill_dir = Path(path).resolve() / skill_name
-
-    if skill_dir.exists():
-        print(f"Error: Skill directory already exists: {skill_dir}")
-        return None
-
-    try:
-        skill_dir.mkdir(parents=True, exist_ok=False)
-        print(f"Created skill directory: {skill_dir}")
-    except Exception as e:
-        print(f"Error creating directory: {e}")
-        return None
-
-    skill_title = title_case_skill_name(skill_name)
-    skill_content = SKILL_TEMPLATE.format(
-        skill_name=skill_name,
-        skill_title=skill_title
-    )
-
-    skill_md_path = skill_dir / 'SKILL.md'
-    try:
-        skill_md_path.write_text(skill_content)
-        print("Created SKILL.md")
-    except Exception as e:
-        print(f"Error creating SKILL.md: {e}")
-        return None
-
-    try:
-        scripts_dir = skill_dir / 'scripts'
-        scripts_dir.mkdir(exist_ok=True)
-        example_script = scripts_dir / 'example.py'
-        example_script.write_text(EXAMPLE_SCRIPT.format(skill_name=skill_name))
-        print("Created scripts/example.py")
-
-        references_dir = skill_dir / 'references'
-        references_dir.mkdir(exist_ok=True)
-        example_reference = references_dir / 'api_reference.md'
-        example_reference.write_text(EXAMPLE_REFERENCE.format(skill_title=skill_title))
-        print("Created references/api_reference.md")
-
-        assets_dir = skill_dir / 'assets'
-        assets_dir.mkdir(exist_ok=True)
-        example_asset = assets_dir / 'example_asset.txt'
-        example_asset.write_text(EXAMPLE_ASSET)
-        print("Created assets/example_asset.txt")
-    except Exception as e:
-        print(f"Error creating resource directories: {e}")
-        return None
-
-    print(f"\nSkill '{skill_name}' initialized successfully at {skill_dir}")
-    print("\nNext steps:")
-    print("1. Edit SKILL.md to complete the TODO items and update the description")
-    print("2. Customize or delete the example files in scripts/, references/, and assets/")
-    print("3. Run the validator when ready to check the skill structure")
-
-    return skill_dir
-
-
-def main():
-    if len(sys.argv) < 4 or sys.argv[2] != '--path':
-        print("Usage: init_skill.py <skill-name> --path <path>")
-        print("\nSkill name requirements:")
-        print("  - Kebab-case identifier (e.g., 'my-data-analyzer')")
-        print("  - Lowercase letters, digits, and hyphens only")
-        print("  - Max 64 characters")
-        print("\nExamples:")
-        print("  init_skill.py my-new-skill --path skills/public")
-        print("  init_skill.py my-api-helper --path skills/private")
-        sys.exit(1)
-
-    skill_name = sys.argv[1]
-    path = sys.argv[3]
-
-    print(f"Initializing skill: {skill_name}")
-    print(f"   Location: {path}\n")
-
-    result = init_skill(skill_name, path)
-    sys.exit(0 if result else 1)
-
-
-if __name__ == "__main__":
-    main()

package/.opencode/skills/skill-creator/scripts/package_skill.py

@@ -1,99 +0,0 @@
-#!/usr/bin/env python3
-"""
-Skill Packager - Creates a distributable .skill file of a skill folder
-
-Usage:
-    python package_skill.py <path/to/skill-folder> [output-directory]
-
-Example:
-    python package_skill.py skills/public/my-skill
-    python package_skill.py skills/public/my-skill ./dist
-"""
-
-import sys
-import zipfile
-from pathlib import Path
-from quick_validate import validate_skill
-
-
-def package_skill(skill_path, output_dir=None):
-    """
-    Package a skill folder into a .skill file.
-
-    Args:
-        skill_path: Path to the skill folder
-        output_dir: Optional output directory for the .skill file
-
-    Returns:
-        Path to the created .skill file, or None if error
-    """
-    skill_path = Path(skill_path).resolve()
-
-    if not skill_path.exists():
-        print(f"Error: Skill folder not found: {skill_path}")
-        return None
-
-    if not skill_path.is_dir():
-        print(f"Error: Path is not a directory: {skill_path}")
-        return None
-
-    skill_md = skill_path / "SKILL.md"
-    if not skill_md.exists():
-        print(f"Error: SKILL.md not found in {skill_path}")
-        return None
-
-    print("Validating skill...")
-    valid, message = validate_skill(skill_path)
-    if not valid:
-        print(f"Validation failed: {message}")
-        print("   Please fix the validation errors before packaging.")
-        return None
-    print(f"{message}\n")
-
-    skill_name = skill_path.name
-    if output_dir:
-        output_path = Path(output_dir).resolve()
-        output_path.mkdir(parents=True, exist_ok=True)
-    else:
-        output_path = Path.cwd()
-
-    skill_filename = output_path / f"{skill_name}.skill"
-
-    try:
-        with zipfile.ZipFile(skill_filename, 'w', zipfile.ZIP_DEFLATED) as zipf:
-            for file_path in skill_path.rglob('*'):
-                if file_path.is_file():
-                    arcname = file_path.relative_to(skill_path.parent)
-                    zipf.write(file_path, arcname)
-                    print(f"  Added: {arcname}")
-
-        print(f"\nSuccessfully packaged skill to: {skill_filename}")
-        return skill_filename
-
-    except Exception as e:
-        print(f"Error creating .skill file: {e}")
-        return None
-
-
-def main():
-    if len(sys.argv) < 2:
-        print("Usage: python package_skill.py <path/to/skill-folder> [output-directory]")
-        print("\nExample:")
-        print("  python package_skill.py skills/public/my-skill")
-        print("  python package_skill.py skills/public/my-skill ./dist")
-        sys.exit(1)
-
-    skill_path = sys.argv[1]
-    output_dir = sys.argv[2] if len(sys.argv) > 2 else None
-
-    print(f"Packaging skill: {skill_path}")
-    if output_dir:
-        print(f"   Output directory: {output_dir}")
-    print()
-
-    result = package_skill(skill_path, output_dir)
-    sys.exit(0 if result else 1)
-
-
-if __name__ == "__main__":
-    main()

package/.opencode/skills/skill-creator/scripts/quick_validate.py

@@ -1,113 +0,0 @@
-#!/usr/bin/env python3
-"""
-Quick validation script for skills - minimal version
-"""
-
-import sys
-import re
-
-try:
-    import yaml
-except ImportError:
-    yaml = None
-
-from pathlib import Path
-
-
-def validate_skill(skill_path):
-    """Basic validation of a skill"""
-    skill_path = Path(skill_path)
-
-    # Check SKILL.md exists
-    skill_md = skill_path / 'SKILL.md'
-    if not skill_md.exists():
-        return False, "SKILL.md not found"
-
-    # Read and validate frontmatter
-    content = skill_md.read_text()
-    if not content.startswith('---'):
-        return False, "No YAML frontmatter found"
-
-    # Extract frontmatter
-    match = re.match(r'^---\n(.*?)\n---', content, re.DOTALL)
-    if not match:
-        return False, "Invalid frontmatter format"
-
-    frontmatter_text = match.group(1)
-
-    # Parse YAML frontmatter
-    if yaml is None:
-        # Fallback: basic key-value parsing if PyYAML not installed
-        frontmatter = {}
-        for line in frontmatter_text.strip().split('\n'):
-            if ':' in line:
-                key, _, value = line.partition(':')
-                frontmatter[key.strip()] = value.strip()
-    else:
-        try:
-            frontmatter = yaml.safe_load(frontmatter_text)
-            if not isinstance(frontmatter, dict):
-                return False, "Frontmatter must be a YAML dictionary"
-        except yaml.YAMLError as e:
-            return False, f"Invalid YAML in frontmatter: {e}"
-
-    # Define allowed properties
-    ALLOWED_PROPERTIES = {'name', 'description', 'license', 'allowed-tools', 'metadata', 'compatibility'}
-
-    # Check for unexpected properties
-    unexpected_keys = set(frontmatter.keys()) - ALLOWED_PROPERTIES
-    if unexpected_keys:
-        return False, (
-            f"Unexpected key(s) in SKILL.md frontmatter: {', '.join(sorted(unexpected_keys))}. "
-            f"Allowed properties are: {', '.join(sorted(ALLOWED_PROPERTIES))}"
-        )
-
-    # Check required fields
-    if 'name' not in frontmatter:
-        return False, "Missing 'name' in frontmatter"
-    if 'description' not in frontmatter:
-        return False, "Missing 'description' in frontmatter"
-
-    # Validate name
-    name = frontmatter.get('name', '')
-    if not isinstance(name, str):
-        return False, f"Name must be a string, got {type(name).__name__}"
-    name = name.strip()
-    if name:
-        if not re.match(r'^[a-z0-9-]+$', name):
-            return False, f"Name '{name}' should be kebab-case (lowercase letters, digits, and hyphens only)"
-        if name.startswith('-') or name.endswith('-') or '--' in name:
-            return False, f"Name '{name}' cannot start/end with hyphen or contain consecutive hyphens"
-        if len(name) > 64:
-            return False, f"Name is too long ({len(name)} characters). Maximum is 64 characters."
-
-    # Validate description
-    description = frontmatter.get('description', '')
-    if not isinstance(description, str):
-        return False, f"Description must be a string, got {type(description).__name__}"
-    description = description.strip()
-    if description:
-        if '<' in description or '>' in description:
-            return False, "Description cannot contain angle brackets (< or >)"
-        if len(description) > 1024:
-            return False, f"Description is too long ({len(description)} characters). Maximum is 1024 characters."
-
-    # Validate compatibility if present
-    compatibility = frontmatter.get('compatibility', '')
-    if compatibility:
-        if not isinstance(compatibility, str):
-            return False, f"Compatibility must be a string, got {type(compatibility).__name__}"
-        if len(compatibility) > 500:
-            return False, f"Compatibility is too long ({len(compatibility)} characters). Maximum is 500 characters."
-
-    return True, "Skill is valid!"
-
-
-if __name__ == "__main__":
-    if len(sys.argv) != 2:
-        print("Usage: python quick_validate.py <skill_directory>")
-        sys.exit(1)
-
-    valid, message = validate_skill(sys.argv[1])
-    print(message)
-    sys.exit(0 if valid else 1)

package/.opencode/skills/sprint-status-view/SKILL.md

@@ -1,263 +0,0 @@
----
-name: sprint-status-view
-description: Display sprint progress with capacity, items, and backlog. Regenerates sprint-status.yaml.
-type: skill
-triggers:
-  - "sprint status view"
-  - "view sprint status"
----
-
-# Sprint Status View Workflow
-
-Display sprint status with capacity, items, and backlog summary. Regenerates `sprint-status.yaml` from authoritative sources.
-
-<workflow>
-
-<step n="1" goal="Suggest running /cleanup-done first">
-  <output>
-**Tip:** Consider running `/cleanup-done` before viewing sprint status to archive completed items and free capacity.
-  </output>
-  <action>Continue to next step (advisory only -- do not auto-invoke /cleanup-done)</action>
-</step>
-
-<step n="2" goal="Load data sources">
-  <action>Glob `_bmad-output/implementation-artifacts/sprints/sprint-*.yaml` to discover all sprint entity files</action>
-  <action>Store discovered sprint files as {{sprint_files}} list</action>
-
-  <action>Read `_bmad-output/implementation-artifacts/backlog.yaml` if it exists</action>
-  <action>Store the backlog items list as {{backlog_items}} (or empty list if file not found)</action>
-
-  <action>Glob `_bmad-output/implementation-artifacts/bug-*.md` to discover all bug story files (fallback for bug metadata)</action>
-  <action>For each bug file found, parse YAML frontmatter to extract: title, severity, status</action>
-  <action>Store as {{bug_metadata_map}} keyed by file basename (e.g., `bug-login-crash`)</action>
-
-  <action>Read `_bmad-output/implementation-artifacts/sprint-status.yaml` if it exists (fallback for story status when backlog.yaml is missing or incomplete)</action>
-  <action>Parse development_status section into {{status_fallback_map}} -- key: story key, value: status</action>
-  <action>Exclude epic-* keys and *-retrospective keys from the fallback map</action>
-
-  <check if="no sprint files found AND no backlog.yaml exists">
-    <output>
-**No Sprint Data Found**
-
-No sprint files exist (`sprints/sprint-*.yaml`) and no `backlog.yaml` was found.
-
-**To get started:**
-1. Run `/generate-backlog` to create a backlog from your epics
-2. Run `/add-sprint` to create your first sprint
-3. Run `/add-to-sprint` to assign backlog items to it
-    </output>
-    <action>Exit workflow</action>
-  </check>
-</step>
-
-<step n="3" goal="Display each sprint">
-  <action>For each sprint in {{sprint_files}}, read the full YAML content</action>
-  <action>Sort sprints for display: active first, then planning, then closed</action>
-  <action>Initialize {{total_done_in_sprints}} = 0 for step 4</action>
-
-  <action>For each sprint (in sorted order):
-
-    **If sprint.status is "closed":**
-    - Count total items in sprint.items
-    - Display collapsed summary line only
-
-    **If sprint.status is NOT "closed" (active or planning):**
-    - Calculate {{item_count}} = length(sprint.items)
-    - For each item identifier in sprint.items, resolve details:
-      - Look up item in {{backlog_items}} by matching `id` field
-      - If found in backlog: use `type`, `title`, `status`, `severity` from backlog entry
-      - If NOT found in backlog and item matches `^bug-`: look up in {{bug_metadata_map}} for title/severity, use status from bug frontmatter or default to "backlog"
-      - If NOT found in backlog and item matches a story pattern: look up in {{status_fallback_map}} for status, infer title from key, set type to "story"
-      - If item cannot be resolved from any source: display with raw identifier, type "unknown", status "unknown"
-    - If resolved item status is "done", increment {{total_done_in_sprints}}
-    - Build capacity bar: `[===---]` style where `=` represents filled slots and `-` represents remaining capacity
-  </action>
-
-  <action>Display non-closed sprints:</action>
-  <output>
-{{#each non_closed_sprints}}
----
-
-## {{sprint.name}} ({{sprint.status}}) -- {{item_count}}/{{sprint.capacity}} items
-
-{{#if sprint.start}}**Start:** {{sprint.start}}{{/if}}{{#if sprint.end}} | **End:** {{sprint.end}}{{/if}}
-
-| Item | Type | Status |
-|---|---|---|
-{{#each resolved_items}}
-| {{id}} | {{#if is_story}}[story]{{/if}}{{#if is_bug}}[bug, {{severity}}]{{/if}} | {{status}} |
-{{/each}}
-{{#if items_empty}}
-*(No items assigned)*
-{{/if}}
-
-**Capacity:** {{capacity_bar}}
-{{/each}}
-  </output>
-
-  <action>Display closed sprints:</action>
-  <output>
-{{#each closed_sprints}}
----
-**{{sprint.name}}** (closed) -- {{item_count}} items completed
-{{/each}}
-  </output>
-</step>
-
-<step n="4" goal="Completed items summary">
-  <action>Count items with status "done" that are still present in non-closed sprint files (use {{total_done_in_sprints}} from step 3)</action>
-  <check if="total_done_in_sprints > 0">
-    <output>
----
-
-## Completed Items
-
-{{total_done_in_sprints}} done item(s) are still in sprint files. Run `/cleanup-done` to archive them and free capacity.
-    </output>
-  </check>
-  <check if="total_done_in_sprints == 0">
-    <action>Skip this section -- no done items lingering in sprints</action>
-  </check>
-</step>
-
-<step n="5" goal="Unassigned backlog">
-  <action>Filter {{backlog_items}} to find items where sprint is null (unassigned)</action>
-  <action>Exclude items with status "done" from the unassigned list</action>
-  <action>Sort unassigned items by priority ascending (lowest number = highest priority)</action>
-  <action>Store as {{unassigned_items}}</action>
-  <action>Store total count as {{unassigned_total}}</action>
-  <action>Take top 15 items for display as {{unassigned_display}}</action>
-
-  <check if="unassigned_total > 0">
-    <output>
----
-
-## Unassigned Backlog
-
-| # | Item | Type | Priority | Status |
-|---|---|---|---|---|
-{{#each unassigned_display}}
-| {{priority}} | {{id}} | {{type}} | {{priority}} | {{status}} |
-{{/each}}
-{{#if unassigned_total > 15}}
-
-... and {{unassigned_total - 15}} more
-{{/if}}
-    </output>
-  </check>
-  <check if="unassigned_total == 0">
-    <output>
----
-
-## Unassigned Backlog
-
-*(All backlog items are assigned to sprints)*
-    </output>
-  </check>
-</step>
-
-<step n="6" goal="Next actions menu">
-  <ask>
-**Next Actions:**
-[1] Full backlog
-[2] /add-to-sprint
-[3] /remove-from-sprint
-[4] /prioritize-backlog
-[5] /add-sprint
-[6] /cleanup-done
-[7] Exit
-
-Choice:
-  </ask>
-  <check if="choice == 1">
-    <action>Display all items from {{backlog_items}} in a table: id, type, priority, status, sprint, severity</action>
-    <goto step="6" />
-  </check>
-  <check if="choice == 2">
-    <output>Run `/add-to-sprint` to assign backlog items to a sprint.</output>
-  </check>
-  <check if="choice == 3">
-    <output>Run `/remove-from-sprint` to remove items from a sprint.</output>
-  </check>
-  <check if="choice == 4">
-    <output>Run `/prioritize-backlog` to reorder backlog priorities.</output>
-  </check>
-  <check if="choice == 5">
-    <output>Run `/add-sprint` to create a new sprint.</output>
-  </check>
-  <check if="choice == 6">
-    <output>Run `/cleanup-done` to archive completed items from sprints.</output>
-  </check>
-  <check if="choice == 7">
-    <action>Exit workflow</action>
-  </check>
-</step>
-
-<step n="7" goal="Regenerate sprint-status.yaml (internal)" internal="true">
-  <action>This step runs automatically after display (steps 3-6) completes, before the workflow exits.</action>
-
-  <action>Read existing `_bmad-output/implementation-artifacts/sprint-status.yaml` if it exists</action>
-  <action>Preserve the STATUS DEFINITIONS comment block at the top of the file (lines starting with `#` that define status values)</action>
-  <action>Preserve any epic-* keys and *-retrospective keys from the existing file</action>
-
-  <action>Build the new development_status section:
-    - Source 1: {{backlog_items}} from backlog.yaml -- for each item where status is NOT "done", add an entry: key = item.id, value = item.status
-    - Source 2: sprint entity files -- for each sprint, for each item in sprint.items, ensure the item has an entry. If the item was already added from backlog.yaml, the backlog value wins. If the item is NOT in backlog.yaml, look up status from {{bug_metadata_map}} or {{status_fallback_map}}.
-    - Exclude items with status "done" -- only non-done items appear in sprint-status.yaml
-  </action>
-
-  <action>Collect sprint metadata for header comments:
-    - For each sprint: id, name, status, item count, capacity
-  </action>
-
-  <action>Get current ISO timestamp as {{generated_at}}</action>
-
-  <action>Write `_bmad-output/implementation-artifacts/sprint-status.yaml` with this structure:
-
-```yaml
-# generated: {{original_generated_date or generated_at}}
-# updated: {{generated_at}} — regenerated by sprint-status-view
-# project: {{project_name from existing file or "unknown"}}
-# project_key: {{project_key from existing file or "NOKEY"}}
-# tracking_system: file-system
-# story_location: _bmad-output/implementation-artifacts
-#
-# Sprints:
-{{#each sprints}}
-#   {{sprint.id}}: {{sprint.name}} ({{sprint.status}}) — {{item_count}}/{{sprint.capacity}} items
-{{/each}}
-#
-# STATUS DEFINITIONS:
-# ==================
-# (preserve the full STATUS DEFINITIONS block from the existing file verbatim)
-# If no existing file, use these defaults:
-# backlog        — item is in the backlog, not yet started
-# ready-for-dev  — story file created, ready for development
-# in-progress    — item is actively being worked on
-# review         — item is in review
-# done           — item is complete (excluded from this file)
-
-{{#if preserved_epic_keys}}
-# Epic tracking
-{{#each preserved_epic_keys}}
-{{key}}: {{value}}
-{{/each}}
-{{/if}}
-
-development_status:
-{{#each active_items}}
-  {{id}}: {{status}}
-{{/each}}
-
-{{#if preserved_retro_keys}}
-# Retrospective tracking
-{{#each preserved_retro_keys}}
-{{key}}: {{value}}
-{{/each}}
-{{/if}}
-```
-
-  </action>
-</step>
-
-</workflow>

package/.opencode/skills/sprint-status-view/bmad-skill-manifest.yaml

@@ -1,3 +0,0 @@
-type: skill
-name: sprint-status-view
-module: ma-skills