aiblueprint-cli 1.1.8 → 1.2.1

package/claude-code-config/commands/epct/tasks.md

@@ -1,206 +0,0 @@
----
-description: Task creation - divide plan into small, actionable task files
-argument-hint: <task-folder-path>
----
-
-You are a task breakdown specialist. Transform implementation plans into small, focused task files.
-
-**You need to ULTRA THINK about how to divide the work effectively.**
-
-## Workflow
-
-1. **VALIDATE INPUT**: Verify task folder is ready
-   - Check that `.claude/tasks/<task-folder>/` exists
-   - Verify `plan.md` file is present
-   - **CRITICAL**: If missing, instruct user to run `/epct:plan` first
-
-2. **READ PLAN**: Load implementation strategy
-   - Read `.claude/tasks/<task-folder>/plan.md` completely
-   - Identify all file changes and major implementation steps
-   - Look for natural boundaries between tasks
-
-3. **ULTRA THINK BREAKDOWN**: Plan task division strategy
-   - **CRITICAL**: Think through how to divide work logically
-   - Consider:
-     - Dependencies between changes
-     - Natural groupings (e.g., all auth-related changes)
-     - Size balance (avoid huge tasks or tiny tasks)
-     - Independent vs dependent work
-   - **GOAL**: Create small, focused tasks that can be completed in 1-2 hours
-
-4. **DIVIDE INTO TASKS**: Create task breakdown
-   - **Task size**: Small enough to be focused, large enough to be meaningful
-   - **Task scope**: Each task should have clear problem and solution
-   - **Dependencies**: Note what must be done before each task
-   - **NO CONCRETE STEPS**: Tasks describe WHAT and WHY, not HOW
-
-5. **CREATE TASK FILES**: Write individual task files
-   - Create `.claude/tasks/<task-folder>/tasks/` subdirectory
-   - Create numbered task files: `task-01.md`, `task-02.md`, etc.
-   - **CRITICAL**: Order tasks by dependencies (dependent tasks come after their prerequisites)
-   - **Structure for each task file**:
-     ```markdown
-     # Task: [Clear, concise task name]
-
-     ## Problem
-     [What needs to be solved or implemented]
-
-     ## Proposed Solution
-     [High-level approach - WHAT to do, not HOW]
-
-     ## Dependencies
-     - Task #N: [Description] (if applicable)
-     - External: [Any external dependencies like API docs]
-
-     ## Context
-     [Brief relevant information from exploration/plan]
-     - Key files: `path/to/file.ts:line`
-     - Patterns to follow: [Reference to similar code]
-
-     ## Success Criteria
-     - [What does "done" look like]
-     - [Tests that should pass]
-     ```
-
-6. **CREATE INDEX**: Generate tasks overview
-   - Create `.claude/tasks/<task-folder>/tasks/index.md`
-   - List all tasks with status tracking
-   - **Structure**:
-     ```markdown
-     # Tasks: [Task Folder Name]
-
-     ## Overview
-     [Brief description of the overall goal]
-
-     ## Task List
-
-     - [ ] **Task 1**: [Name] - `task-01.md`
-     - [ ] **Task 2**: [Name] - `task-02.md` (depends on Task 1)
-     - [ ] **Task 3**: [Name] - `task-03.md`
-
-     ## Execution Order
-     1. Tasks 1 and 3 can be done in parallel
-     2. Task 2 requires Task 1 to be completed first
-     ```
-
-7. **VERIFY QUALITY**: Check task breakdown
-   - **All work covered**: Nothing from plan is missing
-   - **Logical order**: Dependencies are respected
-   - **Right size**: Tasks are small but meaningful
-   - **Clear**: Each task is understandable standalone
-   - **No HOW**: Tasks don't prescribe implementation details
-
-8. **REPORT**: Summarize to user
-   - Confirm number of tasks created
-   - Show task list with dependencies
-   - Highlight which tasks can be done in parallel
-   - Suggest starting with tasks that have no dependencies
-
-## Task Quality Guidelines
-
-### Good Task Example
-```markdown
-# Task: Add JWT Token Validation Middleware
-
-## Problem
-We need to protect API routes by validating JWT tokens in incoming requests. Currently, routes are unprotected.
-
-## Proposed Solution
-Create middleware that extracts JWT from Authorization header, validates signature and expiration, and attaches user info to request context.
-
-## Dependencies
-- None (can start immediately)
-
-## Context
-- Similar pattern exists in `src/api/auth.ts:45-67`
-- Use jsonwebtoken library (already in dependencies)
-- Follow error handling pattern from `src/middleware/error.ts`
-
-## Success Criteria
-- Middleware rejects invalid/expired tokens with 401
-- Valid tokens attach user info to request
-- Unit tests pass for valid/invalid/expired tokens
-```
-
-### Bad Task Example
-```markdown
-# Task: Fix authentication
-
-## Problem
-Auth doesn't work
-
-## Proposed Solution
-Make it work
-
-## Dependencies
-None
-
-## Context
-In the auth files
-
-## Success Criteria
-Works
-```
-
-## Task File Rules
-
-### What to Include
-- **Clear problem statement**: What needs to be solved
-- **High-level solution**: WHAT to build, not HOW
-- **Dependencies**: What must be done first
-- **Context**: Relevant files and patterns
-- **Success criteria**: How to know when done
-
-### What to AVOID
-- **Concrete implementation steps**: No step-by-step instructions
-- **Code snippets**: No actual code in task files
-- **Technical details**: Just enough to understand, not to implement
-- **Huge tasks**: If >2 hours of work, split further
-
-## Size Guidelines
-
-### Too Small (avoid)
-- "Add import statement to file X"
-- "Rename variable Y to Z"
-- Single line changes
-
-### Too Large (split up)
-- "Implement entire authentication system"
-- "Build user dashboard with all features"
-- Tasks that touch >10 files
-
-### Just Right
-- "Add token validation middleware"
-- "Create user profile API endpoint"
-- "Implement password reset flow"
-
-## Dependency Management
-
-### Independent Tasks (can be parallel)
-- Different features
-- Different parts of codebase
-- Different layers (frontend/backend)
-
-### Dependent Tasks (must be sequential)
-- Task B uses code from Task A
-- Task B tests functionality from Task A
-- Task B extends/modifies Task A's work
-
-**CRITICAL**: Order tasks so dependencies come first
-
-## Execution Rules
-
-- **SMALL AND FOCUSED**: Each task should be completable in 1-2 hours
-- **TEXT ONLY**: Simple markdown, easy to read
-- **NO IMPLEMENTATION**: Describe WHAT and WHY, never HOW
-- **LOGICAL ORDER**: Respect dependencies in numbering
-- **CLEAR CONTEXT**: Reference exploration findings
-- **TESTABLE**: Clear success criteria
-
-## Priority
-
-Clarity and Independence > Completeness. Small, clear, independent tasks beat comprehensive but complex ones.
-
----
-
-User: $ARGUMENTS

package/claude-code-config/commands/explain-architecture.md

@@ -1,113 +0,0 @@
----
-description: Analyze and explain architectural patterns, design patterns, and structural decisions in the codebase
-allowed-tools: Read, Glob, Grep, Task
----
-
-You are an architecture analyst. Identify and explain the "why" behind code organization and design choices.
-
-## Workflow
-
-1. **EXPLORE STRUCTURE**: Map the codebase organization
-   - Use `Glob` to find key directories (`**/*.{js,ts,py,java,go}`)
-   - Identify entry points with `Grep` for main/index files
-   - Read configuration files (package.json, pom.xml, etc.)
-   - **CRITICAL**: Don't assume patterns - verify with actual code
-
-2. **IDENTIFY PATTERNS**: Recognize architectural decisions
-   - Search for pattern indicators (`Controller`, `Service`, `Repository`, `Factory`)
-   - Check folder naming conventions (models/, views/, controllers/)
-   - Examine dependency flow between modules
-   - **FOCUS**: Look for consistency across the codebase
-
-3. **ANALYZE IMPLEMENTATION**: Deep dive into pattern usage
-   - Read 2-3 representative files from each architectural layer
-   - Trace data flow through a typical request
-   - Check for separation of concerns
-   - **VERIFY**: Confirm patterns with concrete code examples
-
-4. **DOCUMENT FINDINGS**: Create comprehensive analysis
-   - Start with high-level architecture overview
-   - Detail each pattern with code examples
-   - Create ASCII diagrams for relationships
-   - **STAY IN SCOPE**: Only explain what exists, don't suggest changes
-
-## Execution Rules
-
-- **MUST**: Use actual code examples from the codebase
-- **NEVER**: Assume standard implementations without verification
-- **MUST**: Create visual representations (ASCII diagrams)
-- **CRITICAL**: Explain trade-offs objectively
-- Search broadly first, then focus on specific patterns
-
-## Pattern Detection
-
-### Quick Indicators
-- **MVC**: `/controllers`, `/models`, `/views` directories
-- **Clean Architecture**: `/domain`, `/application`, `/infrastructure`
-- **Microservices**: Multiple service directories with own dependencies
-- **Repository Pattern**: Classes ending in `Repository` or `Repo`
-- **Factory Pattern**: Classes with `create` or `make` methods
-- **Observer Pattern**: `subscribe`, `emit`, `listener` methods
-
-### Analysis Output Format
-
-```markdown
-## Architecture Analysis: [Project Name]
-
-### Overview
-[2-3 sentences describing the overall architecture]
-
-### Primary Patterns Identified
-
-#### 1. [Pattern Name]
-**What it is**: Brief explanation
-**Where it's used**: Specific locations in codebase
-**Why it's used**: Benefits in this context
-
-**Example**:
-```language
-// Code example showing the pattern
-```
-
-**Diagram**:
-```
-┌─────────────┐     ┌─────────────┐
-│   Component │────▶│   Service   │
-└─────────────┘     └─────────────┘
-```
-
-### Architecture Characteristics
-
-#### Strengths
-- [Strength 1]: How it benefits the project
-- [Strength 2]: Specific advantages
-
-#### Trade-offs
-- [Trade-off 1]: What was sacrificed
-- [Trade-off 2]: Complexity added
-
-### Implementation Details
-
-#### File Structure
-```
-src/
-├── controllers/    # MVC Controllers
-├── models/        # Data models
-├── views/         # View templates
-└── services/      # Business logic
-```
-
-#### Key Relationships
-- How components interact
-- Dependency flow
-- Communication patterns
-
-### Recommendations
-- Patterns that could enhance current architecture
-- Potential improvements
-- Consistency suggestions
-```
-
-## Priority
-
-Pattern recognition > Theoretical knowledge. Show what IS, not what COULD BE.

package/claude-code-config/commands/melvynx-plugin.md

@@ -1 +0,0 @@
-Dit "Bonjour youtube"

package/claude-code-config/commands/prompt-agent.md

@@ -1,126 +0,0 @@
----
-allowed-tools: Read, Write, Edit, MultiEdit
-argument-hint: <action> <name> - e.g., "create explore-api", "refactor @agents/websearch.md"
-description: Create and optimize agent prompts with agent-specific patterns
----
-
-You are an agent prompt specialist. Create focused, efficient agent prompts.
-
-## Workflow
-
-1. **PARSE ARGUMENTS**: Determine action type
-   - `create <name>`: New agent from template
-   - `refactor @path`: Enhance existing agent
-   - `update @path`: Modify specific sections
-
-2. **APPLY AGENT TEMPLATE**: Use standard structure
-   - Agents use **section headers** not numbered workflows
-   - Focus on search/analysis/output patterns
-   - Keep agents specialized and focused
-
-3. **WRITE/UPDATE FILE**: Save to agents/ directory
-   - New agents: `agents/<name>.md`
-   - Updates: Preserve all existing content
-
-## Agent Template
-
-```markdown
----
-name: [kebab-case-name]
-description: [One-line capability statement - when to use this agent]
-color: [yellow|blue|green|red]
----
-
-You are a [specific specialist role]. [Core purpose in one sentence].
-
-## [Primary Action Phase]
-
-[Direct instructions for main task]
-- Use `Tool` for specific purposes
-- Pattern to follow for searches
-- What to gather or analyze
-
-## [Secondary Phase if needed]
-
-[Additional processing steps]
-- How to process results
-- Validation or verification steps
-
-## Output Format
-
-[Exactly how to structure the response]
-```
-- Use specific examples when helpful
-- Keep format minimal and scannable
-```
-
-## Execution Rules
-
-- [Critical constraints]
-- [Performance guidelines]
-- [Scope limitations]
-
-## Priority
-
-[Primary goal] > [Secondary]. [One-line focus statement].
-```
-
-## Agent Patterns by Type
-
-### Search/Exploration Agents
-```markdown
-## Search Strategy
-1. Start broad with parallel searches
-2. Read files for full context
-3. Follow connections
-
-## Output Format
-### Found Items
-- Path: /file/location
-- Purpose: [why relevant]
-- Key sections: [what matters]
-```
-
-### Modification Agents (like Snipper)
-```markdown
-## Workflow
-1. **Read**: Load target files
-2. **Edit**: Apply changes
-3. **Report**: List modifications
-
-## Output Format
-- file.ext: [change made]
-```
-
-### Analysis Agents
-```markdown
-## Analysis Process
-- Gather data from X
-- Compare against Y
-- Identify patterns
-
-## Output Format
-### Findings
-[Structured results]
-
-### Recommendations
-[Action items]
-```
-
-## Execution Rules
-
-- **Agents are stateless** - include all context needed
-- **Keep focused** - one clear purpose per agent
-- **Minimize output** - agents should be fast
-- **Use parallel tools** when possible for speed
-- **NO verbose explanations** in agent output
-
-## Common Metadata
-
-- **name**: Always kebab-case (explore-codebase, fix-tests)
-- **description**: Start with "Use this agent when..." or clear trigger
-- **color**: yellow (search), blue (modify), green (analyze), red (critical)
-
-## Priority
-
-Clarity > Features. Keep agents simple and fast.

package/claude-code-config/commands/prompt-command.md

@@ -1,225 +0,0 @@
----
-allowed-tools: Read, Write, Edit, MultiEdit
-argument-hint: <action> <name> - e.g., "create deploy", "refactor @commands/commit.md"
-description: Create and optimize command prompts with command-specific patterns
----
-
-You are a command prompt specialist. Create actionable command prompts that match existing patterns.
-
-## Workflow
-
-1. **PARSE ARGUMENTS**: Determine action type
-   - `create <name>`: New command from template
-   - `refactor @path`: Enhance existing command
-   - `update @path`: Modify specific sections
-
-2. **CHOOSE PATTERN**: Select appropriate format
-   - **Numbered workflow** for process-heavy commands (EPCT, commit, CI)
-   - **Reference/docs** for CLI wrapper commands (neon-cli, vercel-cli)
-   - **Simple sections** for analysis commands (deep-code-analysis)
-
-3. **WRITE/UPDATE FILE**: Save to commands/ directory
-   - New commands: `commands/<name>.md`
-   - Updates: Preserve all existing content and structure
-
-## Command Patterns
-
-### Pattern 1: Numbered Workflow (for processes)
-**Use for**: Multi-step processes, git operations, CI monitoring, EPCT methodology
-
-```markdown
----
-description: [One-line purpose]
-allowed-tools: [Specific tools]
----
-
-You are a [role]. [Mission statement].
-
-## Workflow
-
-1. **ACTION NAME**: Brief description
-   - Specific step with `exact command`
-   - **CRITICAL**: Important constraint
-
-2. **NEXT PHASE**: What happens next
-   - Continue with actions
-   - **STAY IN SCOPE**: Boundaries
-
-## Execution Rules
-- **NON-NEGOTIABLE**: Critical rules
-- Other guidelines
-
-## Priority
-[Focus statement].
-```
-
-### Pattern 2: Reference/Docs Format (for CLI tools)
-**Use for**: CLI wrappers, command reference, documentation commands
-
-```markdown
----
-allowed-tools: Bash(<cli> *)
-description: [CLI tool] commands for [purpose]
----
-
-# [Tool Name] CLI Commands
-
-## [Category 1]
-\```bash
-# Comment explaining command
-tool command --flag
-
-# Another example
-tool other-command <arg>
-\```
-
-## [Category 2]
-\```bash
-# More commands grouped by function
-\```
-
-## Common Workflows
-
-### [Workflow Name]
-\```bash
-# Step-by-step example
-# 1. First command
-tool setup
-
-# 2. Main action  
-tool action --flag
-\```
-```
-
-### Pattern 3: Section-Based Analysis (for research/analysis)
-**Use for**: Analysis commands, research tasks, investigation workflows
-
-```markdown
----
-description: [Analysis purpose]
-allowed-tools: [Research tools]
----
-
-You are a [analyst role]. [Purpose statement].
-
-## [Phase Name]
-
-**Goal**: [What this achieves]
-
-- Action items
-- **CRITICAL**: Constraints
-- Use `specific tools`
-
-## [Another Phase]
-
-[Similar structure]
-
-## Execution Rules
-- Guidelines and constraints
-```
-
-## Command Patterns by Type
-
-### Git Operations (commit, PR)
-```markdown
-## Workflow
-1. **STAGE**: Prepare changes
-   - `git add -A` or selective staging
-   - `git status` to verify
-
-2. **COMMIT**: Create commit
-   - Generate message following convention
-   - `git commit -m "type: description"`
-
-3. **PUSH**: Submit changes
-   - `git push` to remote
-   - Verify with `gh pr view`
-```
-
-### CI/Build Commands
-```markdown
-## Workflow
-1. **WAIT**: Initial delay if needed
-   - `sleep 30` for CI to start
-   
-2. **MONITOR**: Watch status
-   - `gh run list` to find runs
-   - `gh run watch <id>` to monitor
-
-3. **ON FAILURE**: Fix and retry
-   - Get logs with `gh run view --log-failed`
-   - Fix issues and push
-   - Loop back (max attempts)
-```
-
-### Task Execution (EPCT pattern)
-```markdown
-## Workflow
-1. **EXPLORE**: Gather information
-   - Search with parallel agents
-   - Find relevant files
-
-2. **PLAN**: Create strategy
-   - Document approach
-   - Post plan as comment if GitHub issue
-
-3. **CODE**: Implement changes
-   - Follow existing patterns
-   - Stay in scope
-
-4. **TEST**: Verify changes
-   - Run relevant tests only
-   - Check lint and types
-```
-
-### CLI Wrapper Commands
-```markdown
-## Workflow
-1. **PARSE**: Get arguments from $ARGUMENTS
-   - Validate input format
-   - Extract parameters
-
-2. **EXECUTE**: Run CLI command
-   - `cli-tool command --flags`
-   - Handle output
-
-3. **REPORT**: Show results
-   - Parse and format output
-   - Highlight important info
-```
-
-## Metadata Guidelines
-
-### allowed-tools
-- **Git commands**: `Bash(git :*)`
-- **GitHub CLI**: `Bash(gh :*)`
-- **Specific CLI**: `Bash(npm :*)`, `Bash(vercel :*)`
-- **File operations**: `Read, Edit, MultiEdit, Write`
-- **Other**: `Task`, `WebFetch`, etc.
-
-### argument-hint
-Only include if command takes arguments:
-- `<file-path>` - single file input
-- `<issue-number|issue-url>` - multiple input types
-- `<action> <target>` - multi-part arguments
-- Skip for simple commands like `commit`
-
-## Emphasis Patterns
-
-- **CRITICAL/MUST/NEVER**: Non-negotiable rules
-- **STAY IN SCOPE**: Prevent feature creep
-- **BEFORE [action]**: Prerequisites
-- **NON-NEGOTIABLE**: Absolute requirements
-- **STOP**: Halt conditions
-
-## Execution Rules
-
-- **Commands are stateful** - can reference previous steps
-- **Use numbered workflows** for clear sequence
-- **Include exact commands** not abstractions
-- **Add verification steps** after actions
-- **Define failure behavior** (retry, stop, ask)
-
-## Priority
-
-Actionability > Completeness. Make every step executable.

package/claude-code-config/scripts/statusline/data/.gitignore

@@ -1,5 +0,0 @@
-# Ignore all data and cache files
-*.json
-
-# But keep this .gitignore
-!.gitignore

package/claude-code-config/scripts/statusline/src/commands/CLAUDE.md

@@ -1,3 +0,0 @@
-Important :
-
-This folder only include command that we can run using `/Users/melvynx/.claude/scripts/statusline/package.json` commands. Please don't write anything else here.