claude-flow-novice 1.2.1 → 1.3.1

package/.claude-flow-novice/preferences/language-configs/python.json

@@ -0,0 +1,50 @@
+{
+  "_description": "Python Language Configuration - Defines Python project patterns, frameworks, and development best practices",
+  "_purpose": "This configuration helps detect Python projects and applies Python-specific tooling, linting, and testing patterns",
+  "_used_in": [
+    "src/language/language-detector.js (Python project detection)",
+    "src/language/framework-detector.js (Django/Flask/FastAPI detection)",
+    "src/hooks/enhanced/personalization-hooks.js (Python-specific behavior)"
+  ],
+
+  "language": "python",
+  "_language_description": "Primary language identifier for Python projects",
+
+  "frameworks": ["django", "flask", "fastapi", "pytest", "pandas", "numpy"],
+  "_frameworks_description": "Common Python frameworks and libraries that indicate specialized project types",
+
+  "best_practices": {
+    "_description": "Python development standards and tooling recommendations",
+    "file_structure": {
+      "src": "Source modules",
+      "tests": "Test files (pytest)",
+      "docs": "Documentation and examples",
+      "config": "Configuration files",
+      "scripts": "Utility scripts"
+    },
+    "linting": {
+      "black": true,
+      "flake8": true,
+      "mypy": true,
+      "config_files": ["pyproject.toml", ".flake8", "mypy.ini"]
+    },
+    "testing": {
+      "framework": "pytest",
+      "patterns": ["test_*.py", "*_test.py"],
+      "coverage": true
+    },
+    "dependencies": {
+      "package_manager": "pip",
+      "requirements": "requirements.txt",
+      "dev_dependencies": ["black", "flake8", "pytest", "mypy"],
+      "virtual_env": true
+    }
+  },
+  "claude_md_template": {
+    "concurrent_patterns": "Use asyncio for async operations, threading for I/O",
+    "error_handling": "Use try-except blocks, create custom exceptions",
+    "code_style": "Follow PEP 8, use type hints, docstrings",
+    "testing": "Write pytest tests, use fixtures, parametrize tests",
+    "performance": "Use list comprehensions, avoid premature optimization"
+  }
+}

package/.claude-flow-novice/preferences/language-configs/rust.json

@@ -0,0 +1,237 @@
+{
+  "_description": "Rust Language Configuration - Comprehensive Rust project detection, frameworks, and performance-focused development practices",
+  "_purpose": "This configuration provides complete Rust ecosystem support including web frameworks, async runtimes, testing, and performance optimization",
+  "_used_in": [
+    "src/language/language-detector.js (Rust project detection)",
+    "src/language/framework-detector.js (Axum/Actix/Rocket detection)",
+    "src/hooks/enhanced/personalization-hooks.js (Rust-specific behavior)",
+    "config/hooks/fast-file-testing.cjs (Rust testing integration)"
+  ],
+
+  "language": "rust",
+  "_language_description": "Primary language identifier for Rust projects",
+
+  "name": "Rust",
+  "_name_description": "Display name for the language",
+
+  "extensions": [".rs", ".toml"],
+  "_extensions_description": "File extensions that identify Rust projects (.rs=source files, .toml=configuration)",
+
+  "packageFiles": ["Cargo.toml", "Cargo.lock", "rust-toolchain.toml", ".cargo/config.toml"],
+  "_packageFiles_description": "Configuration files that indicate a Rust project and its tooling setup",
+  "frameworks": {
+    "web": {
+      "axum": {
+        "patterns": ["axum", "tokio"],
+        "priority": 1,
+        "description": "Modern async web framework built on tokio"
+      },
+      "actix-web": {
+        "patterns": ["actix-web", "actix"],
+        "priority": 2,
+        "description": "Powerful, pragmatic, and extremely fast web framework"
+      },
+      "rocket": {
+        "patterns": ["rocket"],
+        "priority": 3,
+        "description": "Type-safe, secure web framework with code generation"
+      },
+      "warp": {
+        "patterns": ["warp"],
+        "priority": 4,
+        "description": "Composable, async web framework"
+      }
+    },
+    "async": {
+      "tokio": {
+        "patterns": ["tokio"],
+        "priority": 1,
+        "description": "Async runtime for Rust"
+      },
+      "async-std": {
+        "patterns": ["async-std"],
+        "priority": 2,
+        "description": "Alternative async runtime"
+      }
+    },
+    "cli": {
+      "clap": {
+        "patterns": ["clap"],
+        "priority": 1,
+        "description": "Command line argument parser"
+      },
+      "structopt": {
+        "patterns": ["structopt"],
+        "priority": 2,
+        "description": "Parse command line arguments by defining structs"
+      }
+    },
+    "serialization": {
+      "serde": {
+        "patterns": ["serde", "serde_json", "serde_yaml"],
+        "priority": 1,
+        "description": "Serialization framework"
+      }
+    }
+  },
+  "testFrameworks": {
+    "built-in": {
+      "patterns": ["#[test]", "#[cfg(test)]", "tests/"],
+      "priority": 1,
+      "description": "Rust's built-in testing framework"
+    },
+    "proptest": {
+      "patterns": ["proptest"],
+      "priority": 2,
+      "description": "Property-based testing framework"
+    },
+    "criterion": {
+      "patterns": ["criterion"],
+      "priority": 3,
+      "description": "Benchmarking library"
+    },
+    "quickcheck": {
+      "patterns": ["quickcheck"],
+      "priority": 4,
+      "description": "QuickCheck-style property testing"
+    }
+  },
+  "best_practices": {
+    "file_structure": {
+      "src": "Source code modules (lib.rs, main.rs, modules/)",
+      "tests": "Integration tests directory",
+      "benches": "Benchmark tests",
+      "examples": "Example code",
+      "docs": "Documentation and README",
+      "target": "Build artifacts (auto-generated)",
+      ".cargo": "Cargo configuration"
+    },
+    "linting": {
+      "clippy": true,
+      "rustfmt": true,
+      "rust_analyzer": true,
+      "config_files": ["rustfmt.toml", "clippy.toml", ".cargo/config.toml"],
+      "commands": {
+        "format": "cargo fmt",
+        "lint": "cargo clippy -- -D warnings",
+        "check": "cargo check"
+      }
+    },
+    "testing": {
+      "framework": "built-in",
+      "patterns": ["#[test]", "tests/*.rs", "*_test.rs"],
+      "coverage": "cargo tarpaulin",
+      "commands": {
+        "test": "cargo test",
+        "test_release": "cargo test --release",
+        "bench": "cargo bench",
+        "doc_test": "cargo test --doc"
+      }
+    },
+    "security": {
+      "cargo_audit": {
+        "enabled": true,
+        "command": "cargo audit",
+        "description": "Audit dependencies for security vulnerabilities"
+      },
+      "cargo_deny": {
+        "enabled": true,
+        "command": "cargo deny check",
+        "config_file": "deny.toml",
+        "description": "Lint dependencies for licensing, bans, and advisories"
+      }
+    },
+    "dependencies": {
+      "package_manager": "cargo",
+      "manifest": "Cargo.toml",
+      "lock_file": "Cargo.lock",
+      "dev_dependencies": ["tokio-test", "proptest", "criterion", "cargo-audit", "cargo-deny"],
+      "commands": {
+        "build": "cargo build",
+        "build_release": "cargo build --release",
+        "run": "cargo run",
+        "clean": "cargo clean",
+        "update": "cargo update",
+        "tree": "cargo tree"
+      }
+    },
+    "performance": {
+      "optimization": {
+        "release_profile": {
+          "lto": true,
+          "codegen_units": 1,
+          "panic": "abort"
+        },
+        "build_flags": ["--release", "-C target-cpu=native"]
+      },
+      "profiling": {
+        "tools": ["perf", "valgrind", "flamegraph"],
+        "commands": {
+          "flamegraph": "cargo flamegraph",
+          "bench": "cargo bench"
+        }
+      }
+    }
+  },
+  "claude_md_template": {
+    "concurrent_patterns": "Use tokio for async operations, rayon for parallel computation, channels for communication",
+    "error_handling": "Use Result<T, E> types, create custom error enums with thiserror, propagate with ? operator",
+    "code_style": "Follow rustfmt, use clippy lints, prefer owned types in APIs, use lifetimes sparingly",
+    "testing": "Write unit tests with #[test], integration tests in tests/, use proptest for property testing",
+    "performance": "Profile before optimizing, use zero-cost abstractions, prefer stack allocation, avoid unnecessary clones",
+    "memory_safety": "Leverage ownership system, use Rc/Arc for shared ownership, RefCell/Mutex for interior mutability",
+    "concurrency": "Use tokio for async I/O, rayon for CPU-bound parallelism, avoid shared mutable state"
+  },
+  "build_commands": {
+    "development": {
+      "build": "cargo build",
+      "test": "cargo test",
+      "run": "cargo run",
+      "check": "cargo check",
+      "format": "cargo fmt",
+      "lint": "cargo clippy",
+      "doc": "cargo doc --open"
+    },
+    "production": {
+      "build": "cargo build --release",
+      "test": "cargo test --release",
+      "strip": "cargo build --release && strip target/release/*",
+      "optimize": "cargo build --release --target=x86_64-unknown-linux-musl"
+    },
+    "quality": {
+      "audit": "cargo audit",
+      "deny": "cargo deny check",
+      "outdated": "cargo outdated",
+      "coverage": "cargo tarpaulin --out Html"
+    }
+  },
+  "bestPractices": [
+    "Use Rust's ownership system to prevent memory bugs",
+    "Prefer Result<T, E> over panicking for error handling",
+    "Use cargo clippy for additional linting beyond the compiler",
+    "Write comprehensive tests including edge cases",
+    "Document public APIs with rustdoc comments",
+    "Use serde for serialization instead of manual implementations",
+    "Leverage the type system for compile-time guarantees",
+    "Use async/await for I/O operations with tokio runtime",
+    "Profile before optimizing - Rust is fast by default",
+    "Use cargo-audit regularly to check for security vulnerabilities"
+  ],
+  "concurrentPatterns": {
+    "agentCoordination": "Use Claude Code's Task tool for parallel agent execution with Rust specialization",
+    "fileOperations": "Batch all Read/Write/Edit operations in single message for Cargo.toml and source files",
+    "bashCommands": "Execute multiple cargo commands with && separators (cargo fmt && cargo clippy && cargo test)",
+    "todoManagement": "Batch ALL todos in ONE TodoWrite call (5-10+ minimum) with Rust-specific tasks",
+    "cargoWorkflows": "Combine build, test, and quality checks in single execution pipeline"
+  },
+  "workspace_support": {
+    "enabled": true,
+    "config_file": "Cargo.toml",
+    "member_detection": ["members", "exclude"],
+    "commands": {
+      "workspace_build": "cargo build --workspace",
+      "workspace_test": "cargo test --workspace",
+      "workspace_check": "cargo check --workspace"
+    }
+  }
+}

package/.claude-flow-novice/preferences/language-configs/typescript.json

@@ -0,0 +1,54 @@
+{
+  "_description": "TypeScript Language Configuration - Defines TypeScript project patterns and type-safe development practices",
+  "_purpose": "This configuration enables TypeScript project detection and applies TypeScript-specific tooling and best practices",
+  "_used_in": [
+    "src/language/language-detector.js (TypeScript project detection)",
+    "src/language/framework-detector.js (React/Angular/Node TypeScript detection)",
+    "src/hooks/enhanced/personalization-hooks.js (TypeScript-specific behavior)"
+  ],
+
+  "language": "typescript",
+  "_language_description": "Primary language identifier for TypeScript projects",
+
+  "frameworks": ["node", "express", "react", "angular", "next", "nest"],
+  "_frameworks_description": "Common TypeScript frameworks that indicate specialized project architectures",
+
+  "best_practices": {
+    "_description": "TypeScript development standards and type-safe coding practices",
+    "file_structure": {
+      "src": "Source code with types",
+      "tests": "Test files (Jest, Vitest)",
+      "docs": "Documentation",
+      "config": "Configuration files",
+      "types": "Type definitions"
+    },
+    "linting": {
+      "eslint": true,
+      "prettier": true,
+      "typescript_eslint": true,
+      "config_files": [".eslintrc.json", ".prettierrc.json", "tsconfig.json"]
+    },
+    "testing": {
+      "framework": "jest",
+      "patterns": ["*.test.ts", "*.spec.ts"],
+      "coverage": true
+    },
+    "dependencies": {
+      "package_manager": "npm",
+      "dev_dependencies": ["typescript", "@types/node", "eslint", "prettier", "jest"],
+      "scripts": {
+        "build": "tsc",
+        "test": "jest",
+        "lint": "eslint src/",
+        "typecheck": "tsc --noEmit"
+      }
+    }
+  },
+  "claude_md_template": {
+    "concurrent_patterns": "Use Promise.all(), proper async/await with types",
+    "error_handling": "Define error types, use Result<T, E> patterns",
+    "code_style": "Strict TypeScript config, interface over type when possible",
+    "testing": "Type-safe tests, mock with proper typing",
+    "performance": "Leverage tree shaking, use strict compiler options"
+  }
+}

package/.claude-flow-novice/preferences/project-local.json

@@ -0,0 +1,91 @@
+{
+  "_description": "Project-Local Preferences - Project-specific overrides and configurations that supplement global user preferences",
+  "_purpose": "This file contains project-specific settings that override global preferences and adapt behavior to this particular project's needs",
+  "_used_in": [
+    "src/preferences/preference-manager.js (preference merging and override logic)",
+    "src/language/language-detector.js (project type and language detection)",
+    "src/analytics/project-analytics.js (project-specific analytics and learning)"
+  ],
+
+  "project": {
+    "_description": "Basic project identification and language information",
+    "name": "claude-flow-novice",
+    "_name_description": "Project identifier used for analytics and preference scoping",
+
+    "type": "javascript",
+    "_type_description": "Primary project type detected by the system",
+
+    "framework": "node",
+    "_framework_description": "Primary framework detected (node, react, django, etc.)",
+
+    "initialized": "2025-09-24T14:52:00.000Z",
+    "_initialized_description": "Timestamp when project preferences were first created",
+
+    "language_detected": "javascript",
+    "_language_detected_description": "Primary language detected by file analysis",
+
+    "primary_language": "javascript",
+    "_primary_language_description": "Main programming language for this project",
+
+    "secondary_languages": ["typescript", "python"],
+    "_secondary_languages_description": "Additional languages detected in the project codebase"
+  },
+
+  "overrides": {
+    "_description": "Project-specific preference overrides that take precedence over global user settings",
+    "documentation": {
+      "_description": "Documentation generation overrides for this specific project",
+      "claude_md_generated": true,
+      "_claude_md_generated_description": "Whether CLAUDE.md was auto-generated for this project",
+
+      "custom_best_practices": true,
+      "_custom_best_practices_description": "Enable project-specific best practices in generated documentation",
+
+      "project_specific_rules": [
+        "Focus on concurrent execution patterns",
+        "Emphasize SPARC methodology",
+        "Highlight swarm coordination"
+      ],
+      "_project_specific_rules_description": "Custom rules that agents should follow for this specific project"
+    },
+
+    "tone": {
+      "_description": "Communication style overrides for this project",
+      "technical_focus": true,
+      "_technical_focus_description": "Emphasize technical depth over general explanations for this project",
+
+      "minimize_fluff": true,
+      "_minimize_fluff_description": "Reduce celebratory language and focus on actionable information"
+    },
+
+    "agents": {
+      "_description": "Agent behavior and coordination preferences specific to this project",
+      "preferred_agent_types": ["coder", "reviewer", "tester", "researcher"],
+      "_preferred_agent_types_description": "Default agent types to prioritize for this project's workflow",
+
+      "auto_spawn_patterns": {
+        "_description": "Automatic agent spawning patterns based on task types",
+        "development": ["coder", "tester"],
+        "_development_description": "Agents to spawn automatically for development tasks",
+
+        "analysis": ["researcher", "reviewer"],
+        "_analysis_description": "Agents to spawn automatically for analysis tasks",
+
+        "architecture": ["system-architect", "planner"],
+        "_architecture_description": "Agents to spawn automatically for architectural decisions"
+      }
+    }
+  },
+
+  "analytics": {
+    "_description": "Project-specific analytics and learning settings",
+    "track_performance": true,
+    "_track_performance_description": "Enable performance tracking for this project's workflows",
+
+    "optimize_workflows": true,
+    "_optimize_workflows_description": "Allow system to optimize workflows based on this project's patterns",
+
+    "learn_patterns": true,
+    "_learn_patterns_description": "Enable pattern learning to improve future task handling for similar projects"
+  }
+}

package/.claude-flow-novice/preferences/resource-delegation.json

@@ -0,0 +1,120 @@
+{
+  "resourceDelegation": {
+    "mode": "adaptive",
+    "description": "Controls how resource-heavy commands are executed across swarm agents",
+    "options": {
+      "distributed": {
+        "name": "Distributed Execution",
+        "description": "All agents execute heavy commands simultaneously",
+        "pros": ["Faster parallel execution", "Better resource utilization"],
+        "cons": ["Higher system load", "Potential resource conflicts"],
+        "bestFor": ["Light workloads", "High-performance systems", "Independent tasks"]
+      },
+      "single-delegate": {
+        "name": "Single Agent Delegation",
+        "description": "One agent executes heavy commands, shares results with others",
+        "pros": ["Lower system load", "Prevents resource conflicts", "Better reliability"],
+        "cons": ["Sequential execution", "Single point of failure"],
+        "bestFor": ["Resource-constrained systems", "Complex builds", "Heavy test suites"]
+      },
+      "adaptive": {
+        "name": "Adaptive Resource Management",
+        "description": "Automatically chooses the best strategy based on current conditions",
+        "pros": ["Optimal performance", "Dynamic adaptation", "Balanced resource usage"],
+        "cons": ["Slight overhead for decision-making"],
+        "bestFor": ["Most use cases", "Variable workloads", "Production environments"]
+      }
+    },
+    "heavyCommandThreshold": 5000,
+    "maxConcurrentHeavyCommands": 2,
+    "preferredDelegate": "auto",
+    "resourceLimits": {
+      "cpu": 80,
+      "memory": 75,
+      "network": 90,
+      "description": "System resource thresholds that trigger single-delegate mode"
+    }
+  },
+  "commandCategories": {
+    "test": {
+      "commands": ["npm test", "npm run test", "jest", "vitest", "pytest", "cargo test", "go test", "mvn test"],
+      "defaultStrategy": "single-delegate",
+      "reasoning": "Test suites often require substantial resources and can conflict when run in parallel"
+    },
+    "build": {
+      "commands": ["npm run build", "webpack", "vite build", "tsc", "cargo build", "go build", "gradle build"],
+      "defaultStrategy": "adaptive",
+      "reasoning": "Build processes vary in resource requirements; adaptive mode optimizes based on conditions"
+    },
+    "compile": {
+      "commands": ["tsc", "javac", "gcc", "clang", "rustc"],
+      "defaultStrategy": "single-delegate",
+      "reasoning": "Compilation can be memory-intensive and benefit from dedicated resources"
+    },
+    "lint": {
+      "commands": ["eslint", "prettier", "flake8", "black", "clippy"],
+      "defaultStrategy": "distributed",
+      "reasoning": "Linting is typically lightweight and can be safely distributed"
+    },
+    "package": {
+      "commands": ["npm pack", "docker build", "zip", "tar"],
+      "defaultStrategy": "single-delegate",
+      "reasoning": "Package creation often involves file system operations that can conflict"
+    }
+  },
+  "delegateSelection": {
+    "strategies": {
+      "auto": "Automatically select best agent based on performance metrics and current load",
+      "performance-optimized": "Always select the highest-performing agent",
+      "round-robin": "Rotate delegate selection among available agents",
+      "load-balanced": "Select agent with lowest current resource utilization",
+      "capability-based": "Select agent with most relevant capabilities for the task"
+    },
+    "selectionCriteria": {
+      "performanceWeight": 0.4,
+      "loadWeight": 0.3,
+      "capabilityWeight": 0.2,
+      "availabilityWeight": 0.1
+    }
+  },
+  "monitoring": {
+    "trackPerformance": true,
+    "collectMetrics": true,
+    "alertThresholds": {
+      "highCpuUsage": 85,
+      "highMemoryUsage": 90,
+      "executionTimeout": 300000,
+      "consecutiveFailures": 3
+    },
+    "optimizationHints": {
+      "enableAutoTuning": true,
+      "suggestConfigChanges": true,
+      "trackSuccessPatterns": true
+    }
+  },
+  "examples": {
+    "scenarios": [
+      {
+        "name": "Large Test Suite",
+        "description": "Running comprehensive test suites with high memory requirements",
+        "recommendedMode": "single-delegate",
+        "commands": ["npm run test:all", "pytest tests/", "cargo test --release"],
+        "reasoning": "Prevents memory conflicts and ensures consistent test environment"
+      },
+      {
+        "name": "Multi-Package Build",
+        "description": "Building multiple packages or modules simultaneously",
+        "recommendedMode": "adaptive",
+        "commands": ["lerna run build", "nx run-many --target=build"],
+        "reasoning": "Adapts to system load and optimizes parallel vs sequential execution"
+      },
+      {
+        "name": "Development Workflow",
+        "description": "Standard development tasks like linting and type checking",
+        "recommendedMode": "distributed",
+        "commands": ["eslint src/", "prettier --check", "tsc --noEmit"],
+        "reasoning": "These lightweight tasks benefit from parallel execution"
+      }
+    ]
+  }
+}