blockmine 1.23.4 → 1.25.0

package/.claude/commands/cost-analysis.md

@@ -1,315 +0,0 @@
----
-description: Infrastructure cost analysis, optimization recommendations, action plan
-argument-hint: Optional - specific service or time period (e.g., "last month AWS costs", "Kubernetes cluster", "production environment")
----
-
-Perform infrastructure cost analysis and provide optimization recommendations for: $ARGUMENTS
-
-## Instructions
-
-Analyze infrastructure costs and provide actionable optimization recommendations.
-
-### 1. Cost Discovery
-
-**Request Information:**
-
-Ask the user to provide:
-- [ ] Cloud bill (AWS Cost Explorer, Azure Cost Management, GCP Billing)
-- [ ] Time period for analysis (last month, quarter, year)
-- [ ] Current infrastructure details
-- [ ] Monitoring metrics (CPU/memory utilization)
-
-If not provided, guide them on how to export:
-
-**AWS Cost Explorer Export:**
-```bash
-aws ce get-cost-and-usage \
-  --time-period Start=2024-10-01,End=2024-11-01 \
-  --granularity MONTHLY \
-  --metrics UnblendedCost \
-  --group-by Type=SERVICE
-```
-
-**Azure:**
-```bash
-az consumption usage list \
-  --start-date 2024-10-01 \
-  --end-date 2024-11-01 \
-  --output table
-```
-
-**GCP:**
-```bash
-gcloud billing accounts list
-gcloud billing accounts get-billing-info
-```
-
-### 2. Cost Analysis
-
-**Categorize Spending:**
-
-Compute:
-  - EC2/Compute Engine/VMs
-  - Container services (ECS, EKS, GKE)
-  - Serverless (Lambda, Cloud Functions)
-  - Auto-scaling patterns
-
-Storage:
-  - Object storage (S3, Blob, Cloud Storage)
-  - Block storage (EBS, Persistent Disk)
-  - Databases
-  - Backups
-
-Network:
-  - Data transfer
-  - Load balancers
-  - NAT gateways
-  - VPN/Direct Connect
-
-Other:
-  - Monitoring
-  - Logging
-  - Support
-  - Licensing
-
-**Identify Top Cost Drivers:**
-- List top 10 services by cost
-- Calculate % of total spend
-- Identify trends (increasing, stable, decreasing)
-
-### 3. Utilization Analysis
-
-**Resource Efficiency:**
-
-Compute:
-- [ ] Average CPU utilization (<30% = over-provisioned)
-- [ ] Average memory utilization (<40% = over-provisioned)
-- [ ] Idle instances (running 24/7 but low usage)
-- [ ] Non-production environments running off-hours
-
-Storage:
-- [ ] Unused EBS volumes
-- [ ] Old snapshots
-- [ ] S3 lifecycle policies
-- [ ] Storage class optimization
-
-Database:
-- [ ] Database utilization
-- [ ] Read replica usage
-- [ ] Reserved capacity opportunities
-
-### 4. Optimization Recommendations
-
-**Quick Wins (Immediate Impact):**
-
-1. Delete Unused Resources:
-   ```
-   Resources to find and delete:
-   - Unattached EBS volumes
-   - Old snapshots (>90 days)
-   - Unused elastic IPs
-   - Orphaned load balancers
-   - Test/dev resources left running
-
-   Expected Savings: $X,XXX/month
-   Effort: Low (2-4 hours)
-   Risk: Low (verify before deleting)
-   ```
-
-2. Right-Size Instances:
-   ```
-   Analyze resource utilization:
-   - Instances with <30% CPU for 30 days
-   - Instances with <40% memory
-
-   Action: Downsize instance types
-   Example: m5.xlarge → m5.large (50% savings)
-
-   Expected Savings: $X,XXX/month
-   Effort: Medium (testing required)
-   Risk: Medium (performance impact)
-   ```
-
-3. Stop Non-Production Off-Hours:
-   ```
-   Dev/staging environments:
-   - Run Monday-Friday 8am-8pm only
-   - Save 65% of compute costs
-
-   Expected Savings: $X,XXX/month
-   Effort: Low (automation script)
-   Risk: Low
-   ```
-
-**Medium-Term Optimizations:**
-
-4. Reserved Instances / Savings Plans:
-   ```
-   Analyze steady-state workloads:
-   - Identify always-on instances
-   - Calculate 1-year or 3-year commitment
-   - Compare Savings Plans vs Reserved Instances
-
-   Expected Savings: 30-70% on committed spend
-   Effort: Medium (capacity planning)
-   Risk: Medium (commitment)
-   ```
-
-5. Spot Instances:
-   ```
-   Candidates for Spot:
-   - Batch processing
-   - CI/CD workers
-   - Data processing
-   - Non-critical workloads
-
-   Expected Savings: 60-90% on compute
-   Effort: Medium (fault-tolerance required)
-   Risk: Medium (interruptions possible)
-   ```
-
-6. Storage Optimization:
-   ```
-   S3 Lifecycle Policies:
-   - Move to S3-IA after 30 days
-   - Move to Glacier after 90 days
-   - Delete after retention period
-
-   Expected Savings: 50-90% on storage
-   Effort: Low (lifecycle rules)
-   Risk: Low
-   ```
-
-**Long-Term Strategies:**
-
-7. Architecture Optimization:
-   ```
-   Serverless Migration:
-   - Identify low-traffic APIs
-   - Migrate to Lambda/Cloud Functions
-   - Pay per use vs always-on
-
-   Auto-Scaling:
-   - Implement HPA/VPA in Kubernetes
-   - Auto-scaling groups for EC2
-   - Right-size for peak, scale down for trough
-
-   Multi-Region Cost Optimization:
-   - Reduce cross-region data transfer
-   - Use CloudFront/CDN
-   - Regional data locality
-   ```
-
-### 5. FinOps Best Practices
-
-**Implement Cost Governance:**
-
-Tagging Strategy:
-```yaml
-Required Tags:
-  - Environment (prod/staging/dev)
-  - CostCenter
-  - Team
-  - Project
-  - Owner
-
-Enforcement:
-  - Tag policies
-  - Budget alerts per tag
-  - Chargeback reporting
-```
-
-Budget Alerts:
-```yaml
-Set up alerts:
-  - Overall monthly budget
-  - Per-team budgets
-  - Per-environment budgets
-  - Alert at 50%, 80%, 100%
-```
-
-Cost Allocation:
-```yaml
-Enable:
-  - Cost allocation tags
-  - Chargeback reports
-  - Team cost visibility
-  - Cost anomaly detection
-```
-
-### 6. Implementation Roadmap
-
-**Phase 1 (Week 1): Quick Wins**
-- [ ] Delete unused resources
-- [ ] Stop non-prod off-hours
-- [ ] Implement S3 lifecycle policies
-- Expected Savings: $X,XXX/month
-
-**Phase 2 (Weeks 2-4): Right-Sizing**
-- [ ] Analyze utilization
-- [ ] Right-size instances
-- [ ] Implement auto-scaling
-- Expected Savings: $X,XXX/month
-
-**Phase 3 (Month 2): Reserved Capacity**
-- [ ] Analyze commitment opportunities
-- [ ] Purchase Reserved Instances/Savings Plans
-- [ ] Implement Spot instances
-- Expected Savings: $X,XXX/month
-
-**Phase 4 (Month 3+): Continuous Optimization**
-- [ ] Monthly cost reviews
-- [ ] FinOps culture
-- [ ] Cost awareness in development
-- [ ] Automated optimization
-
-### 7. Tracking and Reporting
-
-**Cost Dashboard:**
-```
-Metrics to track:
-- Monthly total spend
-- Spend by service
-- Spend by team
-- Trend vs budget
-- Optimization savings realized
-
-Review Cadence:
-- Weekly: Anomaly detection
-- Monthly: Cost review meeting
-- Quarterly: Strategic planning
-```
-
-### 8. Output Format
-
-Provide detailed report with:
-
-**Executive Summary:**
-- Current monthly spend: $XXX,XXX
-- Potential savings: $XX,XXX (XX%)
-- Top 3 recommendations
-- Implementation timeline
-
-**Detailed Analysis:**
-- Cost breakdown by service
-- Utilization metrics
-- Waste identification
-
-**Optimization Opportunities:**
-Ranked by ROI:
-1. [Recommendation] - $X,XXX/month, low effort
-2. [Recommendation] - $X,XXX/month, medium effort
-3. [Recommendation] - $X,XXX/month, high effort
-
-**Implementation Plan:**
-- Phase-by-phase roadmap
-- Effort estimates
-- Risk assessment
-- Expected savings timeline
-
-**Tracking:**
-- KPIs to monitor
-- Dashboard setup
-- Review schedule
-
-Be specific with actual dollar amounts and percentages where possible.

package/.claude/commands/dev-docs-update.md

@@ -1,55 +0,0 @@
----
-description: Update dev documentation before context compaction
-argument-hint: Optional - specific context or tasks to focus on (leave empty for comprehensive update)
----
-
-We're approaching context limits. Please update the development documentation to ensure seamless continuation after context reset.
-
-## Required Updates
-
-### 1. Update Active Task Documentation
-For each task in `/dev/active/`:
-- Update `[task-name]-context.md` with:
-  - Current implementation state
-  - Key decisions made this session
-  - Files modified and why
-  - Any blockers or issues discovered
-  - Next immediate steps
-  - Last Updated timestamp
-
-- Update `[task-name]-tasks.md` with:
-  - Mark completed tasks as ✅ 
-  - Add any new tasks discovered
-  - Update in-progress tasks with current status
-  - Reorder priorities if needed
-
-### 2. Capture Session Context
-Include any relevant information about:
-- Complex problems solved
-- Architectural decisions made
-- Tricky bugs found and fixed
-- Integration points discovered
-- Testing approaches used
-- Performance optimizations made
-
-### 3. Update Memory (if applicable)
-- Store any new patterns or solutions in project memory/documentation
-- Update entity relationships discovered
-- Add observations about system behavior
-
-### 4. Document Unfinished Work
-- What was being worked on when context limit approached
-- Exact state of any partially completed features
-- Commands that need to be run on restart
-- Any temporary workarounds that need permanent fixes
-
-### 5. Create Handoff Notes
-If switching to a new conversation:
-- Exact file and line being edited
-- The goal of current changes
-- Any uncommitted changes that need attention
-- Test commands to verify work
-
-## Additional Context: $ARGUMENTS
-
-**Priority**: Focus on capturing information that would be hard to rediscover or reconstruct from code alone.

package/.claude/commands/dev-docs.md

@@ -1,51 +0,0 @@
----
-description: Create a comprehensive strategic plan with structured task breakdown
-argument-hint: Describe what you need planned (e.g., "refactor authentication system", "implement microservices")
----
-
-You are an elite strategic planning specialist. Create a comprehensive, actionable plan for: $ARGUMENTS
-
-## Instructions
-
-1. **Analyze the request** and determine the scope of planning needed
-2. **Examine relevant files** in the codebase to understand current state
-3. **Create a structured plan** with:
-   - Executive Summary
-   - Current State Analysis
-   - Proposed Future State
-   - Implementation Phases (broken into sections)
-   - Detailed Tasks (actionable items with clear acceptance criteria)
-   - Risk Assessment and Mitigation Strategies
-   - Success Metrics
-   - Required Resources and Dependencies
-   - Timeline Estimates
-
-4. **Task Breakdown Structure**: 
-   - Each major section represents a phase or component
-   - Number and prioritize tasks within sections
-   - Include clear acceptance criteria for each task
-   - Specify dependencies between tasks
-   - Estimate effort levels (S/M/L/XL)
-
-5. **Create task management structure**:
-   - Create directory: `dev/active/[task-name]/` (relative to project root)
-   - Generate three files:
-     - `[task-name]-plan.md` - The comprehensive plan
-     - `[task-name]-context.md` - Key files, decisions, dependencies
-     - `[task-name]-tasks.md` - Checklist format for tracking progress
-   - Include "Last Updated: YYYY-MM-DD" in each file
-
-## Quality Standards
-- Plans must be self-contained with all necessary context
-- Use clear, actionable language
-- Include specific technical details where relevant
-- Consider both technical and business perspectives
-- Account for potential risks and edge cases
-
-## Context References
-- Check `PROJECT_KNOWLEDGE.md` for architecture overview (if exists)
-- Consult `BEST_PRACTICES.md` for coding standards (if exists)
-- Reference `TROUBLESHOOTING.md` for common issues to avoid (if exists)
-- Use `dev/README.md` for task management guidelines (if exists)
-
-**Note**: This command is ideal to use AFTER exiting plan mode when you have a clear vision of what needs to be done. It will create the persistent task structure that survives context resets.

package/.claude/commands/feature-dev.md

@@ -1,125 +0,0 @@
----
-description: Guided feature development with codebase understanding and architecture focus
-argument-hint: Optional feature description
----
-
-# Feature Development
-
-You are helping a developer implement a new feature. Follow a systematic approach: understand the codebase deeply, identify and ask about all underspecified details, design elegant architectures, then implement.
-
-## Core Principles
-
-- **Ask clarifying questions**: Identify all ambiguities, edge cases, and underspecified behaviors. Ask specific, concrete questions rather than making assumptions. Wait for user answers before proceeding with implementation. Ask questions early (after understanding the codebase, before designing architecture).
-- **Understand before acting**: Read and comprehend existing code patterns first
-- **Read files identified by agents**: When launching agents, ask them to return lists of the most important files to read. After agents complete, read those files to build detailed context before proceeding.
-- **Simple and elegant**: Prioritize readable, maintainable, architecturally sound code
-- **Use TodoWrite**: Track all progress throughout
-
----
-
-## Phase 1: Discovery
-
-**Goal**: Understand what needs to be built
-
-Initial request: $ARGUMENTS
-
-**Actions**:
-1. Create todo list with all phases
-2. If feature unclear, ask user for:
-   - What problem are they solving?
-   - What should the feature do?
-   - Any constraints or requirements?
-3. Summarize understanding and confirm with user
-
----
-
-## Phase 2: Codebase Exploration
-
-**Goal**: Understand relevant existing code and patterns at both high and low levels
-
-**Actions**:
-1. Launch 2-3 code-explorer agents in parallel. Each agent should:
-   - Trace through the code comprehensively and focus on getting a comprehensive understanding of abstractions, architecture and flow of control
-   - Target a different aspect of the codebase (eg. similar features, high level understanding, architectural understanding, user experience, etc)
-   - Include a list of 5-10 key files to read
-
-   **Example agent prompts**:
-   - "Find features similar to [feature] and trace through their implementation comprehensively"
-   - "Map the architecture and abstractions for [feature area], tracing through the code comprehensively"
-   - "Analyze the current implementation of [existing feature/area], tracing through the code comprehensively"
-   - "Identify UI patterns, testing approaches, or extension points relevant to [feature]"
-
-2. Once the agents return, please read all files identified by agents to build deep understanding
-3. Present comprehensive summary of findings and patterns discovered
-
----
-
-## Phase 3: Clarifying Questions
-
-**Goal**: Fill in gaps and resolve all ambiguities before designing
-
-**CRITICAL**: This is one of the most important phases. DO NOT SKIP.
-
-**Actions**:
-1. Review the codebase findings and original feature request
-2. Identify underspecified aspects: edge cases, error handling, integration points, scope boundaries, design preferences, backward compatibility, performance needs
-3. **Present all questions to the user in a clear, organized list**
-4. **Wait for answers before proceeding to architecture design**
-
-If the user says "whatever you think is best", provide your recommendation and get explicit confirmation.
-
----
-
-## Phase 4: Architecture Design
-
-**Goal**: Design multiple implementation approaches with different trade-offs
-
-**Actions**:
-1. Launch 2-3 code-architect agents in parallel with different focuses: minimal changes (smallest change, maximum reuse), clean architecture (maintainability, elegant abstractions), or pragmatic balance (speed + quality)
-2. Review all approaches and form your opinion on which fits best for this specific task (consider: small fix vs large feature, urgency, complexity, team context)
-3. Present to user: brief summary of each approach, trade-offs comparison, **your recommendation with reasoning**, concrete implementation differences
-4. **Ask user which approach they prefer**
-
----
-
-## Phase 5: Implementation
-
-**Goal**: Build the feature
-
-**DO NOT START WITHOUT USER APPROVAL**
-
-**Actions**:
-1. Wait for explicit user approval
-2. Read all relevant files identified in previous phases
-3. Implement following chosen architecture
-4. Follow codebase conventions strictly
-5. Write clean, well-documented code
-6. Update todos as you progress
-
----
-
-## Phase 6: Quality Review
-
-**Goal**: Ensure code is simple, DRY, elegant, easy to read, and functionally correct
-
-**Actions**:
-1. Launch 3 code-reviewer agents in parallel with different focuses: simplicity/DRY/elegance, bugs/functional correctness, project conventions/abstractions
-2. Consolidate findings and identify highest severity issues that you recommend fixing
-3. **Present findings to user and ask what they want to do** (fix now, fix later, or proceed as-is)
-4. Address issues based on user decision
-
----
-
-## Phase 7: Summary
-
-**Goal**: Document what was accomplished
-
-**Actions**:
-1. Mark all todos complete
-2. Summarize:
-   - What was built
-   - Key decisions made
-   - Files modified
-   - Suggested next steps
-
----