agcel 1.0.1

package/.agent/workflows/api-gen.md

@@ -0,0 +1,59 @@
+# /api-gen - API Generation Command
+
+## Purpose
+
+Generate API endpoints, documentation, or client code from specifications.
+
+## Usage
+
+```
+/api-gen [resource name or OpenAPI spec path]
+```
+
+---
+
+Generate API for: **$ARGUMENTS**
+
+## Workflow
+
+### Step 1: Define Resource
+
+1. Identify resource properties
+2. Define relationships
+3. Determine operations
+
+### Step 2: Generate
+
+1. Create model/schema
+2. Create routes/endpoints
+3. Add validation
+4. Generate tests
+
+### Step 3: Document
+
+1. Create OpenAPI spec
+2. Add examples
+3. Document errors
+
+## Output
+
+```markdown
+## API Generated
+
+### Endpoints
+| Method | Path | Description |
+|--------|------|-------------|
+| GET | /resources | List all |
+| POST | /resources | Create |
+| GET | /resources/:id | Get one |
+
+### Files Created
+- `src/models/resource.ts`
+- `src/routes/resource.ts`
+- `tests/resource.test.ts`
+- `docs/api/resource.md`
+```
+
+
+## Gap Analysis Rule
+Always identify gaps and suggest next steps to users. In case there is no gaps anymore, then AI should clearly state that there is no gap left.

package/.agent/workflows/architect.md

@@ -0,0 +1,44 @@
+---
+description: System Architecture and Design
+---
+
+# /architect Workflow
+
+This workflow defines the technical architecture based on the PRD.
+
+## Prerequisites
+- A `PRD.md` file should exist or the user should provide detailed requirements.
+
+## Steps
+
+1.  **System Design**
+    - Use key: `senior-architect`
+    - Goal: Define system components, data flow, and technology choices.
+    - Output: High-level architecture description.
+
+2.  **Visual Context**
+    - Use key: `c4-context`
+    - Goal: Generate a C4 Context diagram to visualize system boundaries.
+    - Instruction: Use Mermaid.js syntax for diagrams.
+
+3.  **Database Design**
+    - Use key: `database-engineer` (New Skill)
+    - Goal: Design the database schema (ERD or JSON structure).
+    - Output: SQL schema or collection design.
+
+4.  **Security Review**
+    - Use key: `api-security-best-practices`
+    - Goal: Review the proposed architecture for potential security flaws early.
+    - Output: Security recommendations.
+
+5.  **Documentation**
+    - Use key: `architecture`
+    - Goal: Document the Architecture Decision Records (ADRs) and final design.
+    - Instruction: Create `ARCHITECTURE.md` with the full design.
+
+## Iron Rules
+1. If there is anything unclear, ask the user instead of inventing new stuff. Unless the user explicitly tells the AI to invent or suggest ideas.
+
+
+## Gap Analysis Rule
+Always identify gaps and suggest next steps to users. In case there is no gaps anymore, then AI should clearly state that there is no gap left.

package/.agent/workflows/brainstorm.md

@@ -0,0 +1,223 @@
+# /brainstorm - Interactive Design Session
+
+## Purpose
+
+Start an interactive brainstorming session using the one-question-at-a-time methodology. Refine rough ideas into fully-formed designs through collaborative dialogue.
+
+## Usage
+
+```
+/brainstorm [topic or feature to design]
+```
+
+## Arguments
+
+- `$ARGUMENTS`: The topic, feature, or problem to brainstorm about
+
+---
+
+Start interactive brainstorming session for: **$ARGUMENTS**
+
+## Methodology
+
+**Reference**: `.claude/skills/methodology/brainstorming/SKILL.md`
+
+This command uses the superpowers brainstorming methodology for optimal results.
+
+## Workflow
+
+### Phase 1: Understanding
+
+**Goal**: Clarify requirements through sequential questioning.
+
+**Rules**:
+1. Ask **ONE question per message**
+2. Wait for user response before next question
+3. Prefer **multiple-choice** over open-ended questions
+4. Break complex topics into multiple questions
+
+**Example interaction**:
+```
+Claude: "What type of authentication should we support?
+         a) Username/password only
+         b) OAuth providers (Google, GitHub)
+         c) Both options
+         d) Magic link (passwordless)"
+
+User: "b"
+
+Claude: "Which OAuth providers should we integrate?
+         a) Google only
+         b) GitHub only
+         c) Both Google and GitHub
+         d) Let me specify others..."
+```
+
+### Phase 2: Exploration
+
+**Goal**: Present alternatives with clear trade-offs.
+
+Present 2-3 approaches:
+- Lead with recommended option
+- Explain trade-offs for each
+- Let user choose direction
+
+```markdown
+## Approach 1: JWT-based (Recommended)
+- Stateless, scalable
+- Cons: Can't revoke instantly
+
+## Approach 2: Session-based
+- Easy revocation
+- Cons: Requires session store
+
+Which approach aligns better with your goals?
+```
+
+### Phase 3: Design Presentation
+
+**Goal**: Present validated design incrementally.
+
+**Rules**:
+- Break into **200-300 word sections**
+- Validate after each section
+- Cover: architecture, components, data flow, error handling, testing
+
+**Sections to present**:
+1. Architecture overview
+2. Component breakdown
+3. Data flow
+4. Error handling
+5. Testing considerations
+
+## Core Principles
+
+### YAGNI Ruthlessly
+
+Remove unnecessary features aggressively:
+- Question every "nice to have"
+- Start with minimal viable design
+- "We might need this later" = remove it
+
+### One Question at a Time
+
+Sequential questioning produces better results:
+- Gives user time to think deeply
+- Prevents overwhelming with choices
+- Creates natural conversation flow
+
+### Multiple-Choice Preference
+
+When possible, provide structured options:
+- Reduces cognitive load
+- Surfaces your understanding
+- Makes decisions concrete
+
+## Output
+
+After design is validated, create design document:
+
+```markdown
+# Design: [Feature Name]
+Date: [YYYY-MM-DD]
+
+## Summary
+[2-3 sentences]
+
+## Architecture
+[Architecture decisions]
+
+## Components
+[Component breakdown]
+
+## Data Flow
+[How data moves through system]
+
+## Error Handling
+[Error scenarios and handling]
+
+## Testing Strategy
+[Testing approach]
+
+## Open Questions
+[Any remaining unknowns]
+```
+
+## Next Steps After Brainstorming
+
+After design is complete:
+1. Commit design document to version control
+2. Use `/plan --detailed` for implementation planning
+3. Use `/execute-plan` for automated implementation
+
+## Flags
+
+| Flag | Description | Example |
+|------|-------------|---------|
+| `--mode=[mode]` | Use specific behavioral mode | `--mode=brainstorm` |
+| `--depth=[1-5]` | Exploration depth level | `--depth=4` |
+| `--format=[fmt]` | Output format (concise/detailed) | `--format=detailed` |
+| `--save=[path]` | Save design document to file | `--save=docs/design.md` |
+| `--quick` | Shorter session, fewer questions | `--quick` |
+| `--comprehensive` | Longer session, thorough exploration | `--comprehensive` |
+
+### Flag Usage Examples
+
+```bash
+/brainstorm --comprehensive "authentication system design"
+/brainstorm --save=docs/payment-design.md "payment integration"
+/brainstorm --quick "simple file upload feature"
+/brainstorm --depth=5 "microservices architecture"
+```
+
+### Session Depth
+
+| Level | Questions | Exploration |
+|-------|-----------|-------------|
+| 1 | 2-3 | Quick validation only |
+| 2 | 4-5 | Standard session |
+| 3 | 6-8 | Thorough exploration |
+| 4 | 8-10 | Comprehensive |
+| 5 | 10+ | Exhaustive, all angles |
+
+## MCP Integration
+
+This command leverages MCP servers for enhanced brainstorming:
+
+### Reasoning - Structured Exploration (Primary)
+```
+ALWAYS use Reasoning for brainstorming:
+- Explore design options systematically
+- Track pros/cons for each approach
+- Revise conclusions based on user feedback
+- Build confidence in final design incrementally
+```
+
+### Memory - Design Persistence
+```
+Store design decisions for continuity:
+- Create entities for design concepts
+- Store user preferences and constraints
+- Recall previous design patterns
+- Build knowledge graph of architecture decisions
+```
+
+### Web Search - Technology Options
+```
+When exploring technology choices:
+- Fetch current documentation for options
+- Compare library capabilities accurately
+- Understand trade-offs with real data
+```
+
+## When NOT to Use
+
+- Clear "mechanical" processes with known implementation
+- Simple bug fixes with obvious solutions
+- Tasks with explicit requirements already defined
+
+Use direct implementation instead.
+
+
+## Gap Analysis Rule
+Always identify gaps and suggest next steps to users. In case there is no gaps anymore, then AI should clearly state that there is no gap left.

package/.agent/workflows/build.md

@@ -0,0 +1,38 @@
+---
+description: Development and Implementation
+---
+
+# /build Workflow
+
+This workflow guides the implementation of features using best practices.
+
+## Trigger
+- User provides a specific feature to build (e.g., "Implement user login").
+
+## Steps
+
+1.  **Test-Driven Development**
+    - Use key: `test-driven-development`
+    - Goal: Write failing tests for the requested feature *before* implementation.
+    - Instruction: Create `*.test.ts` (or appropriate extension) files first.
+
+2.  **Implementation**
+    - Use key: `typescript-expert` (or `python-patterns` based on language)
+    - Goal: Implement the feature to pass the tests.
+    - Instruction: Follow SOLID principles and language-specific idioms.
+
+3.  **UI Implementation (If Frontend)**
+    - Use key: `react-patterns` / `ui-ux-designer`
+    - Goal: Ensure UI components are accessible and follow the design system.
+    - Instruction: Skip this step if backend-only.
+
+4.  **Refactoring**
+    - Use key: `secure-refactoring`
+    - Goal: Refactor the code for better readability and security after getting tests to pass (Green phase).
+
+## Iron Rules
+1. If there is anything unclear, ask the user instead of inventing new stuff. Unless the user explicitly tells the AI to invent or suggest ideas.
+
+
+## Gap Analysis Rule
+Always identify gaps and suggest next steps to users. In case there is no gaps anymore, then AI should clearly state that there is no gap left.

package/.agent/workflows/changelog.md

@@ -0,0 +1,51 @@
+# /changelog - Changelog Command
+
+## Purpose
+
+Generate changelog entries from recent commits.
+
+## Usage
+
+```
+/changelog [version or 'since:tag']
+```
+
+---
+
+Generate changelog for: **$ARGUMENTS**
+
+## Workflow
+
+1. **Analyze Commits**
+   ```bash
+   git log --oneline --since="last tag"
+   ```
+
+2. **Categorize**
+   - Added
+   - Changed
+   - Fixed
+   - Removed
+
+3. **Generate**
+   - User-friendly descriptions
+   - Link to PRs/issues
+
+## Output
+
+```markdown
+## [Version] - Date
+
+### Added
+- Feature description (#123)
+
+### Changed
+- Improvement description (#124)
+
+### Fixed
+- Bug fix description (#125)
+```
+
+
+## Gap Analysis Rule
+Always identify gaps and suggest next steps to users. In case there is no gaps anymore, then AI should clearly state that there is no gap left.

package/.agent/workflows/checkpoint.md

@@ -0,0 +1,138 @@
+# /checkpoint
+
+## Purpose
+
+Save and restore conversation context using git-based checkpoints. Enables session recovery and state preservation for complex, multi-session work.
+
+---
+
+Manage checkpoints for the current work session.
+
+## Checkpoint Operations
+
+### Save Checkpoint
+
+Create a checkpoint of current state:
+
+```bash
+/checkpoint save [name]
+```
+
+**Process:**
+1. Create git stash with descriptive message
+2. Record current context (files being worked on, task state)
+3. Save checkpoint metadata to `.claude/checkpoints/[name].json`
+
+**Metadata Format:**
+```json
+{
+  "name": "feature-auth",
+  "created": "2024-01-15T14:30:00Z",
+  "git_stash": "stash@{0}",
+  "files_in_context": ["src/auth/login.ts", "src/auth/token.ts"],
+  "current_task": "Implementing JWT refresh",
+  "notes": "User-provided notes"
+}
+```
+
+### List Checkpoints
+
+Show available checkpoints:
+
+```bash
+/checkpoint list
+```
+
+**Output:**
+```markdown
+## Available Checkpoints
+
+| Name | Created | Task | Stash |
+|------|---------|------|-------|
+| feature-auth | 2h ago | JWT refresh | stash@{0} |
+| bugfix-login | 1d ago | Login timeout | stash@{1} |
+```
+
+### Restore Checkpoint
+
+Restore a previous checkpoint:
+
+```bash
+/checkpoint restore [name]
+```
+
+**Process:**
+1. Apply git stash
+2. Load checkpoint metadata
+3. Summarize restored context
+4. Ready to continue work
+
+### Delete Checkpoint
+
+Remove a checkpoint:
+
+```bash
+/checkpoint delete [name]
+```
+
+## Flags
+
+| Flag | Description |
+|------|-------------|
+| `--notes="[text]"` | Add notes to checkpoint |
+| `--force` | Overwrite existing checkpoint |
+| `--include-uncommitted` | Include uncommitted changes |
+| `--dry-run` | Show what would be saved |
+
+## Usage Examples
+
+```bash
+/checkpoint save auth-progress              # Save current state
+/checkpoint save auth --notes="WIP tokens"  # Save with notes
+/checkpoint list                            # Show checkpoints
+/checkpoint restore auth-progress           # Restore state
+/checkpoint delete old-checkpoint           # Remove checkpoint
+```
+
+## Arguments
+
+$ARGUMENTS
+
+Parse the operation (save/list/restore/delete) and checkpoint name.
+
+---
+
+## Auto-Checkpoint
+
+For complex tasks, checkpoints are automatically suggested:
+- Before major refactoring
+- When switching contexts
+- Before risky operations
+- At natural breakpoints
+
+## Best Practices
+
+1. **Name Descriptively**: Use task-related names
+2. **Add Notes**: Future you will thank present you
+3. **Checkpoint Often**: Before context switches
+4. **Clean Up**: Delete obsolete checkpoints
+
+## Recovery Workflow
+
+When resuming work:
+```
+1. /checkpoint list              # See available states
+2. /checkpoint restore [name]    # Restore context
+3. Continue where you left off   # Context is loaded
+```
+
+## Limitations
+
+- Checkpoints use git stash (requires git repo)
+- Large uncommitted changes may be slow
+- Metadata stored in `.claude/checkpoints/`
+- Consider committing before checkpointing for safety
+
+
+## Gap Analysis Rule
+Always identify gaps and suggest next steps to users. In case there is no gaps anymore, then AI should clearly state that there is no gap left.