gsd-trae 1.0.0 → 1.0.2

package/refs/vbenchmark/.agent/workflows/gather-context.md

@@ -1,58 +0,0 @@
----
-description: Gather project context and codebase overview
----
-
-Gather Context $ARGUMENTS
-
-Understand the current state of the repository and recent changes.
-
-## Workflow
-
-1. **Understand what I need** - Ask me if unclear:
-   - Working tree changes (unstaged/staged)?
-   - Recent commits (how many)?
-   - Specific file/directory focus?
-   - General repository overview?
-   - Default: working tree + last 10 commits
-
-2. **Gather git information** - Run in parallel:
-   - `git status -s` for working tree state
-   - `git diff` for unstaged changes
-   - `git diff --staged` for staged changes
-   - `git log --oneline -n [N]` for recent commits
-   - `git diff HEAD~[N]..HEAD` for changes in last N commits
-
-3. **Analyze codebase** - Understand the code:
-   - If specific files/directories: spawn @codebase-explorer for structure and patterns
-   - If general overview: identify key directories, technologies, recent activity
-   - If unfamiliar tech found: spawn @researcher for context on tools and best practices
-
-4. **Synthesize context** - Organize findings:
-   - 📊 **REPOSITORY STATE** - Current branch, uncommitted changes, status
-   - 📝 **RECENT ACTIVITY** - Commits, themes, development patterns
-   - 📁 **KEY FILES** - Important files with file:line references
-   - 🎯 **FOCUS AREAS** - Recommended areas to explore
-   - ⚠️ **WARNINGS** - Conflicts, issues, or concerns
-
-5. **Present summary** - Show me:
-   - High-level overview of repository state
-   - Specific changes with file:line references
-   - Recent development activity and themes
-   - Recommendations for what to focus on
-   - Any warnings (uncommitted changes, merge conflicts, etc.)
-
-## Scope Options
-
-- **Working tree** - Current uncommitted changes
-- **Recent commits** - Last N commits (default: 10)
-- **General overview** - Project structure, technologies, architecture
-- **Focused analysis** - Deep dive into specific areas
-- **Combined** - Mix any of the above
-
-## Tips
-
-- Run git commands in parallel for efficiency
-- Spawn @codebase-explorer and @researcher in parallel when both needed
-- Focus on actionable insights, not raw data
-- Provide file:line references for easy navigation
-- Identify development themes from commit history

package/refs/vbenchmark/.agent/workflows/init.md

@@ -1,56 +0,0 @@
----
-description: Initialize AGENTS.md with project-specific guidance
----
-
-# Initialize AGENTS.md
-
-Analyze the codebase and create an AGENTS.md file with project-specific guidance for AI coding agents.
-
-**Injected into every agent prompt** - Make it concise but comprehensive. Include only what agents can't infer from code.
-
-## Process
-
-1. **Analyze codebase** - Examine: README (project overview, tech stack, commands, setup), config files (package.json, tsconfig.json, etc.), project structure (business logic, database schemas, API routing, applications, components), code organization patterns, testing setup, existing agent rules (.cursor/rules/, .cursorrules, .github/copilot-instructions.md)
-2. **Generate AGENTS.md** - Include: **Build/lint/test commands** (especially single test execution), **Project structure** (where to find business logic, schemas, routes, apps, components), **Code style** (imports, formatting, types, naming, error handling), **Key conventions**, **Safety constraints**, incorporate existing Cursor/Copilot rules if found
-3. **Write** - If AGENTS.md exists, improve it; otherwise create new; write to specified path (default: current directory)
-
-## Guidelines
-
-- Be specific, not generic - avoid vague phrases like "Follow best practices"
-- Exact commands with syntax, especially single test execution
-- Essential sections: Commands, Code Style, Conventions, Safety
-
-## Example Structure
-
-Analyze the project and generate appropriate content. Example format only:
-
-```markdown
-# AGENTS.md
-
-## Commands
-- Install: [dependency install command]
-- Test all: [test command]
-- Test single: [single test execution with path]
-- Lint: [linter command]
-
-## Project Structure
-- Business logic: [location of core business logic]
-- Database schemas: [location of schema definitions]
-- API routes: [location of API routing/endpoints]
-- Applications: [location of app entry points]
-- Components: [location of UI/shared components]
-- Tests: [location and organization of tests]
-
-## Code Style
-- [Language-specific style guidelines]
-- [Import/module patterns]
-- [Error handling patterns]
-
-## Conventions
-- [File organization patterns]
-- [Naming conventions]
-
-## Safety
-- Never execute shell commands with user input
-- Never use `sudo` without explicit permission
-```

package/refs/vbenchmark/.agent/workflows/preset-help.md

@@ -1,50 +0,0 @@
----
-description: Get help with project presets and configurations
----
-
-Explain this agentic development preset to me.
-
-## What to Cover
-
-### 1. The Orchestrator (@orchestrator)
-Explain the 5-step workflow:
-- **Understand** - Assess complexity, decide to ask or build
-- **Research** - Spawn subagents to gather context
-- **Plan** - Create plan, todos, surface unresolved questions
-- **Execute** - Work through tasks, delegate to specialists
-- **Complete** - Verify quality, all todos done
-
-### 2. Available Subagents
-Explain each and when to use:
-- **@codebase-explorer** - Find files, analyze implementations, trace data flow
-- **@researcher** - External docs, best practices, API references
-- **@implementer** - Focused code changes to single files
-- **@tester** - Write tests (TDD or verification mode)
-- **@debugger** - Deep error diagnosis, root cause analysis
-- **@reviewer** - Code review for correctness, security, performance
-- **@documenter** - READMEs, API docs, guides, changelogs
-
-### 3. Available Commands
-List each with brief description:
-- `/commit` - Commit with meaningful message
-- `/review` - Code review with automated checks
-- `/test` - Run or write tests
-- `/debug` - Diagnose errors
-- `/refactor` - Refactor with safety checks
-- `/research` - Research codebase and external docs
-- `/document` - Generate documentation
-- `/init` - Create AGENTS.md for the project
-- `/gather-context` - Repo state and recent changes
-
-### 4. How to Work With This Setup
-- Just describe what you need - the orchestrator handles delegation
-- Use slash commands for specific workflows
-- The agent tracks progress with todos
-- You control git - agent won't auto-commit
-
-### 5. Customization
-- `AGENTS.md` - Add project-specific rules
-- `.agent/agents/` - Modify subagent behavior
-- `.agent/commands/` - Add or edit commands
-
-Keep the explanation practical and concise. Focus on how to use it, not theory.

package/refs/vbenchmark/.agent/workflows/refactor.md

@@ -1,71 +0,0 @@
----
-description: Safe code refactoring with pattern preservation
----
-
-Refactor $ARGUMENTS
-
-Help me refactor code systematically with minimal risk.
-
-## Strategy
-
-Minimize risk through:
-- Small phases (change one thing at a time)
-- Continuous testing (validate after each phase)
-- Incremental migration (old and new coexist temporarily)
-- Type-driven (let compiler catch breaks)
-- Reversible (each phase can be rolled back)
-
-## Workflow
-
-1. **Analyze** - Understand the scope:
-   - Spawn @codebase-explorer to find affected files and dependencies
-   - Spawn @tester to identify test coverage gaps
-   - Map integration points and risks
-
-2. **Design strategy** - Create a phased plan:
-   - Break into incremental phases that can be validated independently
-   - Each phase should be reversible and build on previous phases
-   - Present the strategy to me with phase breakdown and effort estimates
-   - Get my confirmation before proceeding
-
-3. **Prepare tests** - Establish baseline:
-   - Spawn @tester in TDD mode to create characterization tests
-   - Ensure existing behavior is captured
-   - Run tests to establish baseline (proves refactor doesn't change behavior)
-
-4. **Execute phases** - For each phase:
-   - Implement changes (stay focused on one thing)
-   - Run tests (spawn @debugger if failing)
-   - Type check and fix immediately
-   - Manual validation
-   - Atomic commit with clear message
-   - Update me on progress
-   - If phase fails repeatedly: reassess, break into smaller phases, ask me
-
-5. **Cleanup** - Finalize the refactoring:
-   - Remove scaffolding and temporary code
-   - Final validation (all tests pass, types valid, no dead code)
-   - Spawn @reviewer for final check
-   - Document lessons learned
-
-6. **Report** - Summarize for me:
-   - What was refactored
-   - Phases completed
-   - Tests added/updated
-   - Issues encountered
-   - Follow-up recommendations
-
-## Validation Checklist
-
-**After each phase:**
-- [ ] All tests pass
-- [ ] Types valid
-- [ ] Manual testing done
-- [ ] Commit created
-
-**Before declaring complete:**
-- [ ] All phases done
-- [ ] Old code removed
-- [ ] Tests comprehensive
-- [ ] Documentation updated
-- [ ] Review completed

package/refs/vbenchmark/.agent/workflows/research.md

@@ -1,37 +0,0 @@
----
-description: Research external documentation and APIs
----
-
-Research $ARGUMENTS
-
-Help me research a topic using codebase analysis and external docs.
-
-## Workflow
-
-1. **Understand what I need** - Ask me:
-   - Internal codebase understanding?
-   - External documentation/best practices?
-   - Combination of the above?
-
-2. **Spawn subagents in parallel** - Always run concurrently for efficiency:
-   - Spawn @codebase-explorer to find files and analyze implementations
-   - Spawn @researcher for external docs, best practices, comparisons
-   - Wait for all to complete
-
-3. **Synthesize findings** - Combine and analyze:
-   - **Codebase**: How it works, file:line references, patterns, architectural decisions
-   - **External**: Key concepts, best practices, code examples, pitfalls, doc links
-   - **Combined**: Current state vs recommended approach, gap analysis, options with trade-offs
-
-4. **Present results** - Show me:
-   - High-level overview
-   - Detailed findings with specific references (file:line, doc URLs)
-   - Patterns and best practices
-   - Actionable recommendations
-
-## Tips
-
-- Always run subagents in parallel for maximum efficiency
-- Focus on synthesis, not raw data dump
-- Provide actionable recommendations
-- Note version-specific information

package/refs/vbenchmark/.agent/workflows/review.md

@@ -1,38 +0,0 @@
----
-description: Code review for correctness and best practices
----
-
-Review $ARGUMENTS
-
-Help me review code changes for quality, correctness, and best practices.
-
-## Workflow
-
-1. **Gather context** - Understand what changed:
-   - Run `git status` and `git diff` to see my changes
-   - Ask me what the purpose of these changes is
-
-2. **Run automated checks** - Execute in parallel:
-   - Run tests
-   - Run type checking
-   - Run linting
-
-3. **Manual review** - Deep inspection:
-   - Spawn @reviewer with full context (changes, test results, purpose)
-   - Focus on: correctness, security, performance, maintainability, architecture
-
-4. **Synthesize findings** - Organize by severity:
-   - 🔴 **CRITICAL** - Must fix (bugs, security, breaking changes)
-   - 🟡 **SUGGESTED** - Should fix (performance, maintainability)
-   - ℹ️ **NOTES** - Consider (style, minor improvements)
-
-5. **Provide verdict** - Give me clear recommendation:
-   - Approve
-   - Approve with notes
-   - Request changes
-
-For each issue, tell me:
-- Specific location (file:line)
-- What's wrong and why it matters
-- Suggested fix with example
-- Impact if not addressed

package/refs/vbenchmark/.agent/workflows/test.md

@@ -1,61 +0,0 @@
----
-description: Write tests for code coverage and edge cases
----
-
-Test $ARGUMENTS
-
-Help me write comprehensive tests for my code.
-
-## Workflow
-
-1. **Analyze** - Understand what to test:
-   - Spawn @codebase-explorer to find implementation files and test patterns
-   - Identify coverage gaps
-   - Ask me: TDD (tests before implementation) or Verification (tests for existing code)?
-
-2. **Plan strategy** - Prioritize test cases:
-   - Happy path → Edge cases → Error paths → Integration
-   - Focus on: core business logic, public APIs, error handling, security-critical code
-
-3. **Write tests** - Create comprehensive test suite:
-   - Spawn @tester with mode (TDD or Verification)
-   - Follow project conventions and framework patterns
-   - Use clear, descriptive test names (AAA pattern: Arrange, Act, Assert)
-
-4. **Execute** - Run and validate:
-   - Run tests
-   - Verify pass/fail matches expectations
-   - Check coverage
-
-5. **Iterate** - Improve coverage:
-   - If bugs found: spawn @debugger to fix
-   - Add missing test cases for edge cases
-   - Focus on critical paths
-
-## Test Priorities
-
-**Must test:**
-- Core business logic
-- Public APIs
-- Error handling
-- Security-critical code
-
-**Should test:**
-- Edge cases and boundaries
-- Integration points
-- Data transformations
-
-**Can skip:**
-- Trivial getters/setters
-- Framework code
-- Third-party libraries
-
-## Validation Checklist
-
-- [ ] All planned tests written
-- [ ] Tests follow project conventions
-- [ ] Clear, descriptive test names
-- [ ] Edge cases covered
-- [ ] Error paths tested
-- [ ] Tests pass (verification) or fail appropriately (TDD)
-- [ ] No flaky tests

package/refs/vbenchmark/.claude/commands/agentic-dev/apply.md

@@ -1,222 +0,0 @@
-# Apply Phase
-
-Execute implementation with TDD methodology. Supports Ralph Loop for unattended execution.
-
-**Arguments:** `$ARGUMENTS` (change-id)
-
-## Process
-
-```dot
-digraph apply_flow {
-    rankdir=TB;
-
-    subgraph cluster_init {
-        label="Initialization";
-        "1. Read change-id from args" [shape=box];
-        "2. Read proposal.md, design.md, tasks.md" [shape=box];
-        "3. Find next uncompleted task" [shape=box];
-    }
-
-    subgraph cluster_execute {
-        label="Per Task (TDD)";
-        "4. Write failing test" [shape=box];
-        "5. Run test, verify RED" [shape=box];
-        "6. Implement minimal code" [shape=box];
-        "7. Run test, verify GREEN" [shape=box];
-        "8. Commit changes" [shape=box];
-        "9. Update tasks.md: - [x]" [shape=box];
-    }
-
-    "More tasks?" [shape=diamond];
-    "10. Output IMPLEMENTATION COMPLETE" [shape=box];
-
-    "1. Read change-id from args" -> "2. Read proposal.md, design.md, tasks.md";
-    "2. Read proposal.md, design.md, tasks.md" -> "3. Find next uncompleted task";
-    "3. Find next uncompleted task" -> "4. Write failing test";
-    "4. Write failing test" -> "5. Run test, verify RED";
-    "5. Run test, verify RED" -> "6. Implement minimal code";
-    "6. Implement minimal code" -> "7. Run test, verify GREEN";
-    "7. Run test, verify GREEN" -> "8. Commit changes";
-    "8. Commit changes" -> "9. Update tasks.md: - [x]";
-    "9. Update tasks.md: - [x]" -> "More tasks?";
-    "More tasks?" -> "3. Find next uncompleted task" [label="yes"];
-    "More tasks?" -> "10. Output IMPLEMENTATION COMPLETE" [label="no"];
-}
-```
-
-## Self-Check Mechanism (Ralph Loop Support)
-
-**CRITICAL:** At the start of EVERY iteration, perform this check:
-
-```
-1. Read openspec/changes/<change-id>/tasks.md
-2. Parse all `- [ ]` items (uncompleted)
-3. Parse all `- [x]` items (completed)
-4. If NO uncompleted items exist:
-   -> Output: <promise>IMPLEMENTATION COMPLETE</promise>
-   -> STOP
-5. If uncompleted items exist:
-   -> Take the FIRST uncompleted item
-   -> Execute it following TDD
-   -> Update tasks.md
-   -> Continue
-```
-
-This mechanism allows Ralph Loop to:
-- Re-enter with same prompt
-- See previous work in tasks.md
-- Continue from where it left off
-- Stop automatically when done
-
-## Step 1: Get Change ID
-
-The change-id should be provided as argument:
-```
-/agentic-dev:apply add-shortcuts
-```
-
-If not provided, check for active changes:
-```bash
-openspec list
-```
-
-## Step 2: Read Proposal Files
-
-Read these files to understand context:
-```
-openspec/changes/<change-id>/
-├── proposal.md   # Why and what
-├── design.md     # Technical decisions (if exists)
-└── tasks.md      # Implementation checklist
-```
-
-## Step 3: Find Next Task
-
-Parse `tasks.md` and find first `- [ ]` item.
-
-Example tasks.md:
-```markdown
-## 1. Implementation
-
-### Task 1.1: Create shortcut service
-- [x] 1.1.1 Write failing test
-- [x] 1.1.2 Run test, verify failure
-- [ ] 1.1.3 Implement minimal code    <-- NEXT
-- [ ] 1.1.4 Run test, verify pass
-- [ ] 1.1.5 Commit
-```
-
-## Steps 4-8: TDD Execution
-
-### 4. Write Failing Test
-
-```typescript
-// Example: tests/shortcuts/shortcut-service.test.ts
-describe('ShortcutService', () => {
-  it('should register global shortcut', () => {
-    const service = new ShortcutService();
-    service.register('Ctrl+Space', callback);
-    expect(service.isRegistered('Ctrl+Space')).toBe(true);
-  });
-});
-```
-
-### 5. Run Test, Verify RED
-
-```bash
-npm test -- --grep "ShortcutService"
-# Expected: FAIL - ShortcutService is not defined
-```
-
-### 6. Implement Minimal Code
-
-Write only enough code to make the test pass. No extra features.
-
-### 7. Run Test, Verify GREEN
-
-```bash
-npm test -- --grep "ShortcutService"
-# Expected: PASS
-```
-
-### 8. Commit Changes
-
-```bash
-git add -A
-git commit -m "feat(shortcuts): add ShortcutService with register method"
-```
-
-## Step 9: Update tasks.md
-
-**IMMEDIATELY** after completing each step, update tasks.md:
-
-```markdown
-- [x] 1.1.3 Implement minimal code    <-- Changed from [ ] to [x]
-```
-
-This is critical for Ralph Loop to track progress.
-
-## Step 10: Update Documentation
-
-Update project documentation to reflect implementation progress:
-
-### README.md
-- Update "Active Changes" table: change status from "Proposed" to "Implementing" or "Implemented"
-- Add any new commands, tools, or features to relevant sections
-- Update architecture diagram if new components added
-
-### CLAUDE.md
-- Add any new slash commands or workflows
-- Update development instructions if process changed
-- Document any new integration patterns
-
-## Step 11: Complete
-
-When ALL tasks are marked `- [x]` and docs are updated:
-
-```
-<promise>IMPLEMENTATION COMPLETE</promise>
-```
-
-## Task Completion Output
-
-After each task step, output progress:
-
-```
-<promise>TASK 1.1.3 COMPLETE</promise>
-```
-
-This helps track granular progress in Ralph Loop.
-
-## Red Flags
-
-- Skipping tests (violates TDD)
-- Implementing before test fails
-- Forgetting to update tasks.md (breaks Ralph Loop)
-- Implementing extra features not in spec
-- Not committing after each task
-
-## Error Handling
-
-If a step fails:
-1. **Don't skip it** - fix the issue
-2. **Don't proceed** - task must pass before moving on
-3. **Document** - note the error in commit message if it required debugging
-
-If blocked:
-1. Output current progress
-2. Explain the blocker
-3. Ask for help (in manual mode) or retry (in Ralph Loop)
-
-## Subagent Mode (Optional)
-
-For complex tasks, can dispatch subagents per task:
-
-```
-Use superpowers:subagent-driven-development for:
-- Large tasks spanning multiple files
-- Tasks requiring spec review
-- Tasks needing code quality review
-```
-
-In simple cases, execute directly without subagents.