omgkit 2.10.0 → 2.11.0

package/plugin/commands/auto/resume.md

@@ -0,0 +1,233 @@
+---
+description: Resume autonomous execution from saved state
+allowed-tools: Task, Read, Write, Edit, Bash, Glob, Grep, AskUserQuestion
+argument-hint: "[--retry | --skip | --from <step>]"
+---
+
+# Resume Autonomous Execution
+
+Resume project development from the last saved state.
+
+## Resume Modes
+
+### Default Resume
+Continue from exact save point:
+```bash
+/auto:resume
+```
+
+### Retry Mode
+Retry the last failed action:
+```bash
+/auto:resume --retry
+```
+
+### Skip Mode
+Skip the problematic step and continue:
+```bash
+/auto:resume --skip
+```
+
+### From Specific Point
+Resume from a specific step:
+```bash
+/auto:resume --from user_authentication
+```
+
+## Resume Process
+
+### 1. Load State
+
+Read `.omgkit/state.yaml`:
+```yaml
+phase: "backend"
+status: "blocked"  # or "checkpoint", "in_progress"
+
+resume_point:
+  phase: "backend"
+  feature: "user_authentication"
+  step: "implement_login"
+  attempt: 2
+
+error_context:
+  message: "Test failed: should hash password"
+  file: "src/services/user.service.ts"
+  line: 45
+```
+
+### 2. Validate Resume
+
+Check if resume is possible:
+- [ ] State file exists
+- [ ] Not in "completed" status
+- [ ] Resume point is valid
+- [ ] No unresolved checkpoints (unless approved)
+
+If checkpoint pending:
+```
+Cannot resume: Checkpoint pending approval.
+
+Run `/auto:approve` to continue or `/auto:reject` with feedback.
+```
+
+### 3. Restore Context
+
+Load relevant context:
+1. **Memory files**: `.omgkit/memory/context/`
+2. **Generated artifacts**: `.omgkit/generated/`
+3. **Current feature state**: Progress, tests, issues
+4. **Error context**: If resuming from error
+
+### 4. Execute Resume
+
+Based on mode:
+
+#### Default/Retry
+```
+Resuming from: {phase} > {feature} > {step}
+Attempt: {attempt + 1}
+
+[Previous context restored]
+[Continuing execution...]
+```
+
+#### Skip
+```
+Skipping: {step}
+Marking as: SKIPPED (requires manual completion)
+
+Continuing with next step: {next_step}
+```
+
+#### From Specific
+```
+Resetting to: {specified_step}
+Warning: Progress after this point will be re-executed.
+
+Continuing from: {specified_step}
+```
+
+### 5. Continue Execution
+
+After resume setup:
+1. Execute remaining steps in current feature
+2. Continue with `/auto:start` logic
+3. Handle checkpoints and quality gates normally
+
+## Recovery Strategies
+
+### On Test Failure
+
+```yaml
+error_type: "test_failure"
+recovery:
+  - analyze_failure: true
+  - suggest_fix: true
+  - auto_fix_confidence: 0.8  # If > 0.7, attempt auto-fix
+```
+
+If auto-fix confidence is high:
+1. Analyze the failure
+2. Generate fix
+3. Apply fix
+4. Re-run tests
+5. If still failing after 2 attempts, ask for help
+
+### On Build Failure
+
+```yaml
+error_type: "build_failure"
+recovery:
+  - check_imports: true
+  - check_types: true
+  - suggest_fix: true
+```
+
+1. Analyze build error
+2. Check for common issues (imports, types, syntax)
+3. Suggest or apply fix
+4. Retry build
+
+### On External Failure
+
+```yaml
+error_type: "external_failure"  # API, database, etc.
+recovery:
+  - retry_with_backoff: true
+  - max_retries: 3
+```
+
+1. Wait with exponential backoff
+2. Retry operation
+3. If persistent, mark as blocked
+
+## State Updates on Resume
+
+```yaml
+# Before resume
+status: "blocked"
+resume_point:
+  attempt: 2
+
+# After successful resume start
+status: "in_progress"
+resume_point:
+  attempt: 3
+  resumed_at: "2024-01-15T10:30:00Z"
+```
+
+## Output
+
+```
+## Resuming Autonomous Execution
+
+**Project:** [Name]
+**Resume Point:** [phase] > [feature] > [step]
+**Previous Status:** [blocked/checkpoint]
+**Attempt:** [number]
+
+### Context Restored
+- ✓ Memory context loaded
+- ✓ Feature state restored
+- ✓ Error context analyzed
+
+### Recovery Action
+[Describe what will be done to recover]
+
+### Continuing...
+
+[Normal execution output continues]
+```
+
+## Error Handling
+
+If resume fails:
+
+```
+## Resume Failed
+
+**Reason:** [Why resume failed]
+
+### State
+- Phase: [phase]
+- Feature: [feature]
+- Step: [step]
+
+### Options
+1. `/auto:resume --skip` - Skip this step
+2. `/auto:resume --from {previous_step}` - Go back
+3. Fix manually and run `/auto:resume --retry`
+
+### Manual Recovery
+If needed, you can:
+1. Edit `.omgkit/state.yaml` directly
+2. Fix the code issue
+3. Run `/auto:resume`
+```
+
+## Safeguards
+
+1. **Maximum Attempts**: After 3 failed attempts at same step, force checkpoint
+2. **Infinite Loop Detection**: Track step history, detect cycles
+3. **State Backup**: Before each resume, backup current state
+4. **Rollback Option**: Can restore to any previous checkpoint

package/plugin/commands/auto/start.md

@@ -0,0 +1,212 @@
+---
+description: Start autonomous execution from current state
+allowed-tools: Task, Read, Write, Edit, Bash, Glob, Grep, AskUserQuestion
+argument-hint: "[--from-phase <phase>]"
+---
+
+# Autonomous Execution Start
+
+Begin autonomous project development from current state.
+
+## Prerequisites
+
+Before starting, verify:
+1. `.omgkit/state.yaml` exists (created by `/auto:init`)
+2. `.omgkit/generated/prd.md` exists (discovery completed)
+3. No pending checkpoints require approval
+
+## Execution Flow
+
+### 1. Load State
+
+```yaml
+# Read from .omgkit/state.yaml
+project:
+  name: "Project Name"
+  type: "saas"
+  archetype: "saas-mvp"
+phase: "planning"  # Current phase
+status: "ready"    # ready | in_progress | checkpoint | blocked | completed
+```
+
+### 2. Load Archetype
+
+Based on `project.archetype`, load the corresponding archetype definition:
+- `plugin/templates/autonomous/archetypes/{archetype}.yaml`
+
+### 3. Determine Next Actions
+
+From the archetype phases, find the current phase and its:
+- **workflows**: Execute these workflows in order
+- **features**: Execute per-feature workflows
+- **steps**: Execute manual steps
+- **checkpoint**: If true, pause for user approval
+
+### 4. Execute Phase
+
+For each item in the current phase:
+
+#### If workflow:
+```
+Run workflow: {workflow-name}
+```
+
+#### If feature (dynamic phase):
+```
+For each feature in .omgkit/generated/features.yaml:
+  1. Run per_feature workflows (feature, test, code-review)
+  2. Run quality_gates.after_feature checks
+  3. Update feature status in state
+```
+
+#### If step:
+```
+Execute step actions
+Update step completion in state
+```
+
+### 5. Quality Gates
+
+After completing phase actions, run quality gates:
+
+```yaml
+quality_gates:
+  after_feature:
+    - command: "npm test"
+      required: true
+  before_checkpoint:
+    - command: "npm run build"
+      required: true
+```
+
+If any required gate fails:
+1. Log the failure
+2. Set status to "blocked"
+3. Report to user with fix suggestions
+
+### 6. Update State
+
+After each significant action:
+```yaml
+# Update .omgkit/state.yaml
+progress:
+  current_feature: "feature_id"
+  current_step: 3
+  steps_completed: ["step1", "step2"]
+```
+
+### 7. Handle Checkpoints
+
+When reaching a checkpoint:
+1. Set `status: "checkpoint"`
+2. Set `checkpoint.pending: true`
+3. Generate checkpoint summary
+4. Pause and notify user
+
+```
+## Checkpoint: {phase_name}
+
+### Completed
+- [x] Step 1
+- [x] Step 2
+
+### Generated Artifacts
+- path/to/artifact1
+- path/to/artifact2
+
+### Quality Gate Results
+- npm test: PASSED
+- npm run build: PASSED
+
+**ACTION REQUIRED**: Run `/auto:approve` to continue or `/auto:reject` with feedback.
+```
+
+## Autonomy Levels
+
+Respect autonomy levels from archetype:
+
+```yaml
+autonomy:
+  default_level: 1
+  rules:
+    - patterns: ["**/migrations/**"]
+      level: 3  # Requires explicit approval
+    - patterns: ["**/auth/**"]
+      level: 3
+```
+
+**Level 0**: Auto-execute, no confirmation
+**Level 1**: Execute with notification
+**Level 2**: Preview before executing, quick approval
+**Level 3**: Full review required
+**Level 4**: Human must do it
+
+For levels 2-4:
+1. Show what will be done
+2. Wait for `/auto:approve` or `/auto:reject`
+
+## Memory Updates
+
+After significant work:
+1. Update `.omgkit/memory/journal/{date}.md`
+2. Record decisions in `.omgkit/memory/decisions/`
+3. Update context files as needed
+
+## Error Handling
+
+On error:
+1. Log error details to `.omgkit/logs/`
+2. Set `status: "blocked"`
+3. Store error context for resume
+4. Notify user with:
+   - What failed
+   - Why it might have failed
+   - Suggested fixes
+   - How to resume after fixing
+
+## Resume Support
+
+State is saved after every action for reliable resume:
+```yaml
+resume_point:
+  phase: "backend"
+  feature: "user_authentication"
+  step: "implement_login"
+  attempt: 2
+```
+
+## Output
+
+Display progress as work proceeds:
+
+```
+## Autonomous Execution Started
+
+**Project:** [Name]
+**Phase:** [Current Phase]
+**Mode:** [Archetype]
+
+### Progress
+
+[■■■■■□□□□□] 50% - Implementing user_authentication
+
+#### Current Task
+Implementing login endpoint...
+
+#### Recent Actions
+- ✓ Created User model
+- ✓ Added password hashing
+- → Implementing login route
+
+#### Next Up
+- Password reset
+- Session management
+```
+
+## Commands During Execution
+
+User can run these during execution:
+- `/auto:status` - Show detailed status
+- `/auto:pause` - Pause after current task
+- `/auto:checkpoint` - Force a checkpoint
+- `/auto:reject [reason]` - Stop and provide feedback

package/plugin/commands/auto/status.md

@@ -0,0 +1,212 @@
+---
+description: Show autonomous project status and progress
+allowed-tools: Read, Glob
+argument-hint: "[--verbose]"
+---
+
+# Autonomous Project Status
+
+Display comprehensive status of the autonomous project development.
+
+## Status Display
+
+### 1. Load Project State
+
+Read from `.omgkit/state.yaml`:
+- Project info
+- Current phase
+- Current status
+- Progress data
+- Checkpoint state
+
+### 2. Load Archetype
+
+Load archetype definition to understand:
+- Total phases
+- Phase order
+- Remaining work
+
+### 3. Calculate Progress
+
+```
+Total Progress = (completed_phases / total_phases) * 100
+
+Phase Progress = (completed_steps / total_steps) * 100
+
+Feature Progress = (completed_features / total_features) * 100
+```
+
+### 4. Generate Status Report
+
+## Output Format
+
+```
+## Project Status: [Project Name]
+
+**Type:** [project_type] | **Archetype:** [archetype_name]
+**Status:** [status_emoji] [status_text]
+**Started:** [date] | **Last Activity:** [date]
+
+### Overall Progress
+[████████░░░░░░░░░░░░] 42%
+
+### Phase Progress
+
+| Phase | Status | Progress |
+|-------|--------|----------|
+| ✅ Discovery | Complete | 100% |
+| ✅ Planning | Complete | 100% |
+| 🔄 Foundation | In Progress | 60% |
+| ⏳ Backend | Pending | 0% |
+| ⏳ Frontend | Pending | 0% |
+| ⏳ Integration | Pending | 0% |
+| ⏳ Hardening | Pending | 0% |
+| ⏳ Deployment | Pending | 0% |
+
+### Current Phase: Foundation
+
+**Progress:** [████████░░] 60%
+
+| Task | Status |
+|------|--------|
+| ✅ Project scaffolding | Complete |
+| ✅ Database setup | Complete |
+| 🔄 UI foundation | In Progress |
+
+### Features Status
+
+| Feature | Phase | Status | Tests |
+|---------|-------|--------|-------|
+| User Auth | Backend | ✅ Complete | 12/12 |
+| User Profile | Backend | 🔄 In Progress | 5/8 |
+| Dashboard | Frontend | ⏳ Pending | 0/0 |
+
+### Quality Gates
+
+| Gate | Status | Last Run |
+|------|--------|----------|
+| npm test | ✅ Pass | 2 min ago |
+| npm run build | ✅ Pass | 5 min ago |
+| Coverage (80%) | ⚠️ 76% | 2 min ago |
+
+### Pending Decisions
+
+1. **Database Index Strategy** (Level 2)
+   - Suggested: Add composite index on users(email, status)
+   - Waiting for: Quick approval
+
+### Recent Activity
+
+- [10:45] Completed UserService.create()
+- [10:42] Added password validation
+- [10:38] Created User model with Prisma
+- [10:35] Started feature: user_authentication
+
+### Artifacts Generated
+
+- `.omgkit/generated/prd.md` ✅
+- `.omgkit/generated/schema.sql` ✅
+- `.omgkit/generated/api-spec.md` ✅
+- `src/models/user.ts` ✅
+- `src/services/user.service.ts` 🔄
+
+### Next Actions
+
+1. Complete UserService implementation
+2. Write integration tests
+3. Run code review workflow
+
+---
+
+**Commands:**
+- `/auto:resume` - Continue execution
+- `/auto:approve` - Approve pending decisions
+- `/auto:checkpoint` - Force checkpoint
+```
+
+## Verbose Mode
+
+With `--verbose` flag, also show:
+
+### Detailed Logs
+```
+### Execution Log (Last 50 entries)
+
+[10:45:23] INFO  Completed: UserService.create()
+[10:45:22] DEBUG Running test: user.service.test.ts
+[10:45:20] INFO  Generated: src/services/user.service.ts
+[10:45:18] DEBUG Analyzing feature requirements
+...
+```
+
+### Memory State
+```
+### Memory Context
+
+**Active Context Files:**
+- project-brief.md (1.2KB)
+- current-feature.md (0.8KB)
+
+**Decisions Made:** 5
+**Journal Entries:** 3
+**Patterns Recorded:** 2
+```
+
+### Resource Usage
+```
+### Session Stats
+
+- API Calls: 142
+- Tokens Used: ~45,000
+- Time Elapsed: 23 minutes
+- Files Modified: 12
+- Tests Run: 28
+```
+
+## Status Codes
+
+| Status | Emoji | Meaning |
+|--------|-------|---------|
+| ready | 🟢 | Ready to start/continue |
+| in_progress | 🔄 | Currently executing |
+| checkpoint | ⏸️ | Paused for approval |
+| blocked | 🔴 | Error or issue |
+| completed | ✅ | All phases done |
+
+## Special States
+
+### Checkpoint State
+```
+### ⏸️ CHECKPOINT: Planning Phase Complete
+
+**Reason:** Phase completion requires approval
+**Pending Since:** 5 minutes ago
+
+**Review Required:**
+- `.omgkit/generated/schema.sql` - Database schema
+- `.omgkit/generated/api-spec.md` - API specification
+
+**Actions:**
+- `/auto:approve` - Approve and continue
+- `/auto:reject "feedback"` - Request changes
+```
+
+### Blocked State
+```
+### 🔴 BLOCKED: Test Failure
+
+**Error:** 3 tests failing in user.service.test.ts
+**Since:** 2 minutes ago
+
+**Failed Tests:**
+1. should hash password correctly
+2. should validate email format
+3. should prevent duplicate emails
+
+**Suggested Fix:**
+Check the bcrypt import in user.service.ts
+
+**Actions:**
+- Fix the issue manually
+- `/auto:resume` - Retry after fixing
+```