ag-cortex 0.1.0

package/.agent/workflows/report-bug.md

@@ -0,0 +1,150 @@
+---
+name: report-bug
+description: Report a bug in the compound-engineering plugin
+argument-hint: "[optional: brief description of the bug]"
+---
+
+# Report a Compounding Engineering Plugin Bug
+
+Report bugs encountered while using the compound-engineering plugin. This command gathers structured information and creates a GitHub issue for the maintainer.
+
+## Step 1: Gather Bug Information
+
+Use the AskUserQuestion tool to collect the following information:
+
+**Question 1: Bug Category**
+- What type of issue are you experiencing?
+- Options: Agent not working, Command not working, Skill not working, MCP server issue, Installation problem, Other
+
+**Question 2: Specific Component**
+- Which specific component is affected?
+- Ask for the name of the agent, command, skill, or MCP server
+
+**Question 3: What Happened (Actual Behavior)**
+- Ask: "What happened when you used this component?"
+- Get a clear description of the actual behavior
+
+**Question 4: What Should Have Happened (Expected Behavior)**
+- Ask: "What did you expect to happen instead?"
+- Get a clear description of expected behavior
+
+**Question 5: Steps to Reproduce**
+- Ask: "What steps did you take before the bug occurred?"
+- Get reproduction steps
+
+**Question 6: Error Messages**
+- Ask: "Did you see any error messages? If so, please share them."
+- Capture any error output
+
+## Step 2: Collect Environment Information
+
+Automatically gather:
+```bash
+# Get plugin version
+cat ~/.antigravity/plugins/installed_plugins.json 2>/dev/null | grep -A5 "compound-engineering" | head -10 || echo "Plugin info not found"
+
+# Get Antigravity version
+antigravity --version 2>/dev/null || echo "Antigravity CLI version unknown"
+
+# Get OS info
+uname -a
+```
+
+## Step 3: Format the Bug Report
+
+Create a well-structured bug report with:
+
+```markdown
+## Bug Description
+
+**Component:** [Type] - [Name]
+**Summary:** [Brief description from argument or collected info]
+
+## Environment
+
+- **Plugin Version:** [from installed_plugins.json]
+- **Antigravity Version:** [from antigravity --version]
+- **OS:** [from uname]
+
+## What Happened
+
+[Actual behavior description]
+
+## Expected Behavior
+
+[Expected behavior description]
+
+## Steps to Reproduce
+
+1. [Step 1]
+2. [Step 2]
+3. [Step 3]
+
+## Error Messages
+
+```
+[Any error output]
+```
+
+## Additional Context
+
+[Any other relevant information]
+
+---
+*Reported via `/report-bug` command*
+```
+
+## Step 4: Create GitHub Issue
+
+Use the GitHub CLI to create the issue:
+
+```bash
+gh issue create \
+  --repo EveryInc/every-marketplace \
+  --title "[compound-engineering] Bug: [Brief description]" \
+  --body "[Formatted bug report from Step 3]" \
+  --label "bug,compound-engineering"
+```
+
+**Note:** If labels don't exist, create without labels:
+```bash
+gh issue create \
+  --repo EveryInc/every-marketplace \
+  --title "[compound-engineering] Bug: [Brief description]" \
+  --body "[Formatted bug report]"
+```
+
+## Step 5: Confirm Submission
+
+After the issue is created:
+1. Display the issue URL to the user
+2. Thank them for reporting the bug
+3. Let them know the maintainer (Kieran Klaassen) will be notified
+
+## Output Format
+
+```
+✅ Bug report submitted successfully!
+
+Issue: https://github.com/EveryInc/every-marketplace/issues/[NUMBER]
+Title: [compound-engineering] Bug: [description]
+
+Thank you for helping improve the compound-engineering plugin!
+The maintainer will review your report and respond as soon as possible.
+```
+
+## Error Handling
+
+- If `gh` CLI is not authenticated: Prompt user to run `gh auth login` first
+- If issue creation fails: Display the formatted report so user can manually create the issue
+- If required information is missing: Re-prompt for that specific field
+
+## Privacy Notice
+
+This command does NOT collect:
+- Personal information
+- API keys or credentials
+- Private code from your projects
+- File paths beyond basic OS info
+
+Only technical information about the bug is included in the report.

package/.agent/workflows/reproduce-bug.md

@@ -0,0 +1,99 @@
+---
+name: reproduce-bug
+description: Reproduce and investigate a bug using logs, console inspection, and browser screenshots
+argument-hint: "[GitHub issue number]"
+---
+
+# Reproduce Bug Command
+
+Look at github issue #$ARGUMENTS and read the issue description and comments.
+
+## Phase 1: Log Investigation
+
+Run the following agents in parallel to investigate the bug:
+
+1. Task rails-console-explorer(issue_description)
+2. Task appsignal-log-investigator(issue_description)
+
+Think about the places it could go wrong looking at the codebase. Look for logging output we can look for.
+
+Run the agents again to find any logs that could help us reproduce the bug.
+
+Keep running these agents until you have a good idea of what is going on.
+
+## Phase 2: Visual Reproduction with Playwright
+
+If the bug is UI-related or involves user flows, use Playwright to visually reproduce it:
+
+### Step 1: Verify Server is Running
+
+```
+mcp__plugin_compound-engineering_pw__browser_navigate({ url: "http://localhost:3000" })
+mcp__plugin_compound-engineering_pw__browser_snapshot({})
+```
+
+If server not running, inform user to start `bin/dev`.
+
+### Step 2: Navigate to Affected Area
+
+Based on the issue description, navigate to the relevant page:
+
+```
+mcp__plugin_compound-engineering_pw__browser_navigate({ url: "http://localhost:3000/[affected_route]" })
+mcp__plugin_compound-engineering_pw__browser_snapshot({})
+```
+
+### Step 3: Capture Screenshots
+
+Take screenshots at each step of reproducing the bug:
+
+```
+mcp__plugin_compound-engineering_pw__browser_take_screenshot({ filename: "bug-[issue]-step-1.png" })
+```
+
+### Step 4: Follow User Flow
+
+Reproduce the exact steps from the issue:
+
+1. **Read the issue's reproduction steps**
+2. **Execute each step using Playwright:**
+   - `browser_click` for clicking elements
+   - `browser_type` for filling forms
+   - `browser_snapshot` to see the current state
+   - `browser_take_screenshot` to capture evidence
+
+3. **Check for console errors:**
+   ```
+   mcp__plugin_compound-engineering_pw__browser_console_messages({ level: "error" })
+   ```
+
+### Step 5: Capture Bug State
+
+When you reproduce the bug:
+
+1. Take a screenshot of the bug state
+2. Capture console errors
+3. Document the exact steps that triggered it
+
+```
+mcp__plugin_compound-engineering_pw__browser_take_screenshot({ filename: "bug-[issue]-reproduced.png" })
+```
+
+## Phase 3: Document Findings
+
+**Reference Collection:**
+
+- [ ] Document all research findings with specific file paths (e.g., `app/services/example_service.rb:42`)
+- [ ] Include screenshots showing the bug reproduction
+- [ ] List console errors if any
+- [ ] Document the exact reproduction steps
+
+## Phase 4: Report Back
+
+Add a comment to the issue with:
+
+1. **Findings** - What you discovered about the cause
+2. **Reproduction Steps** - Exact steps to reproduce (verified)
+3. **Screenshots** - Visual evidence of the bug (upload captured screenshots)
+4. **Relevant Code** - File paths and line numbers
+5. **Suggested Fix** - If you have one

package/.agent/workflows/resolve-parallel.md

@@ -0,0 +1,34 @@
+---
+name: resolve_parallel
+description: Resolve all TODO comments using parallel processing
+argument-hint: "[optional: specific TODO pattern or file]"
+---
+
+Resolve all TODO comments using parallel processing.
+
+## Workflow
+
+### 1. Analyze
+
+Gather the things todo from above.
+
+### 2. Plan
+
+Create a TodoWrite list of all unresolved items grouped by type.Make sure to look at dependencies that might occur and prioritize the ones needed by others. For example, if you need to change a name, you must wait to do the others. Output a mermaid flow diagram showing how we can do this. Can we do everything in parallel? Do we need to do one first that leads to others in parallel? I'll put the to-dos in the mermaid diagram flow‑wise so the agent knows how to proceed in order.
+
+### 3. Implement (PARALLEL)
+
+Spawn a pr-comment-resolver agent for each unresolved item in parallel.
+
+So if there are 3 comments, it will spawn 3 pr-comment-resolver agents in parallel. liek this
+
+1. Task pr-comment-resolver(comment1)
+2. Task pr-comment-resolver(comment2)
+3. Task pr-comment-resolver(comment3)
+
+Always run all in parallel subagents/Tasks for each Todo item.
+
+### 4. Commit & Resolve
+
+- Commit changes
+- Push to remote

package/.agent/workflows/resolve-pr-parallel.md

@@ -0,0 +1,49 @@
+---
+name: resolve_pr_parallel
+description: Resolve all PR comments using parallel processing
+argument-hint: "[optional: PR number or current PR]"
+---
+
+Resolve all PR comments using parallel processing.
+
+Antigravity automatically detects and understands your git context:
+
+- Current branch detection
+- Associated PR context
+- All PR comments and review threads
+- Can work with any PR by specifying the PR number, or ask it.
+
+## Workflow
+
+### 1. Analyze
+
+Get all unresolved comments for PR
+
+```bash
+gh pr status
+bin/get-pr-comments PR_NUMBER
+```
+
+### 2. Plan
+
+Create a TodoWrite list of all unresolved items grouped by type.
+
+### 3. Implement (PARALLEL)
+
+Spawn a pr-comment-resolver agent for each unresolved item in parallel.
+
+So if there are 3 comments, it will spawn 3 pr-comment-resolver agents in parallel. liek this
+
+1. Task pr-comment-resolver(comment1)
+2. Task pr-comment-resolver(comment2)
+3. Task pr-comment-resolver(comment3)
+
+Always run all in parallel subagents/Tasks for each Todo item.
+
+### 4. Commit & Resolve
+
+- Commit changes
+- Run bin/resolve-pr-thread THREAD_ID_1
+- Push to remote
+
+Last, check bin/get-pr-comments PR_NUMBER again to see if all comments are resolved. They should be, if not, repeat the process from 1.

package/.agent/workflows/resolve-todo-parallel.md

@@ -0,0 +1,35 @@
+---
+name: resolve_todo_parallel
+description: Resolve all pending CLI todos using parallel processing
+argument-hint: "[optional: specific todo ID or pattern]"
+---
+
+Resolve all TODO comments using parallel processing.
+
+## Workflow
+
+### 1. Analyze
+
+Get all unresolved TODOs from the /todos/\*.md directory
+
+### 2. Plan
+
+Create a TodoWrite list of all unresolved items grouped by type.Make sure to look at dependencies that might occur and prioritize the ones needed by others. For example, if you need to change a name, you must wait to do the others. Output a mermaid flow diagram showing how we can do this. Can we do everything in parallel? Do we need to do one first that leads to others in parallel? I'll put the to-dos in the mermaid diagram flow‑wise so the agent knows how to proceed in order.
+
+### 3. Implement (PARALLEL)
+
+Spawn a pr-comment-resolver agent for each unresolved item in parallel.
+
+So if there are 3 comments, it will spawn 3 pr-comment-resolver agents in parallel. liek this
+
+1. Task pr-comment-resolver(comment1)
+2. Task pr-comment-resolver(comment2)
+3. Task pr-comment-resolver(comment3)
+
+Always run all in parallel subagents/Tasks for each Todo item.
+
+### 4. Commit & Resolve
+
+- Commit changes
+- Remove the TODO from the file, and mark it as resolved.
+- Push to remote

package/.agent/workflows/review-analysis.md

@@ -0,0 +1,145 @@
+---
+name: review-analysis
+description: "Internal sub-workflow for the Review Analysis phase. Executes deep agentic analysis."
+---
+
+# Review - Analysis Phase
+
+<review_target> #$ARGUMENTS </review_target>
+
+## Main Tasks
+
+### 1. Parallel Agent Analysis
+
+<thinking>
+Run ALL or most of these agents at the same time.
+</thinking>
+
+#### Parallel Review Agents:
+
+1. Task kieran-rails-reviewer(review_target)
+2. Task dhh-rails-reviewer(review_target)
+3. If turbo is used: Task rails-turbo-expert(review_target)
+4. Task git-history-analyzer(review_target)
+5. Task dependency-detective(review_target)
+6. Task pattern-recognition-specialist(review_target)
+7. Task architecture-strategist(review_target)
+8. Task code-philosopher(review_target)
+9. Task security-sentinel(review_target)
+10. Task performance-oracle(review_target)
+11. Task devops-harmony-analyst(review_target)
+12. Task data-integrity-guardian(review_target)
+13. Task agent-native-reviewer(review_target) - Verify new features are agent-accessible
+
+#### Conditional Agents (Run if applicable):
+
+These agents are run ONLY when the PR matches specific criteria. Check the PR files list to determine if they apply:
+
+**If PR contains database migrations (db/migrate/*.rb files) or data backfills:**
+
+14. Task data-migration-expert(review_target) - Validates ID mappings match production, checks for swapped values, verifies rollback safety
+15. Task deployment-verification-agent(review_target) - Creates Go/No-Go deployment checklist with SQL verification queries
+
+**When to run migration agents:**
+- PR includes files matching `db/migrate/*.rb`
+- PR modifies columns that store IDs, enums, or mappings
+- PR includes data backfill scripts or rake tasks
+- PR changes how data is read/written (e.g., changing from FK to string column)
+- PR title/body mentions: migration, backfill, data transformation, ID mapping
+
+**What these agents check:**
+- `data-migration-expert`: Verifies hard-coded mappings match production reality (prevents swapped IDs), checks for orphaned associations, validates dual-write patterns
+- `deployment-verification-agent`: Produces executable pre/post-deploy checklists with SQL queries, rollback procedures, and monitoring plans
+
+### 2. Ultra-Thinking Deep Dive Phases
+
+<ultrathink_instruction> For each phase below, spend maximum cognitive effort. Think step by step. Consider all angles. Question assumptions. And bring all reviews in a synthesis to the user.</ultrathink_instruction>
+
+<deliverable>
+Complete system context map with component interactions
+</deliverable>
+
+#### Phase 1: Stakeholder Perspective Analysis
+
+<thinking_prompt> ULTRA-THINK: Put yourself in each stakeholder's shoes. What matters to them? What are their pain points? </thinking_prompt>
+
+<stakeholder_perspectives>
+
+1. **Developer Perspective** <questions>
+   - How easy is this to understand and modify?
+   - Are the APIs intuitive?
+   - Is debugging straightforward?
+   - Can I test this easily? </questions>
+
+2. **Operations Perspective** <questions>
+   - How do I deploy this safely?
+   - What metrics and logs are available?
+   - How do I troubleshoot issues?
+   - What are the resource requirements? </questions>
+
+3. **End User Perspective** <questions>
+   - Is the feature intuitive?
+   - Are error messages helpful?
+   - Is performance acceptable?
+   - Does it solve my problem? </questions>
+
+4. **Security Team Perspective** <questions>
+   - What's the attack surface?
+   - Are there compliance requirements?
+   - How is data protected?
+   - What are the audit capabilities? </questions>
+
+5. **Business Perspective** <questions>
+   - What's the ROI?
+   - Are there legal/compliance risks?
+   - How does this affect time-to-market?
+   - What's the total cost of ownership? </questions>
+   
+</stakeholder_perspectives>
+
+#### Phase 2: Scenario Exploration
+
+<thinking_prompt> ULTRA-THINK: Explore edge cases and failure scenarios. What could go wrong? How does the system behave under stress? </thinking_prompt>
+
+<scenario_checklist>
+- [ ] **Happy Path**: Normal operation with valid inputs
+- [ ] **Invalid Inputs**: Null, empty, malformed data
+- [ ] **Boundary Conditions**: Min/max values, empty collections
+- [ ] **Concurrent Access**: Race conditions, deadlocks
+- [ ] **Scale Testing**: 10x, 100x, 1000x normal load
+- [ ] **Network Issues**: Timeouts, partial failures
+- [ ] **Resource Exhaustion**: Memory, disk, connections
+- [ ] **Security Attacks**: Injection, overflow, DoS
+- [ ] **Data Corruption**: Partial writes, inconsistency
+- [ ] **Cascading Failures**: Downstream service issues 
+</scenario_checklist>
+
+### 3. Multi-Angle Review Perspectives
+
+#### Technical Excellence Angle
+- Code craftsmanship evaluation
+- Engineering best practices
+- Technical documentation quality
+- Tooling and automation assessment
+
+#### Business Value Angle
+- Feature completeness validation
+- Performance impact on users
+- Cost-benefit analysis
+- Time-to-market considerations
+
+#### Risk Management Angle
+- Security risk assessment
+- Operational risk evaluation
+- Compliance risk verification
+- Technical debt accumulation
+
+#### Team Dynamics Angle
+- Code review etiquette
+- Knowledge sharing effectiveness
+- Collaboration patterns
+- Mentoring opportunities
+
+### 4. Simplification and Minimalism Review
+
+Run the Task code-simplicity-reviewer() to see if we can simplify the code.