agcel 1.0.4 → 2.0.0

package/.agent/workflows/mode.md

@@ -1,174 +0,0 @@
----
-description: Switch Mode
----
-
-# /mode
-
-## Purpose
-
-Switch between behavioral modes to optimize responses for different task types. Modes adjust communication style, output format, and problem-solving approach.
-
----
-
-Switch to the specified behavioral mode.
-
-## Available Modes
-
-| Mode | Description | Best For |
-|------|-------------|----------|
-| `default` | Balanced standard behavior | General tasks |
-| `brainstorm` | Creative exploration, more questions | Design, ideation |
-| `token-efficient` | Compressed, concise output | High-volume, cost savings |
-| `deep-research` | Thorough analysis, citations | Investigation, audits |
-| `implementation` | Code-focused, minimal prose | Executing plans |
-| `review` | Critical analysis, finding issues | Code review, QA |
-| `orchestration` | Multi-task coordination | Complex parallel work |
-
-## Mode Switching
-
-### Activate Mode
-```bash
-/mode [mode-name]
-```
-
-### Check Current Mode
-```bash
-/mode
-```
-(Shows current active mode)
-
-### Reset to Default
-```bash
-/mode default
-```
-
-## Mode Details
-
-### Default Mode
-- Standard balanced responses
-- Mix of explanation and code
-- Normal verification steps
-
-### Brainstorm Mode
-- Ask more clarifying questions
-- Present multiple alternatives
-- Explore trade-offs explicitly
-- Delay convergence on solutions
-
-### Token-Efficient Mode
-- Minimal explanations
-- Code-only responses where possible
-- Skip obvious context
-- 30-70% token savings
-
-### Deep-Research Mode
-- Thorough investigation
-- Evidence and citations
-- Confidence levels stated
-- Comprehensive analysis
-
-### Implementation Mode
-- Jump straight to code
-- Progress indicators
-- Minimal discussion
-- Execute don't deliberate
-
-### Review Mode
-- Look for issues first
-- Categorized findings
-- Severity levels
-- Actionable feedback
-
-### Orchestration Mode
-- Task breakdown
-- Parallel execution planning
-- Result aggregation
-- Coordination focus
-
-## Flags
-
-| Flag | Description |
-|------|-------------|
-| `--info` | Show detailed mode description |
-| `--list` | List all available modes |
-
-## Usage Examples
-
-```bash
-/mode brainstorm            # Switch to brainstorm mode
-/mode token-efficient       # Switch to efficient mode
-/mode                       # Show current mode
-/mode --list                # List all modes
-/mode default               # Reset to default
-```
-
-## Arguments
-
-$ARGUMENTS
-
-If mode name provided: switch to that mode
-If no arguments: show current mode
-If `--list`: show all modes
-
----
-
-## Mode Persistence
-
-- Modes persist for the session
-- Explicitly switch when task type changes
-- Mode affects all subsequent responses
-- Can be overridden per-command with flags
-
-## Command Flag Override
-
-Override mode for single command:
-```bash
-/feature --mode=implementation [desc]
-/review --mode=deep-research [file]
-/plan --mode=brainstorm [task]
-```
-
-## Recommended Workflows
-
-### Feature Development
-```
-/mode brainstorm           # Explore approaches
-[discuss design]
-/mode implementation       # Execute plan
-[write code]
-/mode review               # Check quality
-[review code]
-```
-
-### Bug Investigation
-```
-/mode deep-research        # Investigate thoroughly
-[analyze bug]
-/mode implementation       # Apply fix
-[fix bug]
-/mode default              # Return to normal
-```
-
-### Cost-Conscious Session
-```
-/mode token-efficient      # Set for session
-[work on multiple tasks]
-/mode default              # Reset when done
-```
-
-## Mode Files
-
-Mode definitions are in `.claude/modes/`:
-- `default.md`
-- `brainstorm.md`
-- `token-efficient.md`
-- `deep-research.md`
-- `implementation.md`
-- `review.md`
-- `orchestration.md`
-
-Customize modes by editing these files.
-
-
-## 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/optimize.md

@@ -1,57 +0,0 @@
----
-description: Performance Optimization
----
-
-# /optimize - Performance Optimization Command
-
-## Purpose
-
-Analyze and optimize code performance.
-
-## Usage
-
-```
-/optimize [file or function]
-```
-
----
-
-Optimize: **$ARGUMENTS**
-
-## Workflow
-
-1. **Analyze Current Performance**
-   - Identify bottlenecks
-   - Check complexity
-   - Profile if possible
-
-2. **Identify Opportunities**
-   - Algorithm improvements
-   - Caching opportunities
-   - Async optimizations
-
-3. **Implement Optimizations**
-   - Make targeted changes
-   - Verify improvements
-   - Ensure correctness
-
-## Output
-
-```markdown
-## Optimization Report
-
-### Before
-- Time complexity: O(n²)
-- Estimated time: 500ms
-
-### After
-- Time complexity: O(n log n)
-- Estimated time: 50ms
-
-### Changes Made
-- [Description of optimizations]
-```
-
-
-## 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/plan.md

@@ -1,341 +0,0 @@
----
-description: Task Planning
----
-
-# /plan - Task Planning Command
-
-## Purpose
-
-Create structured implementation plans with task breakdown, dependencies, and time estimates for complex work.
-
-## Usage
-
-```
-/plan [task description or feature request]
-```
-
-## Arguments
-
-- `$ARGUMENTS`: Description of the task, feature, or work to plan
-
----
-
-Create a detailed implementation plan for: **$ARGUMENTS**
-
-## Workflow
-
-### Phase 1: Understanding
-
-1. **Parse Requirements**
-   - Identify core functionality needed
-   - List explicit requirements
-   - Note implicit requirements
-   - Identify acceptance criteria
-
-2. **Clarify Ambiguities**
-   - Ask questions if unclear
-   - List assumptions made
-   - Note dependencies on decisions
-
-### Phase 2: Research
-
-1. **Explore Codebase**
-   - Find related implementations
-   - Identify patterns to follow
-   - Locate integration points
-   - Note conventions
-
-2. **Technical Research** (if needed)
-   - Research unfamiliar technologies
-   - Find best practices
-   - Identify potential pitfalls
-
-### Phase 3: Task Breakdown
-
-1. **Decompose Work**
-   - Break into atomic tasks
-   - Each task: 15-60 minutes
-   - Clear completion criteria
-
-2. **Order by Dependencies**
-   - What blocks what
-   - Parallel opportunities
-   - Critical path
-
-3. **Add Estimates**
-   - S: <30 min
-   - M: 30-60 min
-   - L: 1-2 hours
-   - XL: 2-4 hours
-
-### Phase 4: Documentation
-
-1. **Create Plan Document**
-   - Summary
-   - Task list
-   - Files to modify
-   - Risks
-
-2. **Track with TodoWrite**
-   - Add all tasks
-   - Set initial status
-
-## Output
-
-### Implementation Plan
-
-```markdown
-## Plan: [Feature/Task Name]
-
-### Summary
-[2-3 sentence overview of what will be built]
-
-### Scope
-
-**In Scope**
-- [What will be done]
-
-**Out of Scope**
-- [What won't be done]
-
-**Assumptions**
-- [Key assumptions made]
-
----
-
-### Tasks
-
-#### Phase 1: Setup [Total: Xh]
-| # | Task | Size | Depends On |
-|---|------|------|------------|
-| 1 | Create data model | M | - |
-| 2 | Set up database migration | S | 1 |
-| 3 | Add model tests | M | 1 |
-
-#### Phase 2: Core Implementation [Total: Xh]
-| # | Task | Size | Depends On |
-|---|------|------|------------|
-| 4 | Implement service layer | L | 1 |
-| 5 | Add business logic | M | 4 |
-| 6 | Write service tests | M | 5 |
-
-#### Phase 3: API Layer [Total: Xh]
-| # | Task | Size | Depends On |
-|---|------|------|------------|
-| 7 | Create API endpoints | M | 5 |
-| 8 | Add validation | S | 7 |
-| 9 | Write API tests | M | 8 |
-
-#### Phase 4: Integration [Total: Xh]
-| # | Task | Size | Depends On |
-|---|------|------|------------|
-| 10 | Integrate with frontend | M | 7 |
-| 11 | End-to-end testing | M | 10 |
-| 12 | Update documentation | S | 11 |
-
----
-
-### Files to Create/Modify
-
-**Create**
-- `src/models/feature.py` - Data model
-- `src/services/feature.py` - Business logic
-- `src/api/feature.py` - API endpoints
-- `tests/test_feature.py` - Tests
-
-**Modify**
-- `src/api/__init__.py` - Register routes
-- `docs/api.md` - API documentation
-
----
-
-### Dependencies
-
-**External**
-- [Package X] - For [purpose]
-
-**Internal**
-- Requires [existing feature] to be complete
-
----
-
-### Risks
-
-| Risk | Impact | Mitigation |
-|------|--------|------------|
-| [Risk 1] | High | [How to mitigate] |
-| [Risk 2] | Medium | [How to mitigate] |
-
----
-
-### Questions for Stakeholders
-1. [Question about requirement]
-2. [Question about edge case]
-
----
-
-### Success Criteria
-- [ ] All tasks completed
-- [ ] Tests passing with 80%+ coverage
-- [ ] API documentation updated
-- [ ] Code reviewed and approved
-```
-
-## Plan Templates
-
-### Feature Plan
-For new functionality
-
-### Bug Fix Plan
-For debugging and fixing issues
-
-### Refactor Plan
-For code improvements
-
-### Migration Plan
-For data or system migrations
-
-## Detailed Mode (Superpowers Methodology)
-
-Use `--detailed` flag for superpowers-style plans with 2-5 minute tasks:
-
-```
-/plan --detailed [task description]
-```
-
-### Detailed Mode Features
-
-**Reference**: `.claude/skills/methodology/writing-plans/SKILL.md`
-
-When `--detailed` is specified:
-- **Bite-sized tasks**: 2-5 minutes each (vs standard 15-60 min)
-- **Exact file paths**: Always include full paths
-- **Complete code samples**: Actual code, not descriptions
-- **TDD steps per task**: Write test → verify fail → implement → verify pass → commit
-- **Expected command outputs**: Specify what success looks like
-
-### Detailed Task Template
-
-```markdown
-## Task [N]: [Task Name]
-
-**Files**:
-- Create: `path/to/new-file.ts`
-- Modify: `path/to/existing-file.ts`
-- Test: `path/to/test-file.test.ts`
-
-**Steps**:
-
-1. Write failing test
-   ```typescript
-   // Exact test code
-   ```
-
-2. Verify test fails
-   ```bash
-   npm test -- --grep "test name"
-   # Expected: 1 failing
-   ```
-
-3. Implement minimally
-   ```typescript
-   // Exact implementation code
-   ```
-
-4. Verify test passes
-   ```bash
-   npm test -- --grep "test name"
-   # Expected: 1 passing
-   ```
-
-5. Commit
-   ```bash
-   git commit -m "feat: add [feature]"
-   ```
-```
-
-### Execution After Planning
-
-Use `/execute-plan [plan-file]` for subagent-driven execution with code review gates.
-
-**Reference**: `.claude/skills/methodology/executing-plans/SKILL.md`
-
-## Flags
-
-| Flag | Description | Example |
-|------|-------------|---------|
-| `--mode=[mode]` | Use specific behavioral mode | `--mode=brainstorm` |
-| `--detailed` | Use superpowers methodology (2-5 min tasks) | `--detailed` |
-| `--depth=[1-5]` | Planning thoroughness level | `--depth=4` |
-| `--format=[fmt]` | Output format (concise/detailed/json) | `--format=detailed` |
-| `--save=[path]` | Save plan to file | `--save=plans/auth.md` |
-| `--checkpoint` | Create checkpoint after planning | `--checkpoint` |
-
-### Flag Usage Examples
-
-```bash
-/plan --detailed "implement user authentication"
-/plan --mode=brainstorm "redesign checkout flow"
-/plan --depth=5 --save=plans/migration.md "database migration"
-/plan --format=json "api endpoint structure"
-```
-
-### Mode Recommendations
-
-| Mode | Best For |
-|------|----------|
-| `default` | Standard planning |
-| `brainstorm` | Exploratory planning, multiple approaches |
-| `deep-research` | Complex features needing investigation |
-| `implementation` | Quick plans for clear tasks |
-
-## MCP Integration
-
-This command leverages MCP servers for enhanced planning:
-
-### Reasoning - Structured Planning (Primary)
-```
-ALWAYS use Reasoning for task decomposition:
-- Break complex tasks into logical thought sequences
-- Track dependencies between steps
-- Revise plan as understanding deepens
-- Use for risk identification and mitigation planning
-```
-
-### Memory - Decision Persistence
-```
-Store and recall planning context:
-- Remember decisions from previous planning sessions
-- Recall user preferences for task sizing
-- Store architectural patterns for reuse
-- Create entities for major features/components
-```
-
-### Web Search - Technology Research
-```
-When planning involves unfamiliar technologies:
-- Fetch current documentation for accurate estimates
-- Understand API patterns before estimating complexity
-- Identify potential integration challenges
-```
-
-### Filesystem - Codebase Analysis
-```
-For accurate file identification:
-- Use list_dir to understand project structure
-- Use grep_search to find existing patterns
-- Identify files to create vs modify
-```
-
-<!-- CUSTOMIZATION POINT -->
-## Variations
-
-Modify behavior via CLAUDE.md:
-- Task size definitions (standard: 15-60 min, detailed: 2-5 min)
-- Required plan sections
-- Estimation approach
-- Risk assessment criteria
-
-
-## 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/pr.md

@@ -1,78 +0,0 @@
----
-description: Create Pull Request
----
-
-# /pr - Create Pull Request
-
-## Purpose
-
-Create a well-documented pull request with proper description and checks.
-
-## Usage
-
-```
-/pr [title or 'auto']
-```
-
----
-
-Create a pull request: **$ARGUMENTS**
-
-## Workflow
-
-### Step 1: Prepare Changes
-
-```bash
-git status
-git diff main...HEAD
-```
-
-### Step 2: Verify Ready
-
-- [ ] All tests passing
-- [ ] Code reviewed
-- [ ] No merge conflicts
-- [ ] Branch pushed
-
-### Step 3: Create PR
-
-```bash
-gh pr create --title "type(scope): description" --body "$(cat <<'EOF'
-## Summary
-- [Change 1]
-- [Change 2]
-
-## Test Plan
-- [ ] Unit tests
-- [ ] Manual testing
-
-## Screenshots
-[If applicable]
-
-## Checklist
-- [ ] Tests added/updated
-- [ ] Documentation updated
-- [ ] No breaking changes
-
-🤖 Generated with [Claude Code](https://claude.com/claude-code)
-EOF
-)"
-```
-
-## Output
-
-```markdown
-## Pull Request Created
-
-**URL**: https://github.com/org/repo/pull/123
-**Title**: feat(auth): add OAuth support
-**Base**: main ← feature/oauth
-
-### Changes
-- 5 files changed
-- +234 -12 lines
-```
-
-
-## 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/product-plan.md

@@ -1,36 +0,0 @@
----
-description: Ideation and Requirements Planning
----
-
-# /product-plan Workflow
-
-This workflow transforms a rough idea into a concrete product plan and requirements document.
-
-## Steps
-
-1.  **Brainstorming & Ideation**
-    - Use key: `brainstorming`
-    - Goal: Generate feature ideas, explore alternatives, and define the core value proposition.
-    - Output: A list of prioritized features and concepts.
-
-2.  **Feasibility Check**
-    - Use key: `senior-architect`
-    - Goal: Assess technical feasibility and high-level constraints.
-    - Output: Technical risk assessment.
-
-3.  **Requirements Definition**
-    - Use key: `product-manager` (New Skill)
-    - Goal: Write detailed User Stories and Acceptance Criteria.
-    - Output: A draft Product Requirements Document (PRD).
-
-4.  **Finalize Plan**
-    - Use key: `writing-plans`
-    - Goal: Synthesize all inputs into a final `PRD.md` artifact.
-    - Instruction: Create a file named `PRD.md` in the current directory with the full plan.
-
-## 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/production-deploy.md

@@ -1,39 +0,0 @@
----
-description: Production Deployment
----
-
-# /production-deploy Workflow
-
-This workflow prepares the application for production deployment.
-
-## Steps
-
-1.  **Containerization**
-    - Use key: `docker-expert`
-    - Goal: Create or optimize `Dockerfile` and `docker-compose.yml`.
-    - Output: Production-ready container configuration.
-
-2.  **Infrastructure as Code**
-    - Use key: `aws-serverless` / `vercel-deployment`
-    - Goal: Generate deployment configuration (Terraform, CDK, or Vercel/Netlify config).
-    - Instruction: Choose the provider based on user preference or project type.
-
-3.  **CI/CD Pipeline**
-    - Use key: `ci-cd-engineer`
-    - Goal: Create GitHub Actions or GitLab CI pipeline files.
-    - Output: `.github/workflows/deploy.yml` or equivalent.
-
-4.  **Pre-Flight Checks**
-    - Use key: `seo-audit`
-    - Goal: Check public-facing pages for SEO if applicable.
-
-5.  **Documentation**
-    - Use key: `security-documentation`
-    - Goal: Update `README.md` and security docs with deployment instructions.
-
-## 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.