make-it-done 0.1.0

package/makeitdone/workflows/quick.md

@@ -0,0 +1,151 @@
+# Quick Task Execution Workflow
+
+Ad-hoc task execution without full phase structure. Useful for out-of-band work.
+
+**Token budget**: ~12K (direct executor spawn, no wave structure)
+
+---
+
+## Context Setup
+
+@/Users/ismailalam/Development/my/makeitdone/makeitdone/steps/model-route.md
+@/Users/ismailalam/Development/my/makeitdone/makeitdone/steps/agent-contracts.md
+
+---
+
+## Execution
+
+### 1. Parse Task Description
+
+```bash
+TASK_DESC="$ARGUMENTS"
+
+if [ -z "$TASK_DESC" ]; then
+  error "Usage: /mid:quick '<task description>'"
+  exit 1
+fi
+```
+
+### 2. Route Model
+
+```bash
+context_window=$(mid-tools config get context_window)
+model_profile=$(mid-tools config get model_profile)
+
+if [ "$context_window" -lt 500000 ]; then
+  # Degrade to haiku
+  EXECUTOR_MODEL=haiku
+  output "warn: Low context, using haiku"
+else
+  # Use profile routing
+  case "$model_profile" in
+    budget) EXECUTOR_MODEL=haiku ;;
+    balanced) EXECUTOR_MODEL=sonnet ;;
+    quality) EXECUTOR_MODEL=opus ;;
+  esac
+fi
+```
+
+### 3. Spawn Executor (Direct)
+
+```bash
+EXECUTOR_OUTPUT=$(spawn agent \
+  name=mid-executor \
+  model=$EXECUTOR_MODEL \
+  context=$(cat << EOF
+mode: quick
+task: $TASK_DESC
+interactive: $([ "$INTERACTIVE_FLAG" = true ] && echo "true" || echo "false")
+EOF
+))
+```
+
+### 4. Parse Output
+
+```bash
+if [[ $EXECUTOR_OUTPUT == *"## WAVE COMPLETE"* ]] || \
+   [[ $EXECUTOR_OUTPUT == *"completed"* ]]; then
+  output "## TASK COMPLETE"
+  
+  # Extract results
+  RESULTS=$(echo "$EXECUTOR_OUTPUT" | grep -A 10 "Results:")
+  echo "$RESULTS"
+  
+  if [ "$VERIFY_FLAG" = true ]; then
+    # Quick verification
+    spawn mid-verifier mode=integration
+  fi
+  
+elif [[ $EXECUTOR_OUTPUT == *"## BLOCKED"* ]]; then
+  output "## TASK BLOCKED"
+  
+  # Show blocker
+  BLOCKER=$(echo "$EXECUTOR_OUTPUT" | grep -A 5 "BLOCKED")
+  echo "$BLOCKER"
+  
+  ask_user "How to proceed?"
+  
+else
+  output "## TASK FAILED"
+  ask_user "Debug or skip?"
+fi
+```
+
+### 5. Update STATE (Optional)
+
+If task is part of current phase:
+
+```bash
+if [ "$UPDATE_STATE" = true ]; then
+  mid-tools state set last_quick_task "$TASK_DESC"
+  mid-tools state set last_quick_time $(date -u +%s)
+fi
+```
+
+---
+
+## Usage Examples
+
+```bash
+# Simple task
+/mid:quick "Write unit tests for auth module"
+
+# With verification
+/mid:quick "Refactor login endpoint" --verify
+
+# Interactive (ask questions)
+/mid:quick "Design database schema" --interactive
+
+# Don't update state
+/mid:quick "Review code in PR" --no-state-update
+```
+
+---
+
+## Key Differences from /mid:do
+
+| Aspect | /mid:do | /mid:quick |
+|--------|---------|-----------|
+| **Scope** | Full phase execution | Single task |
+| **Structure** | PLAN.md + waves | Task description only |
+| **State** | Full tracking | Optional |
+| **Verification** | Per-wave gates | Optional |
+| **Time budget** | Hours | 30 minutes max |
+
+---
+
+## Error Handling
+
+- **No task description**: Show usage error
+- **Blocked task**: Escalate to user
+- **Context too low**: Fail with suggestion to run `/mid:status`
+- **Task too complex**: Suggest using `/mid:plan` + `/mid:do`
+
+---
+
+## Anti-patterns Avoided
+
+✓ Lightweight (direct executor spawn)
+✓ No wave structure (simpler context)
+✓ Optional state updates (don't force tracking)
+✓ Time-boxed execution

package/makeitdone/workflows/report.md

@@ -0,0 +1,138 @@
+# Report Generation Workflow
+
+Create comprehensive project report across all phases.
+
+**Token budget**: ~6K (frontmatter reads + light processing)
+
+---
+
+## Context Setup
+
+@/Users/ismailalam/Development/my/makeitdone/makeitdone/steps/state-read.md
+
+---
+
+## Execution
+
+### 1. Gather Phase Summaries
+
+```bash
+for phase in 1 2 3 4 5; do
+  PHASE_DIR=".planning/phases/$(printf '%02d' $phase)-*"
+  
+  if [ ! -d "$PHASE_DIR" ]; then
+    break  # No more phases
+  fi
+  
+  if [ -f "$PHASE_DIR/SUMMARY.md" ]; then
+    # Extract frontmatter + first 10 lines
+    SUMMARY=$(mid-tools fm get "$PHASE_DIR/SUMMARY.md")
+    STATUS=$(echo "$SUMMARY" | grep "^status:" | cut -d: -f2)
+    ACTUAL_HOURS=$(echo "$SUMMARY" | grep "^actual_hours:" | cut -d: -f2)
+    
+    accumulate_phase_data $phase "$STATUS" "$ACTUAL_HOURS"
+  fi
+done
+```
+
+### 2. Generate Report
+
+```bash
+cat > report_output.md << EOF
+# Project Report
+
+**Generated**: $(date)
+**Project**: $(mid-tools config get project_name)
+
+## Summary
+
+Total Phases: $TOTAL_PHASES
+Completed: $COMPLETED_PHASES
+In Progress: $IN_PROGRESS_PHASES
+Total Hours: $TOTAL_HOURS
+Average per Phase: $AVG_HOURS
+
+## Phase Breakdown
+
+| Phase | Status | Hours | Variance |
+|-------|--------|-------|----------|
+EOF
+
+for phase in phases_data; do
+  echo "| Phase $phase | $status | $hours | $var |" >> report_output.md
+done
+
+cat >> report_output.md << EOF
+
+## Key Metrics
+
+- Time Efficiency: Actual vs Estimated
+- Quality Gates: Tests passed, reviews completed
+- Risks Resolved: [count]
+- Blockers Encountered: [count]
+
+## Next Steps
+
+- $(phase_specific_next_step)
+
+---
+*Report generated by makeitdone*
+EOF
+```
+
+### 3. Save Report
+
+```bash
+cp report_output.md .planning/REPORT_$(date +%Y%m%d_%H%M%S).md
+```
+
+### 4. Output
+
+```
+## REPORT GENERATED
+
+File: .planning/REPORT_$(date +%Y%m%d_%H%M%S).md
+Phases covered: $COVERED_PHASES
+Total hours: $TOTAL_HOURS
+
+Key metrics above.
+```
+
+---
+
+## Formats
+
+Text format (default): Markdown report (above)
+
+JSON format (--format json):
+
+```bash
+jq -n \
+  --arg project "$(mid-tools config get project_name)" \
+  --arg phases "$TOTAL_PHASES" \
+  --arg hours "$TOTAL_HOURS" \
+  '{project: $project, phases: $phases | tonumber, hours: $hours | tonumber}'
+```
+
+TOON format (--format toon):
+
+```bash
+echo '{project: "'$(mid-tools config get project_name)'", phases: '$TOTAL_PHASES', hours: '$TOTAL_HOURS'}' | \
+  node ~/.claude/makeitdone/bin/mid-tools.cjs toon -
+```
+
+---
+
+## Error Handling
+
+- **No SUMMARY.md files**: Report partial data (phases completed so far)
+- **Invalid config**: Use defaults
+- **Date formatting issue**: Use ISO format fallback
+
+---
+
+## Anti-patterns Avoided
+
+✓ Frontmatter-only reads (small data)
+✓ Report uses TOON for JSON output
+✓ No agent spawning (pure data aggregation)

package/makeitdone/workflows/status.md

@@ -0,0 +1,135 @@
+# Status Workflow
+
+Show current project status and phase progress.
+
+**Token budget**: ~4K (frontmatter reads only)
+
+---
+
+## Context Setup
+
+@/Users/ismailalam/Development/my/makeitdone/makeitdone/steps/state-read.md
+
+---
+
+## Execution
+
+### 1. Load State
+
+```bash
+context_window=$(mid-tools config get context_window)
+
+if [ "$context_window" -lt 500000 ]; then
+  STATE=$(mid-tools fm get .planning/STATE.md)
+else
+  STATE=$(mid-tools state get)
+fi
+```
+
+### 2. Extract Metrics
+
+```bash
+PHASE=$(echo "$STATE" | grep "^phase:" | cut -d: -f2 | tr -d ' ')
+CURRENT_WAVE=$(echo "$STATE" | grep "^current_wave:" | cut -d: -f2 | tr -d ' ')
+PHASE_START=$(echo "$STATE" | grep "phase_start_time:" | cut -d: -f2 | tr -d ' ')
+
+# Calculate elapsed time
+ELAPSED=$(($(date +%s) - $PHASE_START))
+ELAPSED_HOURS=$(($ELAPSED / 3600))
+ELAPSED_MINS=$((($ELAPSED % 3600) / 60))
+```
+
+### 3. Load Roadmap (frontmatter)
+
+```bash
+ROADMAP_FM=$(mid-tools fm get .planning/ROADMAP.md)
+TOTAL_PHASES=$(echo "$ROADMAP_FM" | grep -c "^## [0-9]")
+```
+
+### 4. Load Plan Progress
+
+```bash
+PHASE_DIR=".planning/phases/$(printf '%02d' $PHASE)-*"
+
+if [ -f "$PHASE_DIR/PLAN.md" ]; then
+  PLAN_FM=$(mid-tools fm get "$PHASE_DIR/PLAN.md")
+  TOTAL_TASKS=$(echo "$PLAN_FM" | grep "^tasks:" | cut -d: -f2)
+  TOTAL_WAVES=$(echo "$PLAN_FM" | grep "^waves:" | cut -d: -f2)
+fi
+```
+
+### 5. Format Output
+
+Text format (default):
+
+```
+╔════════════════════════════════════╗
+║   makeitdone Project Status        ║
+╚════════════════════════════════════╝
+
+Project: [from config.json]
+Phase: $PHASE / $TOTAL_PHASES
+Wave: $CURRENT_WAVE / $TOTAL_WAVES
+
+Tasks: [count completed] / $TOTAL_TASKS
+Time: ${ELAPSED_HOURS}h ${ELAPSED_MINS}m
+
+Recent Updates:
+- [from STATE.md notes]
+
+Next: /mid:do $PHASE --wave $CURRENT_WAVE
+```
+
+JSON format (--format json):
+
+```json
+{
+  "phase": $PHASE,
+  "total_phases": $TOTAL_PHASES,
+  "wave": $CURRENT_WAVE,
+  "total_waves": $TOTAL_WAVES,
+  "tasks_total": $TOTAL_TASKS,
+  "elapsed_seconds": $ELAPSED,
+  "status": "in-progress"
+}
+```
+
+TOON format (--format toon):
+
+```
+phase: $PHASE
+total_phases: $TOTAL_PHASES
+wave: $CURRENT_WAVE
+total_waves: $TOTAL_WAVES
+tasks_total: $TOTAL_TASKS
+elapsed_seconds: $ELAPSED
+status: in-progress
+```
+
+### 6. Output Status
+
+```
+## STATUS REPORT
+
+Phase: $PHASE / $TOTAL_PHASES (progress%)
+Wave: $CURRENT_WAVE / $TOTAL_WAVES
+Time: ${ELAPSED_HOURS}h ${ELAPSED_MINS}m
+
+Next: See command above
+```
+
+---
+
+## Error Handling
+
+- **Missing STATE.md**: Suggest `/mid:init`
+- **Missing PLAN.md**: Suggest `/mid:plan --mode phase --phase $PHASE`
+- **Invalid format flag**: Default to text
+
+---
+
+## Anti-patterns Avoided
+
+✓ Frontmatter-only reads (no full files)
+✓ Multiple output formats (user choice)
+✓ Fast calculation (no spawning agents)

package/makeitdone/workflows/verify.md

@@ -0,0 +1,177 @@
+# Verify Phase Workflow
+
+Quality gate for phase completion. Validates against acceptance criteria.
+
+**Token budget**: ~8K (read-only work, haiku agents)
+
+---
+
+## Context Setup
+
+@/Users/ismailalam/Development/my/makeitdone/makeitdone/steps/state-read.md
+@/Users/ismailalam/Development/my/makeitdone/makeitdone/steps/model-route.md
+
+---
+
+## Modes
+
+- `--mode integration` — test coordination, file presence, contracts
+- `--mode security` — OWASP checks, auth patterns, secret scanning
+- `--mode ui` — visual validation checkpoints
+- `--mode audit` — full verification (all three)
+
+---
+
+## Initialization
+
+### 1. Load Phase
+
+```bash
+PHASE=${phase_arg}
+PHASE_DIR=".planning/phases/$(printf '%02d' $PHASE)-*"
+
+if [ ! -f "$PHASE_DIR/PLAN.md" ] || [ ! -f ".planning/REQUIREMENTS.md" ]; then
+  error "Phase or requirements not found"
+fi
+```
+
+### 2. Check Acceptance Criteria
+
+```bash
+ACCEPTANCE=$(mid-tools fm get ".planning/REQUIREMENTS.md" --field "acceptance_criteria" || \
+             mid-tools fm get "$PHASE_DIR/PLAN.md" --field "acceptance_criteria")
+
+if [ -z "$ACCEPTANCE" ]; then
+  warn "No acceptance criteria found, skipping verification"
+  exit 0
+fi
+```
+
+---
+
+## Execution (Integration Mode)
+
+### 1. Spawn Verifier
+
+```bash
+VERIFIER_OUTPUT=$(spawn agent \
+  name=mid-verifier \
+  model=haiku \
+  context=$(cat << EOF
+mode: integration
+phase: $PHASE
+acceptance_criteria: $ACCEPTANCE
+phase_dir: $PHASE_DIR
+EOF
+))
+```
+
+### 2. Parse Result
+
+```bash
+if [[ $VERIFIER_OUTPUT == *"## VERIFICATION PASSED"* ]]; then
+  output_marker "## VERIFICATION PASSED"
+  exit 0
+elif [[ $VERIFIER_OUTPUT == *"## VERIFICATION FAILED"* ]]; then
+  # Extract blocker reasons
+  BLOCKERS=$(echo "$VERIFIER_OUTPUT" | grep -A 10 "FAILED")
+  echo "$BLOCKERS"
+  output_marker "## VERIFICATION FAILED"
+  ask_user "Fix blockers and retry? /mid:verify --phase $PHASE"
+else
+  output_marker "## VERIFICATION INCOMPLETE"
+fi
+```
+
+---
+
+## Execution (Security Mode)
+
+```bash
+VERIFIER_OUTPUT=$(spawn agent \
+  name=mid-verifier \
+  model=haiku \
+  context=$(cat << EOF
+mode: security
+phase: $PHASE
+phase_dir: $PHASE_DIR
+EOF
+))
+```
+
+Parse same as integration mode. Typical blockers:
+- Hardcoded secrets
+- Missing auth checks
+- Vulnerable dependencies
+- SQL injection patterns
+
+---
+
+## Execution (Audit Mode)
+
+Runs all three modes sequentially:
+
+```bash
+for mode in integration security ui; do
+  spawn mid-verifier mode=$mode phase=$PHASE
+  
+  if result contains "FAILED"; then
+    accumulate_blockers
+  fi
+done
+
+if [ ${#blockers[@]} -eq 0 ]; then
+  output_marker "## VERIFICATION PASSED"
+  mid-tools state advance $PHASE
+else
+  output_marker "## VERIFICATION FAILED - $BLOCKER_COUNT issues"
+fi
+```
+
+---
+
+## Success Path
+
+```
+## VERIFICATION PASSED
+
+Criteria: 8/8 ✅
+Duration: 3m
+Phase: Ready for /mid:next
+```
+
+---
+
+## Failure Path
+
+```
+## VERIFICATION FAILED - Security issues
+
+Blockers:
+1. Hardcoded API key in .env.example (line 5)
+   Fix: Move to .env, add to .gitignore
+   
+2. Missing CSRF token on POST /user (route.ts:42)
+   Fix: Add csrf middleware
+
+Action: Apply fixes, then /mid:verify --phase 1
+```
+
+---
+
+## Error Handling
+
+- **No acceptance criteria**: Warn, skip verification
+- **Verifier timeout**: Partial results OK, user can retry
+- **Verification incomplete**: Mark as incomplete, ask for review
+- **Critical blocker**: Escalate to user
+
+---
+
+## Anti-patterns Avoided
+
+✓ Read-only work (haiku agents only)
+✓ Frontmatter-only reads (context budget)
+✓ Exact completion marker checking
+✓ Fast-fail on critical blockers
+✓ No attempt to fix (diagnose + escalate)

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "make-it-done",
+  "version": "0.1.0",
+  "description": "Token-optimized skill orchestration framework for Claude Code",
+  "type": "module",
+  "bin": {
+    "makeitdone": "bin/install.js",
+    "mid": "bin/install.js"
+  },
+  "scripts": {
+    "prepublishOnly": "node -e \"import('fs').then(fs => fs.chmodSync('bin/install.js', '755'))\""
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "orchestration",
+    "toon",
+    "token-optimization",
+    "spec-driven"
+  ],
+  "author": "Ismail Alam",
+  "license": "MIT",
+  "dependencies": {
+    "@toon-format/toon": "^2.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "esbuild": "^0.19.10",
+    "typescript": "^5.3.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "bin/",
+    "makeitdone/",
+    "commands/",
+    "agents/",
+    "README.md",
+    "package.json"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/itzmail/make-it-done.git"
+  },
+  "homepage": "https://github.com/itzmail/make-it-done#readme",
+  "bugs": {
+    "url": "https://github.com/itzmail/make-it-done/issues"
+  }
+}