claude-flow-novice 2.12.0 → 2.13.0

package/claude-assets/commands/cfn/write-plan.md

@@ -1,104 +1,275 @@
-# Write Plan Command
+---
+description: "CFN Loop pre-planning: Generate structured implementation plans with TDD approach"
+argument-hint: "<task description> [--mode=mvp|standard|enterprise]"
+allowed-tools: ["Task", "TodoWrite", "Read", "Write", "Bash"]
+---
 
-## Overview
-The `write-plan` command helps create structured, test-driven implementation plans for claude-flow-novice projects, leveraging our CFN Loop workflow and adaptive context strategies.
+# Write Plan - CFN Loop Pre-Planning
 
-## Core Principles
+Generate structured implementation plan BEFORE executing CFN Loop. Outputs plan document for review.
 
-### 1. Test-Driven Development (TDD)
-- Always start with failure scenarios (Red phase)
-- Implement minimal code to pass tests (Green phase)
-- Refactor for quality and maintainability (Refactor phase)
+🎯 **Use this BEFORE /cfn-loop-cli or /cfn-loop-task**
 
-### 2. CFN Loop Integration
-Utilize the CFN Loop workflow for complex implementations:
-- **Loop 3 (Implementation)**: Create detailed implementation plan
-- **Loop 2 (Validation)**: Comprehensive test and review
-- **Product Owner Decision**: Strategic go/no-go checkpoint
+**Task**: $ARGUMENTS
 
-## Plan Structure Template
+## What This Does
 
+**Pre-planning phase for CFN Loop:**
+1. Analyzes task complexity
+2. Selects appropriate agents
+3. Defines test cases and success criteria
+4. Creates implementation roadmap
+5. Outputs plan document for approval
+
+**Then run:**
+```bash
+# After reviewing plan
+/cfn-loop-cli "Implement JWT authentication" --mode=standard
+# OR
+/cfn-loop-task "Implement JWT authentication" --mode=standard
+```
+
+## Command Options
+
+```bash
+# Standard planning
+/write-plan "Implement JWT authentication"
+
+# MVP planning (faster, simpler)
+/write-plan "Build prototype feature" --mode=mvp
+
+# Enterprise planning (comprehensive)
+/write-plan "Production security system" --mode=enterprise
+```
+
+**Options:**
+- `--mode=<mvp|standard|enterprise>`: Planning depth (default: standard)
+
+## Execution Pattern
+
+### Step 1: Analyze Task
+
+```javascript
+Task("planner", `
+  ANALYZE TASK FOR CFN LOOP PLANNING
+
+  Task: $ARGUMENTS
+  Mode: ${mode}
+
+  ANALYSIS REQUIRED:
+  1. Complexity Assessment:
+     - Estimated files: 1-2 (simple) | 3-5 (standard) | >5 (complex)
+     - Estimated LOC: <200 (simple) | 200-500 (standard) | >500 (complex)
+     - Keywords: security, performance, frontend, mobile, etc.
+
+  2. Agent Selection:
+     - Loop 3 (Implementation): Based on task type
+       * Backend: backend-dev, researcher, devops
+       * Full-stack: backend-dev, react-frontend-engineer, devops
+       * Mobile: mobile-dev, backend-dev
+       * Security: security-specialist, backend-dev
+     - Loop 2 (Validation): Scale by complexity
+       * Simple: reviewer, tester
+       * Standard: +architect, +security-specialist
+       * Complex: +code-analyzer, +performance-benchmarker
+
+  3. Test Cases (TDD Approach):
+     - Red Phase: Failure scenarios
+     - Green Phase: Minimal passing implementation
+     - Refactor Phase: Quality improvements
+
+  4. Success Criteria:
+     - Test coverage target (≥80%)
+     - Performance benchmarks (if applicable)
+     - Security requirements (if applicable)
+     - Deliverables list
+
+  OUTPUT: planning/PLAN_${sanitize($ARGUMENTS)}.md
+`)
+```
+
+### Step 2: Generate Plan Document
+
+**Plan Structure:**
 ```markdown
-# [Feature/Task Name]
+# Implementation Plan: [Task Name]
 
-## Objectives
-- Clear, measurable implementation goals
-- Specific deliverables
+## Task Analysis
+- **Complexity**: Simple | Standard | Complex
+- **Estimated Files**: N
+- **Estimated LOC**: N
+- **Mode**: ${mode}
 
-## Context Injection
-- Epic Context
-- Sprint Context
-- Specific Deliverables
+## Agent Configuration
 
-## Coordination Strategy
-- Coordinator: `cost-savings-cfn-loop-coordinator`
-- Agents: Specify roles (backend-dev, researcher, etc.)
-- Iteration Strategy
+### Loop 3 (Implementation)
+- agent-1 (role)
+- agent-2 (role)
+- agent-3 (role)
 
-## Phase 1: Test and Specification
-### Deliverables
-- [ ] Test script (tests/test-[feature].sh)
-- [ ] Specification document
+### Loop 2 (Validation)
+- reviewer (code review)
+- tester (quality assurance)
+[+ architect, security-specialist for standard/enterprise]
 
-### Test Cases
-- Failure scenarios
-- Edge cases
-- Performance expectations
+### Product Owner
+- product-owner (PROCEED/ITERATE/ABORT decision)
 
-## Phase 2: Minimal Implementation
-### Deliverables
+## Test-Driven Development Plan
+
+### Phase 1: Red (Failure Scenarios)
+**Deliverables:**
+- [ ] Test script: tests/test-[feature].sh
+- [ ] Failure test cases defined
+
+**Test Cases:**
+1. [Test case 1 - expected failure]
+2. [Test case 2 - edge case]
+3. [Test case 3 - performance requirement]
+
+### Phase 2: Green (Minimal Implementation)
+**Deliverables:**
 - [ ] Minimal working implementation
-- [ ] Initial test coverage
+- [ ] All test cases passing
 
-## Phase 3: Refactoring and Optimization
-### Deliverables
-- [ ] Improved code quality
-- [ ] Enhanced test coverage
-- [ ] Performance optimization
+**Implementation Steps:**
+1. [Core functionality]
+2. [Basic validation]
+3. [Minimal error handling]
+
+### Phase 3: Refactor (Quality Improvement)
+**Deliverables:**
+- [ ] Code quality improvements
+- [ ] Enhanced test coverage (≥80%)
+- [ ] Documentation
 
-## Redis Coordination Checkpoints
-- Entry point validation
-- Iteration confidence reporting
-- Context extraction verification
+**Refactoring Goals:**
+1. [Code organization]
+2. [Performance optimization]
+3. [Security hardening]
 
 ## Success Criteria
-- Test coverage ≥ 90%
-- Complexity score < 15
-- Meets architectural guidelines
+
+### Quality Gates
+- Loop 3 Gate: ≥${mode === 'enterprise' ? 0.85 : mode === 'standard' ? 0.75 : 0.70}
+- Loop 2 Consensus: ≥${mode === 'enterprise' ? 0.95 : mode === 'standard' ? 0.90 : 0.80}
+
+### Deliverables
+- [ ] All test cases passing
+- [ ] Test coverage ≥80%
+- [ ] Code complexity <15 per function
+- [ ] Security review complete
+- [ ] Documentation updated
+
+### Performance Benchmarks (if applicable)
+- [Benchmark 1]
+- [Benchmark 2]
 
 ## Potential Blockers
-- Identify potential implementation challenges
-- Pre-emptive mitigation strategies
+
+**Technical:**
+- [Potential blocker 1]
+- [Mitigation strategy]
+
+**Dependencies:**
+- [External dependency 1]
+- [Fallback plan]
 
 ## Iteration Strategy
-- Maximum iterations: 10
-- Confidence threshold: ≥ 0.90
-- Adaptive agent spawning based on feedback
+- Max iterations: ${mode === 'enterprise' ? 15 : mode === 'standard' ? 10 : 5}
+- Confidence threshold: ${mode === 'enterprise' ? 0.95 : mode === 'standard' ? 0.90 : 0.80}
+- Adaptive agent spawning: YES
+
+## Next Steps
+
+1. Review this plan
+2. Execute CFN Loop:
+   \`\`\`bash
+   /cfn-loop-cli "$ARGUMENTS" --mode=${mode}
+   # OR for debugging:
+   /cfn-loop-task "$ARGUMENTS" --mode=${mode}
+   \`\`\`
 ```
 
-## Usage Guidelines
+### Step 3: Output Plan
+
+```javascript
+const planPath = `planning/PLAN_${sanitize($ARGUMENTS)}.md`;
+Write(planPath, planContent);
+
+console.log(`✅ Implementation plan generated: ${planPath}`);
+console.log('');
+console.log('📋 Plan Summary:');
+console.log(`- Complexity: ${complexity}`);
+console.log(`- Loop 3 Agents: ${loop3Agents.length}`);
+console.log(`- Loop 2 Validators: ${loop2Agents.length}`);
+console.log(`- Test Cases: ${testCases.length}`);
+console.log(`- Success Criteria: ${successCriteria.length}`);
+console.log('');
+console.log('Next: Review plan, then execute CFN Loop');
+console.log(`/cfn-loop-cli "$ARGUMENTS" --mode=${mode}`);
+```
+
+## Integration with CFN Loop
+
+**Workflow:**
+```
+1. /write-plan "Task description" --mode=standard
+   ↓ Generates planning/PLAN_task.md
+
+2. Human reviews plan (optional)
+   ↓ Approve or request changes
+
+3. /cfn-loop-cli "Task description" --mode=standard
+   ↓ Executes implementation following plan
+
+4. CFN Loop autonomously implements following TDD phases
+```
+
+## Mode Comparison
+
+| Mode | Complexity | Agents | Test Coverage | Use Case |
+|------|------------|--------|---------------|----------|
+| MVP | Low | 3-4 total | ≥70% | Prototypes, proof-of-concept |
+| Standard | Medium | 5-7 total | ≥80% | Production features |
+| Enterprise | High | 8-10 total | ≥90% | Critical systems, compliance |
+
+## Example Output
 
-### Spawning Plan Creation
-```bash
-/write-plan "Implement JWT Authentication" \
-  --epic-context '{"goal":"Secure API access"}' \
-  --sprint-context '{"sprint":"Authentication MVP"}' \
-  --agents "backend-dev,security-specialist"
 ```
+Analyzing task...
 
-### Example Workflow
-1. Generate initial plan
-2. Review with team via Redis pub/sub
-3. Refine plan based on feedback
-4. Execute using `cost-savings-cfn-loop-coordinator`
+✅ Implementation plan generated: planning/PLAN_jwt_authentication.md
+
+📋 Plan Summary:
+- Complexity: Standard
+- Loop 3 Agents: 3 (backend-dev, researcher, devops)
+- Loop 2 Validators: 4 (reviewer, tester, architect, security-specialist)
+- Test Cases: 8
+- Success Criteria: 6
+
+Next: Review plan, then execute CFN Loop
+/cfn-loop-cli "Implement JWT authentication" --mode=standard
+```
 
 ## Best Practices
-- Keep tasks small and focused
-- Prioritize testability
-- Leverage adaptive context injection
-- Use explicit deliverable tracking
-
-## Notes
-- This is a living document
-- Continuously update based on team feedback
-- Align with claude-flow-novice adaptive context strategies
+
+**When to Use:**
+- ✅ Complex tasks (>3 steps)
+- ✅ Security-critical features
+- ✅ Team collaboration (plan review needed)
+- ✅ Learning CFN Loop workflow
+
+**When to Skip:**
+- Simple bug fixes (go straight to /cfn-loop-cli)
+- Urgent hotfixes (no time for planning)
+- Well-understood patterns (agent knows what to do)
+
+## Related Commands
+
+- **Execute Plan**: `/cfn-loop-cli` (production) or `/cfn-loop-task` (debugging)
+- **Document Results**: `/cfn-loop-document` (after completion)
+
+---
+
+**Version:** 2.0.0 (2025-10-31) - Integrated with CFN Loop v3 architecture

package/dist/cli/config-manager.js

@@ -1,100 +1,118 @@
-import * as fs from "fs/promises";
-import * as path from "path";
-import Ajv from "ajv";
-import * as lodash from "lodash";
-let ConfigManager = class ConfigManager {
-    static _instance = null;
-    configPath;
-    schemaPath;
-    ajv;
-    constructor(){
-        this.configPath = path.join(process.env.HOME || "", ".claude-flow-config.json");
-        this.schemaPath = path.join(__dirname, "../../.claude/skills/config-management/config.json");
-        this.ajv = new Ajv();
-    }
-    static getInstance() {
-        if (!ConfigManager._instance) {
-            ConfigManager._instance = new ConfigManager();
-        }
-        return ConfigManager._instance;
-    }
-    async readConfig() {
-        try {
-            const configContent = await fs.readFile(this.configPath, "utf-8");
-            return JSON.parse(configContent);
-        } catch (error) {
-            // If config doesn't exist, create from schema
-            return this.resetToDefaults();
-        }
-    }
-    async writeConfig(config) {
-        const schemaContent = await fs.readFile(this.schemaPath, "utf-8");
-        const schema = JSON.parse(schemaContent);
-        const validate = this.ajv.compile(schema);
-        if (!validate(config)) {
-            throw new Error("Invalid configuration: " + this.ajv.errorsText(validate.errors));
-        }
-        await fs.writeFile(this.configPath, JSON.stringify(config, null, 2), "utf-8");
+"use strict";
+var __awaiter = this && this.__awaiter || function(thisArg, _arguments, P, generator) {
+    function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve) {
+            resolve(value);
+        });
     }
-    async getValue(keyPath) {
-        const config = await this.readConfig();
-        const value = lodash.get(config, keyPath);
-        if (value === undefined) {
-            // Check if it's a custom key path not in the schema
-            const customConfig = await this.readCustomConfig();
-            return lodash.get(customConfig, keyPath);
+    return new (P || (P = Promise))(function(resolve, reject) {
+        function fulfilled(value) {
+            try {
+                step(generator.next(value));
+            } catch (e) {
+                reject(e);
+            }
         }
-        return value;
-    }
-    async readCustomConfig() {
-        try {
-            const customConfigPath = path.join(process.env.HOME || "", ".claude-flow-custom-config.json");
-            const customConfigContent = await fs.readFile(customConfigPath, "utf-8");
-            return JSON.parse(customConfigContent);
-        } catch (error) {
-            // If custom config doesn't exist or can't be read, return empty object
-            return {};
+        function rejected(value) {
+            try {
+                step(generator["throw"](value));
+            } catch (e) {
+                reject(e);
+            }
         }
-    }
-    async set(key, value) {
-        const config = await this.readConfig();
-        // Type assertion to handle full object
-        if (typeof value === "object" && value !== null) {
-            config[key] = value;
-        } else {
-            throw new Error("Invalid configuration value");
+        function step(result) {
+            result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
-        await this.writeConfig(config);
-    }
-    async getAll() {
-        return this.readConfig();
-    }
-    async resetToDefaults() {
-        const schemaContent = await fs.readFile(this.schemaPath, "utf-8");
-        const schema = JSON.parse(schemaContent);
-        // Extract default values from the schema
-        const defaultConfig = {
-            redis: {
-                host: schema.properties.redis.properties.host.default,
-                port: schema.properties.redis.properties.port.default
-            },
-            agent: {
-                default_strategy: schema.properties.agent.properties.default_strategy.default,
-                max_concurrent_agents: schema.properties.agent.properties.max_concurrent_agents.default,
-                log_level: schema.properties.agent.properties.log_level.default
-            },
-            security: {
-                enabled: schema.properties.security.properties.enabled.default,
-                max_retry_attempts: schema.properties.security.properties.max_retry_attempts.default
-            }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = this && this.__generator || function(thisArg, body) {
+    var _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
         };
-        await this.writeConfig(defaultConfig);
-        return defaultConfig;
     }
-};
-export default ConfigManager;
-
-//# sourceMappingURL=config-manager.js.mapop[1] : void 0,
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
             done: true
         };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow-novice",
-  "version": "2.12.0",
+  "version": "2.13.0",
   "description": "AI agent orchestration framework with namespace-isolated skills, agents, and CFN Loop validation. Safe installation with ~0.01% collision risk.",
   "main": "dist/index.js",
   "type": "module",

package/claude-assets/commands/cfn/auto-compact.md

@@ -1,80 +0,0 @@
----
-description: "Compact conversation history to reduce token usage and maintain context efficiency"
-argument-hint: "[--focus=<topic>] [--threshold=<percentage>]"
-allowed-tools: ["Read", "Write", "Bash", "TodoWrite"]
----
-
-# Auto-Compact - Programmatic Context Compression
-
-Summarize and compress conversation history while preserving key facts, decisions, and context.
-
-**Task**: $ARGUMENTS
-
-## Command Options
-
-```bash
-/auto-compact
-/auto-compact --focus="security decisions and API changes"
-/auto-compact --threshold=70
-/auto-compact --focus="CFN Loop implementation" --threshold=75
-```
-
-**Options:**
-- `--focus=<topic>`: Focus summarization on specific topics (optional)
-- `--threshold=<percentage>`: Token usage threshold to trigger compact (default: 70)
-
-## Current Session Analysis
-
-**Token Usage**: Check current context usage and determine if compaction is needed.
-
-## Compaction Strategy
-
-### What to Preserve
-- Key architectural decisions
-- Active task progress and todos
-- Critical bug fixes and security changes
-- Recent consensus validations
-- Current phase/sprint context
-
-### What to Compress
-- Verbose implementation details
-- Exploratory discussions
-- Resolved issues and completed tasks
-- Historical context from earlier phases
-- Redundant explanations
-
-## Execution Steps
-
-1. **Analyze Current Context**: Review token usage and conversation flow
-2. **Extract Key Facts**: Identify critical decisions, active work, and essential context
-3. **Generate Summary**: Create concise summary preserving:
-   - Active tasks and blockers
-   - Recent decisions (last 10-20% of conversation)
-   - Phase/sprint progress
-   - Technical debt items
-   - Next steps
-4. **Recommend Action**: Suggest when user should run `/compact` with optimal focus
-
-## Output Format
-
-```
-📊 **Context Analysis**
-- Current tokens: X/200k (Y%)
-- Recommendation: [COMPACT NOW | DEFER | MONITOR]
-
-🎯 **Suggested Compact Focus**
-[Generated focus string based on conversation]
-
-💡 **Summary Preview**
-[Key facts to preserve in compact]
-
-✅ **Action Required**
-Run: /compact focus: "[generated focus]"
-```
-
-## Notes
-
-- This command **analyzes** and **recommends** compaction
-- User must manually run `/compact` (built-in command)
-- Threshold default: 70% (140k/200k tokens)
-- Auto-triggered at 95% by Claude Code built-in