agcel 1.0.4 → 2.0.0

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

@@ -1,63 +0,0 @@
----
-description: API Generation
----
-
-# /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

@@ -1,44 +0,0 @@
----
-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

@@ -1,227 +0,0 @@
----
-description: Interactive Brainstorming Session
----
-
-# /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

@@ -1,38 +0,0 @@
----
-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

@@ -1,55 +0,0 @@
----
-description: Changelog Generation
----
-
-# /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

@@ -1,142 +0,0 @@
----
-description: Create a Checkpoint
----
-
-# /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.