@jhm1909/ag-kit 0.1.0

package/.agent/skills/project-manager/references/task-decomposition.md

@@ -0,0 +1,194 @@
+# Deep Task Decomposition Guide
+
+This guide provides a comprehensive methodology for breaking down documentation into maximum granular, actionable tasks.
+
+## Core Philosophy
+
+> **"A task that takes more than 4 hours is not a task—it's a mini-project hiding complexity."**
+
+The goal is to decompose until:
+
+1. Each task is **independently testable**
+2. Each task is **estimable** (ideally 1-4 hours)
+3. Each task has **clear Definition of Done**
+4. Each task can be **assigned to one person**
+
+## Decomposition Levels
+
+### Level 1: Epic (Feature/Module)
+
+- **Size**: Days to weeks
+- **Source**: PRD sections, major features
+- **Example**: "User Authentication System"
+
+### Level 2: Story (User-Facing Capability)
+
+- **Size**: 1-3 days
+- **Source**: Use cases, user flows
+- **Format**: "As a [role], I want [action], so that [value]"
+- **Example**: "As a user, I want to reset my password, so that I can regain access"
+
+### Level 3: Task (Technical Work Unit)
+
+- **Size**: 2-8 hours
+- **Source**: Story breakdown by layer/component
+- **Example**: "Implement forgot password API endpoint"
+
+### Level 4: Sub-Task (Atomic Action)
+
+- **Size**: 30min - 2 hours
+- **Source**: Implementation steps
+- **Example**: "Add email validation regex", "Write unit test for token expiry"
+
+## Decomposition Algorithm
+
+### Step 1: Document Analysis
+
+Extract from document:
+
+1. **Nouns** → Entities/Objects (User, Order, Product)
+2. **Verbs** → Actions/Operations (Create, Update, Delete, View)
+3. **Adjectives** → Constraints/Rules (valid, unique, max 10)
+4. **Flows** → Sequences (Step 1 → Step 2 → Step 3)
+
+### Step 2: Entity-Action Matrix
+
+Create a matrix:
+
+| Entity | Create | Read | Update | Delete | Special Actions       |
+| ------ | ------ | ---- | ------ | ------ | --------------------- |
+| User   | ✓      | ✓    | ✓      | ✓      | Login, Logout, Verify |
+| Order  | ✓      | ✓    | ✓      | -      | Cancel, Refund        |
+
+Each ✓ = At least 1 Story
+
+### Step 3: Vertical Slice Decomposition
+
+For each Story, break into **vertical slices** (not horizontal layers):
+
+**❌ Bad (Horizontal)**:
+
+- Build all APIs
+- Build all UI screens
+- Write all tests
+
+**✅ Good (Vertical)**:
+
+- User can view product list (API + UI + Test)
+- User can view product detail (API + UI + Test)
+- User can add to cart (API + UI + Test)
+
+### Step 4: Task Breakdown Template
+
+For each Story, create tasks using this structure:
+
+```markdown
+## Story: [Story Title]
+
+### Database/Schema
+
+- [ ] Create migration for [table]
+- [ ] Add index for [column]
+- [ ] Seed test data
+
+### Backend/API
+
+- [ ] Define request/response types
+- [ ] Implement [endpoint] handler
+- [ ] Add input validation
+- [ ] Add authorization check
+- [ ] Write unit tests
+- [ ] Write integration tests
+
+### Frontend/UI
+
+- [ ] Create [component] component
+- [ ] Implement state management
+- [ ] Connect to API
+- [ ] Handle loading state
+- [ ] Handle error state
+- [ ] Handle empty state
+- [ ] Add form validation (if applicable)
+- [ ] Write component tests
+
+### Cross-Cutting
+
+- [ ] Add logging
+- [ ] Add error tracking
+- [ ] Update API documentation
+- [ ] Update user documentation (if needed)
+```
+
+### Step 5: Edge Case Extraction
+
+For each flow, identify:
+
+- **Happy Path**: Normal successful flow
+- **Validation Errors**: Invalid inputs
+- **Business Rule Violations**: Constraint failures
+- **System Errors**: Network, timeout, service unavailable
+- **Concurrency**: Race conditions, optimistic locking
+- **Authorization**: Permission denied scenarios
+
+Each edge case may generate additional tasks.
+
+## Output Format
+
+### Task Card Template
+
+```markdown
+## [TASK-ID]: [Task Title]
+
+**Story**: [Parent Story ID]
+**Type**: Backend | Frontend | Database | DevOps | Documentation
+**Priority**: P0 | P1 | P2
+**Estimate**: [X hours]
+
+### Description
+
+[Brief description of what needs to be done]
+
+### Acceptance Criteria
+
+- [ ] Criterion 1
+- [ ] Criterion 2
+
+### Technical Notes
+
+- [Any implementation hints or constraints]
+
+### Dependencies
+
+- Blocked by: [TASK-ID] (if any)
+- Blocks: [TASK-ID] (if any)
+
+### Definition of Done
+
+- [ ] Code complete
+- [ ] Tests written and passing
+- [ ] Code reviewed
+- [ ] Documentation updated
+```
+
+## Decomposition Triggers
+
+Use this capability when user says:
+
+- "Break down this PRD..."
+- "Decompose this feature..."
+- "Create tasks from this document..."
+- "Split this into smaller tasks..."
+- "What tasks do we need for..."
+
+## Quality Checklist
+
+Before finalizing decomposition:
+
+- [ ] **No task > 8 hours** - If larger, break it down further
+- [ ] **Each task is testable** - Has clear pass/fail criteria
+- [ ] **Dependencies are explicit** - Blocked/blocks relationships
+- [ ] **No hidden complexity** - Edge cases extracted as tasks
+- [ ] **Estimates are realistic** - Include testing time
+- [ ] **Vertical slices preferred** - End-to-end functionality
+- [ ] **Documentation tasks included** - API docs, user docs
+- [ ] **Test tasks explicit** - Not "included" in dev tasks

package/.agent/skills/project-manager/references/workflows-guide.md

@@ -0,0 +1,44 @@
+# Antigravity Workflows Standard
+
+This guide defines the **Antigravity Workflow Specification**. Workflows orchestrate multiple skills and tools for complex task completion.
+
+## 1. File Metadata (Frontmatter)
+
+```yaml
+---
+description: [Summary starting with a verb, e.g., "Orchestrates..."]
+---
+```
+
+## 2. Structure & Formatting
+
+### A. Stage-Based Steps
+
+Use `## Step N: [Phase Name]` for major progress markers.
+
+### B. Annotations & Callouts
+
+- **Turbo**: Use `// turbo` above a step to denote auto-run compatibility.
+- **MCP Callouts**: Use the following format for tool suggestions:
+  `> 💡 **MCP**: Use [tool-name] for [purpose]`
+- **Rule References**: Always link to required rules:
+  `> 💡 **MANDATORY**: Follow [.agent/rules/name.md](file:///path/to/rule.md)`
+
+### C. Skill Integration
+
+Explicitly state which skill should be invoked:
+
+- "Invoke `[backend-developer]` skill to..."
+
+### D. Quick Reference Table
+
+Include a summary table at the end of the file:
+| Step | Skill | Output |
+| :--- | :--- | :--- |
+| 1 | research | markdown |
+
+## 3. Best Practices
+
+1. **Vertical Slicing**: Ensure steps lead to a functional "slice" of value.
+2. **Checkpoints**: Use **WAIT** in bold to indicate where user feedback is strictly required.
+3. **Pathing**: Use absolute `file:///` URIs for internal links to ensure they are clickable.

package/.agent/skills/project-manager/router.json

@@ -0,0 +1,160 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "name": "project-manager",
+  "description": "Routes queries to appropriate reference documents based on keywords and context",
+  "routes": [
+    {
+      "id": "prd-template",
+      "keywords": [
+        "PRD",
+        "product requirements",
+        "requirements document",
+        "strategic",
+        "hypothesis",
+        "success metrics",
+        "analytics"
+      ],
+      "path": "templates/prd-strategic.md",
+      "description": "PRD Strategic Template - 'What & Why'. Hypothesis, success metrics, analytics."
+    },
+    {
+      "id": "user-story-template",
+      "keywords": [
+        "user story",
+        "backlog",
+        "acceptance criteria",
+        "DoD",
+        "definition of done",
+        "story"
+      ],
+      "path": "templates/user-story-simple.md",
+      "description": "User Story Template - Backlog items with Story + Acceptance Criteria + DoD."
+    },
+    {
+      "id": "strategy-one-pager",
+      "keywords": [
+        "strategy",
+        "one-pager",
+        "pitch",
+        "value",
+        "cost",
+        "risk",
+        "new idea"
+      ],
+      "path": "templates/pm-strategy-one-pager.md",
+      "description": "Strategy One-Pager Template - Pitching new ideas (Value, Cost, Risk)."
+    },
+    {
+      "id": "rules-guide",
+      "keywords": [
+        "rules",
+        "SOP",
+        "context injection",
+        "rule structure",
+        "governance",
+        "standards",
+        ".agent/rules"
+      ],
+      "path": "references/rules-guide.md",
+      "description": "STANDARD: SOPs, Context Injection, Rule Structure for .agent/rules/"
+    },
+    {
+      "id": "workflows-guide",
+      "keywords": [
+        "workflow",
+        "turbo",
+        "checkpoint",
+        "flow design",
+        "automation",
+        ".agent/workflows"
+      ],
+      "path": "references/workflows-guide.md",
+      "description": "STANDARD: Turbo execution, checkpoints, flow design for .agent/workflows/"
+    },
+    {
+      "id": "task-decomposition",
+      "keywords": [
+        "decomposition",
+        "breakdown",
+        "split",
+        "granularity",
+        "estimation",
+        "vertical slice",
+        "entity-action"
+      ],
+      "path": "references/task-decomposition.md",
+      "description": "Methodology for breaking docs into granular tasks (2-8 hours)."
+    },
+    {
+      "id": "strategic-frameworks",
+      "keywords": [
+        "RICE",
+        "Kano",
+        "prioritization",
+        "scoring",
+        "ranking",
+        "framework"
+      ],
+      "path": "references/strategic-frameworks.md",
+      "description": "RICE, Kano, and other prioritization methods."
+    },
+    {
+      "id": "ba-collaboration",
+      "keywords": [
+        "business analyst",
+        "BA",
+        "domain",
+        "compliance",
+        "regulatory",
+        "persona",
+        "industry"
+      ],
+      "path": "references/ba-collaboration.md",
+      "description": "Collaboration guide with Business Analyst skill for domain-specific context."
+    },
+    {
+      "id": "skill-creation",
+      "keywords": [
+        "create skill",
+        "update skill",
+        "manage skill",
+        "skill maintenance",
+        "new agent skill"
+      ],
+      "path": "references/skill-creation.md",
+      "description": "Comprehensive guide for creating, initializing, and maintaining Agent Skills."
+    },
+    {
+      "id": "skill-questionnaire",
+      "keywords": [
+        "skill creation",
+        "new skill",
+        "update skill",
+        "skill requirements",
+        "questionnaire"
+      ],
+      "path": "templates/skill-questionnaire.md",
+      "description": "Questionnaire to gather requirements for creating or updating an Agent Skill."
+    }
+  ],
+  "relatedSkills": [
+    {
+      "name": "business-analysis",
+      "path": "../business-analysis/SKILL.md",
+      "description": "For deep domain-specific context, regulations, and industry standards.",
+      "keywords": [
+        "domain",
+        "compliance",
+        "regulatory",
+        "user persona",
+        "industry metrics",
+        "FinTech",
+        "Healthcare"
+      ]
+    }
+  ],
+  "usageInstructions": {
+    "howToUse": "1. Match user query keywords against routes[].keywords. 2. Load the corresponding path file for detailed instructions. 3. For domain-specific queries, consult relatedSkills.",
+    "priority": "Templates for creation tasks, References for standards/methodology, RelatedSkills for domain expertise."
+  }
+}

package/.agent/skills/project-manager/scripts/compare_skill.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+"""
+Compare two versions of a skill (before/after upgrade).
+
+Usage:
+    python compare_skill.py <before_path> <after_path>
+    
+Example:
+    python compare_skill.py .agent/skills/designer.backup .agent/skills/designer
+"""
+
+import sys
+import re
+import argparse
+from pathlib import Path
+
+# Import encoding utils from same directory
+try:
+    from encoding_utils import configure_utf8_console, read_text_utf8
+    configure_utf8_console()
+except ImportError:
+    def read_text_utf8(path: Path) -> str:
+        return path.read_text(encoding='utf-8')
+
+
+def count_tokens_approx(text: str) -> int:
+    """Approximate token count (words + punctuation)."""
+    return len(re.findall(r'\S+', text))
+
+
+def extract_frontmatter(content: str) -> tuple[dict, str]:
+    """Extract YAML frontmatter and body from SKILL.md."""
+    frontmatter = {}
+    body = content
+    
+    match = re.match(r'^---\s*\n(.*?)\n---\s*\n(.*)$', content, re.DOTALL)
+    if match:
+        fm_text = match.group(1)
+        body = match.group(2)
+        
+        # Simple YAML parsing
+        for line in fm_text.split('\n'):
+            if ':' in line and not line.startswith(' '):
+                key, _, value = line.partition(':')
+                frontmatter[key.strip()] = value.strip()
+    
+    return frontmatter, body
+
+
+def extract_sections(body: str) -> list[str]:
+    """Extract markdown section headers."""
+    return re.findall(r'^#{1,3}\s+(.+)$', body, re.MULTILINE)
+
+
+def count_files(skill_path: Path) -> dict:
+    """Count files in skill subdirectories."""
+    counts = {'scripts': 0, 'references': 0, 'assets': 0}
+    
+    for subdir in counts.keys():
+        path = skill_path / subdir
+        if path.exists():
+            counts[subdir] = len([f for f in path.iterdir() if f.is_file()])
+    
+    return counts
+
+
+def analyze_skill(skill_path: Path) -> dict:
+    """Analyze a skill and return metrics."""
+    skill_md = skill_path / 'SKILL.md'
+    
+    if not skill_md.exists():
+        raise FileNotFoundError(f"SKILL.md not found in {skill_path}")
+    
+    content = read_text_utf8(skill_md)
+    frontmatter, body = extract_frontmatter(content)
+    sections = extract_sections(body)
+    file_counts = count_files(skill_path)
+    
+    return {
+        'name': frontmatter.get('name', skill_path.name),
+        'description': frontmatter.get('description', ''),
+        'tokens': count_tokens_approx(content),
+        'sections': sections,
+        'section_count': len(sections),
+        'scripts': file_counts['scripts'],
+        'references': file_counts['references'],
+        'assets': file_counts['assets'],
+        'frontmatter': frontmatter,
+    }
+
+
+def compare_skills(before: dict, after: dict) -> str:
+    """Generate comparison report in markdown format."""
+    
+    def calc_change(b, a):
+        if b == 0:
+            return f"+{a}" if a > 0 else "0"
+        pct = ((a - b) / b) * 100
+        sign = "+" if pct >= 0 else ""
+        return f"{sign}{pct:.0f}%"
+    
+    # Find section changes
+    before_sections = set(before['sections'])
+    after_sections = set(after['sections'])
+    new_sections = after_sections - before_sections
+    removed_sections = before_sections - after_sections
+    
+    report = f"""## Skill Comparison Report: {after['name']}
+
+### Summary
+| Metric | Before | After | Change |
+|--------|--------|-------|--------|
+| Tokens | {before['tokens']} | {after['tokens']} | {calc_change(before['tokens'], after['tokens'])} |
+| Sections | {before['section_count']} | {after['section_count']} | {calc_change(before['section_count'], after['section_count'])} |
+| Scripts | {before['scripts']} | {after['scripts']} | {calc_change(before['scripts'], after['scripts'])} |
+| References | {before['references']} | {after['references']} | {calc_change(before['references'], after['references'])} |
+| Assets | {before['assets']} | {after['assets']} | {calc_change(before['assets'], after['assets'])} |
+
+"""
+
+    if new_sections:
+        report += "### New Sections Added\n"
+        for section in sorted(new_sections):
+            report += f"- {section}\n"
+        report += "\n"
+    
+    if removed_sections:
+        report += "### Sections Removed\n"
+        for section in sorted(removed_sections):
+            report += f"- {section}\n"
+        report += "\n"
+    
+    # Description change
+    if before['description'] != after['description']:
+        report += "### Description Changed\n"
+        report += f"**Before:** {before['description'][:100]}...\n\n"
+        report += f"**After:** {after['description'][:100]}...\n\n"
+    
+    return report
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Compare two versions of a skill (before/after upgrade)'
+    )
+    parser.add_argument('before', type=Path, help='Path to before skill (backup)')
+    parser.add_argument('after', type=Path, help='Path to after skill (current)')
+    parser.add_argument('--output', '-o', type=Path, help='Output file (default: stdout)')
+    
+    args = parser.parse_args()
+    
+    if not args.before.exists():
+        print(f"❌ Error: Before path does not exist: {args.before}", file=sys.stderr)
+        sys.exit(1)
+    
+    if not args.after.exists():
+        print(f"❌ Error: After path does not exist: {args.after}", file=sys.stderr)
+        sys.exit(1)
+    
+    try:
+        before_analysis = analyze_skill(args.before)
+        after_analysis = analyze_skill(args.after)
+        report = compare_skills(before_analysis, after_analysis)
+        
+        if args.output:
+            args.output.write_text(report, encoding='utf-8')
+            print(f"✅ Report saved to: {args.output}")
+        else:
+            print(report)
+            
+    except Exception as e:
+        print(f"❌ Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()

package/.agent/skills/project-manager/scripts/encoding_utils.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+"""
+Cross-platform encoding utilities for Windows compatibility.
+
+Fixes UnicodeEncodeError on Windows by reconfiguring stdout/stderr to UTF-8
+and providing encoding-aware file I/O helpers.
+"""
+
+import sys
+from pathlib import Path
+
+
+def configure_utf8_console():
+    """
+    Reconfigure stdout/stderr for UTF-8 on Windows.
+
+    Windows uses cp1252 by default which cannot encode Unicode emojis.
+    This function switches to UTF-8 with 'replace' error handling to
+    prevent crashes on truly incompatible terminals.
+    """
+    if sys.platform == 'win32':
+        try:
+            sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+            sys.stderr.reconfigure(encoding='utf-8', errors='replace')
+        except AttributeError:
+            pass  # Python < 3.7
+
+
+def read_text_utf8(path: Path) -> str:
+    """Read file with explicit UTF-8 encoding."""
+    return path.read_text(encoding='utf-8')
+
+
+def write_text_utf8(path: Path, content: str) -> None:
+    """Write file with explicit UTF-8 encoding."""
+    path.write_text(content, encoding='utf-8')