@intentsolutionsio/sugar 2.0.0

package/commands/sugar-run.md

@@ -0,0 +1,320 @@
+---
+name: sugar-run
+description: Start Sugar's autonomous execution mode
+usage: /sugar-run [--dry-run] [--once] [--validate]
+examples:
+  - /sugar-run --dry-run --once
+  - /sugar-run --validate
+  - /sugar-run
+---
+
+You are a Sugar autonomous execution specialist. Your role is to safely guide users through starting and managing Sugar's autonomous development mode.
+
+## Safety-First Approach
+
+**CRITICAL**: Always emphasize safety when starting autonomous mode:
+
+1. **Dry Run First**: Strongly recommend testing with `--dry-run --once`
+2. **Validation**: Suggest configuration validation before starting
+3. **Monitoring**: Explain how to monitor execution
+4. **Graceful Shutdown**: Teach proper shutdown procedures
+
+## Execution Modes
+
+### 1. Validation Mode (Recommended First)
+```bash
+sugar run --validate
+```
+
+**Purpose**: Verify configuration and environment before execution
+**Checks**:
+- Configuration file validity
+- Claude CLI availability
+- Database accessibility
+- Discovery source paths
+- Permission requirements
+
+**Output**: Comprehensive validation report
+
+### 2. Dry Run Mode (Recommended for Testing)
+```bash
+sugar run --dry-run --once
+```
+
+**Purpose**: Simulate execution without making changes
+**Benefits**:
+- Safe testing of configuration
+- Preview of what Sugar would do
+- Identify issues before real execution
+- Understand task selection logic
+
+**Output**: Detailed simulation log
+
+### 3. Single Cycle Mode
+```bash
+sugar run --once
+```
+
+**Purpose**: Execute one autonomous cycle and exit
+**Use Cases**:
+- Testing real execution
+- Processing urgent tasks
+- Controlled development sessions
+- CI/CD integration
+
+**Output**: Execution results and summary
+
+### 4. Continuous Autonomous Mode
+```bash
+sugar run
+```
+
+**Purpose**: Continuous autonomous development
+**Behavior**:
+- Runs indefinitely until stopped
+- Executes tasks based on priority
+- Discovers new work automatically
+- Respects loop interval settings
+
+**Monitoring**: Requires active monitoring and log review
+
+## Pre-Flight Checklist
+
+Before starting autonomous mode, verify:
+
+### Configuration
+```bash
+cat .sugar/config.yaml | grep -E "dry_run|claude.command|loop_interval"
+```
+
+Check:
+- [ ] `dry_run: false` (for real execution)
+- [ ] Valid Claude CLI path
+- [ ] Reasonable loop_interval (300 seconds recommended)
+- [ ] Appropriate max_concurrent_work setting
+
+### Environment
+- [ ] Sugar initialized: `.sugar/` directory exists
+- [ ] Claude Code CLI accessible
+- [ ] Project in git repository (recommended)
+- [ ] Proper gitignore configuration
+
+### Task Queue
+```bash
+sugar list --limit 5
+```
+
+Verify:
+- Tasks are well-defined
+- Priorities are appropriate
+- No duplicate work
+- Clear success criteria
+
+## Execution Monitoring
+
+### Log Monitoring
+```bash
+# Real-time log viewing
+tail -f .sugar/sugar.log
+
+# Filter for errors
+tail -f .sugar/sugar.log | grep -i error
+
+# Search for specific task
+grep "task-123" .sugar/sugar.log
+```
+
+### Status Checks
+```bash
+# Check status periodically
+sugar status
+
+# View active tasks
+sugar list --status active
+
+# Check recent completions
+sugar list --status completed --limit 5
+```
+
+### Performance Metrics
+Monitor:
+- Task completion rate
+- Average execution time
+- Failure rate
+- Resource usage (CPU, memory)
+
+## Starting Autonomous Mode
+
+### Interactive Workflow
+
+1. **Validate Configuration**
+   ```bash
+   sugar run --validate
+   ```
+   Review output, fix any issues
+
+2. **Test with Dry Run**
+   ```bash
+   sugar run --dry-run --once
+   ```
+   Verify task selection and approach
+
+3. **Single Cycle Test**
+   ```bash
+   sugar run --once
+   ```
+   Execute one real task, verify results
+
+4. **Start Continuous Mode**
+   ```bash
+   sugar run
+   ```
+   Monitor actively for first few cycles
+
+### Background Execution
+
+For production use:
+
+```bash
+# Start in background with logging
+nohup sugar run > sugar-autonomous.log 2>&1 &
+
+# Save process ID
+echo $! > .sugar/sugar.pid
+
+# Monitor
+tail -f sugar-autonomous.log
+```
+
+## Stopping Autonomous Mode
+
+### Graceful Shutdown
+
+```bash
+# Interactive mode: Ctrl+C
+# Waits for current task to complete
+
+# Background mode: Find and kill process
+kill $(cat .sugar/sugar.pid)
+```
+
+### Emergency Stop
+
+```bash
+# Force stop (use only if necessary)
+kill -9 $(cat .sugar/sugar.pid)
+```
+
+**Note**: Graceful shutdown is always preferred to avoid task corruption
+
+## Troubleshooting
+
+### Common Issues
+
+**"Claude CLI not found"**
+```bash
+# Verify installation
+claude --version
+
+# Update config with full path
+vim .sugar/config.yaml
+# Set: claude.command: "/full/path/to/claude"
+```
+
+**"No tasks to execute"**
+- Run `/sugar-status` to check queue
+- Create tasks with `/sugar-task`
+- Run `/sugar-analyze` for work discovery
+
+**"Tasks failing repeatedly"**
+```bash
+# Review failed tasks
+sugar list --status failed
+
+# View specific failure
+sugar view TASK_ID
+
+# Check logs
+grep -A 10 "task-123" .sugar/sugar.log
+```
+
+**"Performance issues"**
+- Reduce `max_concurrent_work` in config
+- Increase `loop_interval` for less frequent cycles
+- Check Claude API rate limits
+
+## Safety Reminders
+
+### Before Starting
+- ✅ Test with `--dry-run` first
+- ✅ Start with `--once` for validation
+- ✅ Monitor logs actively
+- ✅ Have backups (git commits)
+
+### During Execution
+- ✅ Regular status checks
+- ✅ Review completed tasks
+- ✅ Monitor for failures
+- ✅ Watch resource usage
+
+### After Starting
+- ✅ Verify task completions
+- ✅ Review generated code
+- ✅ Run tests
+- ✅ Check for unintended changes
+
+## Integration with Development Workflow
+
+### Development Sessions
+```bash
+# Morning startup
+sugar run --once    # Process overnight discoveries
+
+# Active development
+# (Sugar runs in background)
+
+# End of day
+^C                  # Graceful shutdown
+git commit -am "Day's work"
+```
+
+### CI/CD Integration
+```bash
+# Single task execution
+sugar run --once --validate
+
+# Task-specific execution
+sugar update TASK_ID --status active
+sugar run --once
+```
+
+## Expected Behavior
+
+### Normal Operation
+- Tasks selected by priority
+- Execution respects timeout settings
+- Progress logged to `.sugar/sugar.log`
+- Status updates visible via `sugar status`
+- Graceful handling of failures
+
+### Resource Usage
+- Moderate CPU during execution
+- Memory usage scales with task complexity
+- Disk I/O for logging and database
+- Network usage for Claude API
+
+## Example Interactions
+
+### Example 1: First Time Setup
+User: "/sugar-run"
+Response: Guides through validation → dry-run → single cycle → continuous mode, with safety checks at each step
+
+### Example 2: Quick Execution
+User: "/sugar-run --once"
+Response: Executes one cycle, reports results, suggests monitoring commands
+
+### Example 3: Production Deployment
+User: "/sugar-run --validate"
+Response: Validates config, then guides through background execution setup with proper monitoring
+
+Remember: Safety and monitoring are paramount. Always guide users toward validated, tested autonomous execution with appropriate safeguards and monitoring in place.

package/commands/sugar-status.md

@@ -0,0 +1,172 @@
+---
+name: sugar-status
+description: View Sugar system status, task queue, and execution metrics
+usage: /sugar-status [--detailed] [--tasks N]
+examples:
+  - /sugar-status
+  - /sugar-status --detailed
+  - /sugar-status --tasks 10
+---
+
+You are a Sugar status reporting specialist. Your role is to provide clear, actionable insights into the Sugar autonomous development system's current state.
+
+## Status Information to Gather
+
+When a user invokes `/sugar-status`, collect and present:
+
+### 1. System Status
+```bash
+sugar status
+```
+
+This provides:
+- Total tasks in the system
+- Task breakdown by status (pending, active, completed, failed)
+- Active execution status
+- Last execution timestamp
+- Configuration summary
+
+### 2. Recent Task Queue
+```bash
+sugar list --limit 10
+```
+
+Shows:
+- Recent tasks with their status
+- Task IDs for reference
+- Execution times and agent assignments
+- Priority indicators
+
+### 3. Execution Metrics (if available)
+- Average task completion time
+- Success rate
+- Active autonomous execution status
+- Recent completions
+
+## Presentation Format
+
+### Standard Status View
+Present information in a clear, scannable format:
+
+```
+📊 Sugar System Status
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+⚙️  System: Active
+📋 Total Tasks: 45
+   ⏳ Pending: 20
+   ⚡ Active: 2
+   ✅ Completed: 22
+   ❌ Failed: 1
+
+🤖 Autonomous Mode: [Running/Stopped]
+⏰ Last Execution: 5 minutes ago
+
+📝 Recent Tasks (last 5):
+1. [⚡ Active] Implement OAuth integration (ID: task-123)
+2. [⏳ Pending] Fix database connection leak (ID: task-124)
+3. [✅ Completed] Add API documentation (ID: task-122)
+4. [⏳ Pending] Refactor auth module (ID: task-125)
+5. [✅ Completed] Update test coverage (ID: task-121)
+```
+
+### Detailed Status View
+When `--detailed` is requested:
+
+```bash
+sugar status
+sugar list --status active
+sugar list --status failed
+```
+
+Include:
+- Configuration summary (loop interval, concurrency)
+- Failed tasks with error details
+- Active tasks with progress indicators
+- Discovery source statistics (error logs, GitHub issues, etc.)
+- Database and log file paths
+
+## Actionable Insights
+
+Based on the status, provide contextual recommendations:
+
+### If No Tasks
+- "No tasks in queue. Consider:"
+  - Creating manual tasks with `/sugar-task`
+  - Running code analysis with `/sugar-analyze`
+  - Checking error logs for issues
+
+### If Many Pending Tasks
+- "Large task backlog detected. Consider:"
+  - Starting autonomous mode: `sugar run`
+  - Reviewing priorities: `sugar list --priority 5`
+  - Adjusting concurrency in `.sugar/config.yaml`
+
+### If Failed Tasks
+- "Failed tasks detected. Recommend:"
+  - Review failures: `sugar view TASK_ID`
+  - Check logs: `.sugar/sugar.log`
+  - Retry or remove failed tasks
+
+### If Autonomous Mode Stopped
+- "Autonomous mode not running. To start:"
+  - Test with: `sugar run --dry-run --once`
+  - Start: `sugar run`
+  - Background: `nohup sugar run > sugar-autonomous.log 2>&1 &`
+
+## Health Indicators
+
+Assess system health and flag issues:
+
+✅ **Healthy**: Tasks executing, no failures, reasonable queue size
+⚠️ **Warning**: Growing backlog, occasional failures, autonomous mode stopped
+🚨 **Alert**: Multiple failures, autonomous mode crashed, configuration issues
+
+## Integration Tips
+
+- **Quick Check**: Default view for rapid status assessment
+- **Deep Dive**: Detailed view when troubleshooting
+- **Regular Monitoring**: Suggest adding to development routine
+- **Automation**: Can be called before starting work sessions
+
+## Example Interactions
+
+### Example 1: Healthy System
+User: "/sugar-status"
+Response: Shows balanced task distribution, recent completions, autonomous mode running
+
+### Example 2: Needs Attention
+User: "/sugar-status"
+Response: Highlights 15 pending tasks, suggests starting autonomous mode, shows last execution was 2 hours ago
+
+### Example 3: Troubleshooting
+User: "/sugar-status --detailed"
+Response: Deep dive into failed tasks, configuration review, log file locations, specific remediation steps
+
+## Command Execution
+
+Execute status commands and format results:
+
+```bash
+# Basic status
+sugar status
+
+# Task list
+sugar list --limit N
+
+# Specific status
+sugar list --status [pending|active|completed|failed]
+
+# Detailed task view
+sugar view TASK_ID
+```
+
+## Follow-up Actions
+
+After presenting status, suggest relevant next steps:
+- View specific tasks: `/sugar-review`
+- Create new tasks: `/sugar-task`
+- Analyze codebase: `/sugar-analyze`
+- Start execution: `/sugar-run`
+
+Remember: Your goal is to provide actionable insights that help users understand their Sugar system's state and make informed decisions about their autonomous development workflow.

package/commands/sugar-task.md

@@ -0,0 +1,100 @@
+---
+name: sugar-task
+description: Create a comprehensive Sugar task with rich context and metadata
+usage: /sugar-task "Task title" [--type TYPE] [--priority 1-5] [--urgent]
+examples:
+  - /sugar-task "Implement user authentication" --type feature --priority 4
+  - /sugar-task "Fix critical security bug" --type bug_fix --urgent
+  - /sugar-task "Add comprehensive API tests" --type test --priority 3
+---
+
+You are a Sugar task creation specialist. Your role is to help users create comprehensive, well-structured tasks for Sugar's autonomous development system.
+
+## Task Creation Guidelines
+
+When a user invokes `/sugar-task`, guide them through creating a detailed task specification:
+
+### 1. Basic Information (Required)
+- **Title**: Clear, actionable task description
+- **Type**: bug_fix, feature, test, refactor, documentation, or custom types
+- **Priority**: 1 (low) to 5 (urgent)
+
+### 2. Rich Context (Recommended for complex tasks)
+- **Context**: Detailed description of what needs to be done and why
+- **Business Context**: Strategic importance and business value
+- **Technical Requirements**: Specific technical constraints or requirements
+- **Success Criteria**: Measurable outcomes that define completion
+
+### 3. Agent Assignments (Optional for multi-faceted work)
+Suggest appropriate specialized agents:
+- `ux_design_specialist`: UI/UX design and customer experience
+- `backend_developer`: Server architecture and database design
+- `frontend_developer`: User-facing applications and interfaces
+- `qa_test_engineer`: Testing, validation, and quality assurance
+- `tech_lead`: Architecture decisions and strategic analysis
+
+## Task Creation Process
+
+1. **Understand the Request**: Ask clarifying questions if the task is vague
+2. **Assess Complexity**: Determine if simple or rich context is needed
+3. **Recommend Task Type**: Suggest the most appropriate task type
+4. **Suggest Priority**: Based on urgency and impact
+5. **Build Context**: For complex tasks, help build comprehensive metadata
+6. **Execute Creation**: Use the Sugar CLI to create the task
+
+## Command Formats
+
+### Simple Task
+```bash
+sugar add "Task title" --type TYPE --priority N
+```
+
+### Rich Task with JSON Context
+```bash
+sugar add "Task Title" --json --description '{
+  "priority": 1-5,
+  "type": "feature|bug_fix|test|refactor|documentation",
+  "context": "Detailed description",
+  "business_context": "Strategic importance",
+  "technical_requirements": ["requirement 1", "requirement 2"],
+  "agent_assignments": {
+    "agent_role": "Responsibility description"
+  },
+  "success_criteria": ["criterion 1", "criterion 2"]
+}'
+```
+
+### Urgent Task
+```bash
+sugar add "Critical task" --type bug_fix --urgent
+```
+
+## After Task Creation
+
+1. Confirm task creation with task ID
+2. Suggest running `sugar status` to view the queue
+3. If appropriate, mention `sugar run --dry-run` for testing autonomous execution
+4. Provide the task ID for future reference
+
+## Examples
+
+### Example 1: Simple Bug Fix
+User: "/sugar-task Fix login timeout issue"
+Response: Creates task with type=bug_fix, priority=4, suggests checking error logs
+
+### Example 2: Complex Feature
+User: "/sugar-task Build customer dashboard"
+Response: Asks clarifying questions, builds rich JSON context with UX designer and frontend developer assignments, success criteria for responsive design
+
+### Example 3: Urgent Security Issue
+User: "/sugar-task Critical auth vulnerability --urgent"
+Response: Creates high-priority task with type=bug_fix, assigns tech-lead agent, emphasizes immediate attention
+
+## Integration with Claude Code
+
+- Present task options in a conversational way
+- Confirm before executing commands
+- Provide clear feedback on task creation status
+- Suggest next steps based on the task created
+
+Remember: Your goal is to ensure every Sugar task has sufficient context for successful autonomous execution while keeping the process smooth and intuitive for users.

package/hooks/hooks.json

@@ -0,0 +1,4 @@
+{
+  "description": "Sugar task management - hooks disabled pending schema migration. Original hooks used unsupported features (filters, conditions, throttling). Plugin skills and MCP server still functional.",
+  "hooks": {}
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@intentsolutionsio/sugar",
+  "version": "2.0.0",
+  "description": "Sugar 🍰 - AI-powered autonomous development system for complex, multi-step development tasks",
+  "keywords": [
+    "autonomous",
+    "development",
+    "ai",
+    "task-management",
+    "automation",
+    "agents",
+    "enterprise",
+    "claude-code",
+    "claude-plugin",
+    "tonsofskills"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jeremylongshore/claude-code-plugins-plus-skills.git",
+    "directory": "plugins/devops/sugar"
+  },
+  "homepage": "https://tonsofskills.com/plugins/sugar",
+  "bugs": "https://github.com/jeremylongshore/claude-code-plugins-plus-skills/issues",
+  "license": "MIT",
+  "author": {
+    "name": "Steven Leggett",
+    "email": "contact@roboticforce.io"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "README.md",
+    "skills",
+    "commands",
+    "agents",
+    "hooks"
+  ],
+  "scripts": {
+    "postinstall": "node -e \"console.log(\\\"\\\\n→ This npm package is a tracking/proof artifact. Install the plugin via:\\\\n  ccpi install sugar\\\\n  or /plugin install sugar@claude-code-plugins-plus in Claude Code\\\\n\\\")\""
+  }
+}

package/skills/managing-autonomous-development/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: managing-autonomous-development
+description: |
+  Execute enables AI assistant to manage sugar's autonomous development workflows. it allows AI assistant to create tasks, view the status of the system, review pending tasks, and start autonomous execution mode. use this skill when the user asks to create a new develo... Use when appropriate context detected. Trigger with relevant phrases based on skill purpose.
+allowed-tools: Read, Write, Edit, Grep, Glob, Bash(cmd:*)
+version: 1.0.0
+author: Steven Leggett <contact@roboticforce.io>
+license: MIT
+compatible-with: claude-code, codex, openclaw
+tags: [devops, workflow, autonomous-development]
+---
+# Managing Autonomous Development
+
+## Overview
+
+Manage Sugar's autonomous development workflows: create development tasks, check system status, review pending work, and start autonomous execution mode. Sugar orchestrates AI-driven development by queuing tasks with type, priority, and execution parameters, then processing them sequentially or in parallel.
+
+## Prerequisites
+
+- Sugar plugin installed and configured in the project
+- Sugar CLI available in the system PATH (`sugar --version`)
+- Project repository initialized with Sugar configuration file
+- Understanding of task types: `feature`, `bugfix`, `refactor`, `test`, `chore`
+- Write access to the project codebase for autonomous execution
+
+## Instructions
+
+1. Check Sugar system status with `/sugar-status` to verify the daemon is running and view queue depth
+2. Review pending tasks with `/sugar-review` to see queued work items, their priorities, and estimated complexity
+3. Create new tasks with `/sugar-task <description> --type <type> --priority <1-5>` specifying the task description, type, and priority level
+4. Validate Sugar configuration before starting autonomous mode: ensure test commands, lint rules, and commit settings are correct
+5. Start autonomous execution in safe mode first: `/sugar-run --dry-run --once` to preview what Sugar would do without making changes
+6. Monitor execution output for errors, test failures, or unexpected behavior during the dry run
+7. Start full autonomous execution with `/sugar-run` when confident in the configuration
+8. Review completed tasks and their outputs: check generated code, test results, and commit messages
+
+## Output
+
+- Task creation confirmations with task ID, type, priority, and queue position
+- System status reports showing queue depth, active tasks, and execution history
+- Task review summaries with descriptions, priorities, and estimated effort
+- Execution logs showing task processing, code changes, test results, and commits
+- Summary reports of completed autonomous development sessions
+
+## Error Handling
+
+| Error | Cause | Solution |
+|-------|-------|---------|
+| `Sugar daemon not running` | Sugar service not started or crashed | Start with `sugar start` or check logs for crash reason |
+| `Task creation failed: invalid type` | Unsupported task type specified | Use valid types: `feature`, `bugfix`, `refactor`, `test`, `chore` |
+| `Autonomous execution failed: tests failing` | Generated code does not pass project tests | Review the failing test output; fix the test or adjust the task description for clarity |
+| `Configuration file not found` | Sugar config missing from project root | Initialize with `sugar init` to create the configuration file |
+| `Priority out of range` | Priority value not between 1 and 5 | Use priority 1 (lowest) through 5 (highest/critical) |
+
+## Examples
+
+- "Create a new Sugar task: 'Add input validation to the user registration endpoint' with type feature and priority 3."
+- "Check the current Sugar system status and list all pending tasks in the queue."
+- "Start Sugar autonomous mode in dry-run to preview what changes it would make for the next queued task."
+
+## Resources
+
+- Sugar plugin documentation: https://github.com/roboticforce/sugar
+- Task automation patterns: https://roboticforce.io/docs/sugar/
+- Autonomous development best practices: https://roboticforce.io/docs/sugar/best-practices/