antigravity-ai-kit 2.1.0 → 3.0.1

package/.agent/workflows/create.md

@@ -1,75 +1,142 @@
----
-description: Create new features, components, or modules from scratch
----
-
-# /create Workflow
-
-> **Purpose**: Scaffold new features, components, or modules with best practices
-
----
-
-## Workflow Steps
-
-### 1. Clarify Requirements
-
-- What type of component/feature?
-- What framework/technology?
-- Any specific patterns to follow?
-
-### 2. Check Existing Patterns
-
-- Look for similar components in codebase
-- Identify established conventions
-- Reuse existing utilities and helpers
-
-### 3. Scaffold Structure
-
-```
-feature/
-├── components/       # UI components
-├── hooks/           # Custom hooks
-├── utils/           # Utility functions
-├── types/           # TypeScript types
-├── api/             # API calls
-├── __tests__/       # Tests
-└── index.ts         # Public exports
-```
-
-### 4. Implement Core Logic
-
-- Follow existing code patterns
-- Apply SOLID principles
-- Write self-documenting code
-
-### 5. Add Tests
-
-- Unit tests for utilities
-- Integration tests for components
-- E2E tests for critical flows
-
-### 6. Document
-
-- Add JSDoc comments
-- Update README if needed
-- Create usage examples
-
----
-
-## Checklist
-
-- [ ] Requirements clarified
-- [ ] Existing patterns reviewed
-- [ ] Structure scaffolded
-- [ ] Core logic implemented
-- [ ] Tests written
-- [ ] Documentation added
-
----
-
-## Examples
-
-```
-/create React component for user profile card
-/create NestJS module for authentication
-/create API endpoint for order processing
-```
+---
+description: Create new features, components, or modules from scratch.
+version: 2.1.0
+sdlc-phase: build
+skills: [app-builder, clean-code]
+commit-types: [feat]
+---
+
+# /create — Scaffold New Features
+
+> **Trigger**: `/create [description]`
+> **Lifecycle**: Build — after `/plan` approval
+
+> [!IMPORTANT]
+> This workflow creates new code. All scaffolded code MUST follow existing project patterns and conventions. No orphan code — everything must integrate with the existing architecture.
+
+> [!TIP]
+> This workflow leverages the **app-builder** skill. Read `.agent/skills/app-builder/SKILL.md` for extended guidance.
+
+---
+
+## Critical Rules
+
+1. **Follow existing patterns** — scan the codebase for conventions before writing anything
+2. **No orphan code** — every new file must be imported, referenced, or routed
+3. **Tests required** — every new feature must include appropriate tests
+4. **Stack-agnostic detection** — auto-detect the project type before scaffolding
+5. **User approval for major scaffolds** — present the plan before creating >5 files
+6. **Document public APIs** — add inline documentation for all exported functions/components
+
+---
+
+## Steps
+
+// turbo
+1. **Clarify Requirements**
+   - What type of component, feature, or module?
+   - What is the acceptance criteria?
+   - Any specific patterns, libraries, or constraints?
+
+// turbo
+2. **Detect Project Stack**
+   - Auto-detect the project type from config files (`package.json`, `pyproject.toml`, `Cargo.toml`, `go.mod`, etc.)
+   - Identify the framework, language, and conventions in use
+   - Determine the appropriate scaffold structure
+
+// turbo
+3. **Analyze Existing Patterns**
+   - Search for similar components/modules in the codebase
+   - Identify naming conventions, file structure, and import patterns
+   - Note relevant utilities, helpers, and shared modules to reuse
+
+4. **Present Scaffold Plan**
+   - Show the proposed file structure and integration points
+   - For major scaffolds (>5 files): present plan and wait for user approval
+   - For minor scaffolds: proceed with creation
+
+5. **Implement**
+   - Create files following detected project conventions
+   - Apply SOLID principles and project-specific patterns
+   - Wire up imports, routes, and exports
+
+6. **Add Tests**
+   - Unit tests for utilities and business logic
+   - Integration tests for component interactions
+   - E2E tests for critical user flows (when applicable)
+
+7. **Document**
+   - Add inline documentation (JSDoc, docstrings, etc.)
+   - Update relevant README or docs if the feature is user-facing
+   - Create usage examples if appropriate
+
+---
+
+## Output Template
+
+```markdown
+## 🏗️ Create: [Feature Name]
+
+### Stack Detected
+
+- **Language**: [language]
+- **Framework**: [framework]
+- **Conventions**: [detected patterns]
+
+### Files Created
+
+| File | Purpose |
+| :--- | :------ |
+| `path/to/file` | [description] |
+
+### Integration Points
+
+- [How new code connects to existing architecture]
+
+### Tests Added
+
+- [x] Unit tests: `path/to/tests`
+- [x] Integration tests: `path/to/tests`
+
+### Next Steps
+
+After creation: proceed to `/test` for full test suite or `/preview` for visual verification.
+```
+
+---
+
+## Governance
+
+**PROHIBITED:**
+- Creating files without checking existing patterns first
+- Scaffolding framework-specific code in a different-stack project
+- Leaving orphan files not connected to the project
+- Skipping tests for new features
+- Skipping failed steps · proceeding without resolution
+
+**REQUIRED:**
+- Stack detection before scaffolding
+- Pattern analysis before implementation
+- User approval for scaffolds creating >5 files
+- Test coverage for all new code
+- Integration with existing project architecture
+
+---
+
+## Completion Criteria
+
+- [ ] Project stack is detected and documented
+- [ ] Existing patterns are analyzed and followed
+- [ ] All files are created and integrated (no orphans)
+- [ ] Tests are written and passing
+- [ ] Documentation is added for public APIs
+- [ ] After creation: proceed to `/test` for validation or `/preview` for visual check
+
+---
+
+## Related Resources
+
+- **Previous**: `/plan` (implementation plan must exist for major features)
+- **Next**: `/test` (validate new code) · `/preview` (visual verification)
+- **Skill**: `.agent/skills/app-builder/SKILL.md`
+- **Related Skills**: `.agent/skills/clean-code/SKILL.md` · `.agent/skills/architecture/SKILL.md`

package/.agent/workflows/debug.md

@@ -1,98 +1,157 @@
----
-description: Systematic debugging workflow. Activates DEBUG mode for problem investigation.
----
-
-# /debug - Systematic Problem Investigation
-
-$ARGUMENTS
-
----
-
-## Purpose
-
-Activates DEBUG mode for systematic investigation of issues, errors, or unexpected behavior.
-
----
-
-## Behavior
-
-1. **Gather Information**
-   - Error message
-   - Reproduction steps
-   - Expected vs actual behavior
-   - Recent changes
-
-2. **Form Hypotheses**
-   - List possible causes
-   - Order by likelihood
-
-3. **Investigate Systematically**
-   - Test each hypothesis
-   - Check logs, data flow
-   - Use elimination method
-
-4. **Fix and Prevent**
-   - Apply fix
-   - Explain root cause
-   - Add prevention measures
-
----
-
-## Output Format
-
-```markdown
-## 🔍 Debug: [Issue]
-
-### 1. Symptom
-
-[What's happening]
-
-### 2. Information Gathered
-
-- Error: `[error message]`
-- File: `[filepath]`
-- Line: [line number]
-
-### 3. Hypotheses
-
-1. ❓ [Most likely cause]
-2. ❓ [Second possibility]
-3. ❓ [Less likely cause]
-
-### 4. Investigation
-
-**Testing hypothesis 1:**
-[What I checked] → [Result]
-
-### 5. Root Cause
-
-🎯 **[Explanation]**
-
-### 6. Fix
-
-[Code changes]
-
-### 7. Prevention
-
-🛡️ [How to prevent in future]
-```
-
----
-
-## Examples
-
-```
-/debug login not working
-/debug API returns 500
-/debug form doesn't submit
-/debug data not saving
-```
-
----
-
-## Key Principles
-
-- **Ask before assuming** — get full error context
-- **Test hypotheses** — don't guess randomly
-- **Explain why** — not just what to fix
-- **Prevent recurrence** — add tests, validation
+---
+description: Systematic debugging workflow. Activates DEBUG mode for problem investigation.
+version: 2.1.0
+sdlc-phase: reactive
+skills: [debugging-strategies]
+commit-types: [fix]
+---
+
+# /debug — Systematic Problem Investigation
+
+> **Trigger**: `/debug [issue description]`
+> **Lifecycle**: Reactive — any SDLC phase
+
+> [!CAUTION]
+> Debugging may involve production systems. Never apply untested fixes to production. Always identify and document the root cause before implementing changes.
+
+> [!TIP]
+> This workflow leverages the **debugging-strategies** skill. Read `.agent/skills/debugging-strategies/SKILL.md` for extended guidance.
+
+---
+
+## Critical Rules
+
+1. **Root cause required** — never apply a fix without understanding why the issue occurs
+2. **No guessing** — form hypotheses, test them systematically, eliminate possibilities
+3. **Prevention mandatory** — every fix must include measures to prevent recurrence
+4. **Preserve evidence** — capture error messages, logs, and reproduction steps before changing anything
+5. **Minimal changes** — fix only what's broken; avoid scope creep during debugging
+
+---
+
+## Argument Parsing
+
+| Command | Action |
+| :-------------------------- | :------------------------------------------- |
+| `/debug` | Prompt for issue description |
+| `/debug [issue]` | Investigate the specified issue directly |
+
+---
+
+## Steps
+
+// turbo
+1. **Gather Information**
+   - Capture the exact error message, stack trace, or unexpected behavior
+   - Document reproduction steps (reliable vs. intermittent)
+   - Note expected vs. actual behavior
+
+// turbo
+2. **Environment Diagnostics**
+   - Operating system and version
+   - Runtime versions (Node.js, Python, etc.)
+   - Recent git changes (`git log -5 --oneline`)
+   - Relevant environment variables and config
+   - Dependency versions (`package.json`, `pyproject.toml`, etc.)
+
+// turbo
+3. **Form Hypotheses**
+   - List 3+ possible causes, ordered by likelihood
+   - Consider: recent changes, dependency issues, environment differences, data edge cases
+
+// turbo
+4. **Investigate Systematically**
+   - Test each hypothesis in order of likelihood
+   - Check logs, data flow, network requests, and state
+   - Use elimination method — rule out causes definitively
+   - Document findings for each hypothesis tested
+
+5. **Apply Fix**
+   - Implement the minimal fix that addresses the root cause
+   - Verify the fix resolves the original issue
+   - Confirm no regressions are introduced
+
+6. **Prevent Recurrence**
+   - Add tests that would catch this issue
+   - Add validation, error handling, or guardrails as needed
+   - Document the root cause for future reference
+
+---
+
+## Output Template
+
+```markdown
+## 🔍 Debug: [Issue]
+
+### 1. Symptom
+
+[What's happening — error message, unexpected behavior]
+
+### 2. Environment
+
+- **OS**: [os]
+- **Runtime**: [runtime and version]
+- **Recent Changes**: [last 3 commits]
+
+### 3. Hypotheses
+
+1. ❓ [Most likely cause] — [why]
+2. ❓ [Second possibility] — [why]
+3. ❓ [Less likely cause] — [why]
+
+### 4. Investigation
+
+**Hypothesis 1:** [What I checked] → [Result: confirmed / eliminated]
+**Hypothesis 2:** [What I checked] → [Result]
+
+### 5. Root Cause
+
+🎯 **[Root cause explanation]**
+
+### 6. Fix Applied
+
+[Code changes with explanation]
+
+### 7. Prevention
+
+🛡️ [Tests added, validation added, documentation updated]
+
+After fix: proceed to `/test` for regression verification.
+```
+
+---
+
+## Governance
+
+**PROHIBITED:**
+- Applying fixes without identifying the root cause
+- Guessing randomly without structured hypothesis testing
+- Modifying production systems without rollback plan
+- Ignoring prevention measures after a fix
+- Skipping failed steps · proceeding without resolution
+
+**REQUIRED:**
+- Evidence-based hypothesis testing
+- Root cause documentation before any fix
+- Prevention measures (tests, validation, guardrails)
+- Regression verification after fix
+
+---
+
+## Completion Criteria
+
+- [ ] Error/issue is fully reproduced and documented
+- [ ] Environment diagnostics are captured
+- [ ] Root cause is identified with evidence
+- [ ] Fix is applied and verified
+- [ ] Prevention measures are implemented (tests, validation)
+- [ ] No regressions introduced
+- [ ] After fix: proceed to `/test` for full regression check
+
+---
+
+## Related Resources
+
+- **Next**: `/test` (regression verification after fix)
+- **Skill**: `.agent/skills/debugging-strategies/SKILL.md`
+- **Related Skills**: `.agent/skills/testing-patterns/SKILL.md`