claude-flow-novice 1.3.0 → 1.3.2

package/.claude-flow-novice/preferences/generation.json

@@ -0,0 +1,147 @@
+{
+  "_description": "CLAUDE.md Template Generation Settings - Controls automatic generation of language-specific CLAUDE.md files",
+  "_purpose": "This file controls how CLAUDE.md templates are automatically generated for different programming languages and frameworks",
+  "_used_in": [
+    "src/language/claude-md-generator.js (template generation)",
+    "src/language/language-detector.js (framework detection)",
+    "src/preferences/preference-manager.js (configuration loading)",
+    "src/slash-commands/claude-md.js (slash command execution)",
+    "src/npx/claude-md-protection.js (NPX protection system)",
+    "scripts/post-install-claude-md.js (postinstall hook)"
+  ],
+
+  "autoGenerate": true,
+  "_autoGenerate_description": "Whether to automatically generate CLAUDE.md files when a new project language is detected",
+
+  "includeFrameworkSpecific": true,
+  "_includeFrameworkSpecific_description": "Include framework-specific configurations (React hooks, Django settings, etc.)",
+
+  "includeBestPractices": true,
+  "_includeBestPractices_description": "Include language/framework best practices in generated templates",
+
+  "includeTestingPatterns": true,
+  "_includeTestingPatterns_description": "Include testing framework patterns (Jest, pytest, etc.) in templates",
+
+  "includeDeploymentGuidelines": false,
+  "_includeDeploymentGuidelines_description": "Include deployment and CI/CD guidelines in generated templates",
+
+  "backupExisting": true,
+  "_backupExisting_description": "Create backup of existing CLAUDE.md before overwriting with new template",
+
+  "preserveCustomSections": true,
+  "_preserveCustomSections_description": "Preserve custom sections when regenerating templates",
+
+  "confidenceThreshold": 0.3,
+  "_confidenceThreshold_description": "Minimum confidence level (0-1) required for language detection before generating template",
+  "languages": {
+    "javascript": {
+      "enabled": true,
+      "includeConcurrentPatterns": true,
+      "includeErrorHandling": true,
+      "includePerformanceTips": true
+    },
+    "typescript": {
+      "enabled": true,
+      "includeStrictConfig": true,
+      "includeUtilityTypes": true,
+      "includeTestingPatterns": true
+    },
+    "python": {
+      "enabled": true,
+      "includePEP8": true,
+      "includeAsyncPatterns": true,
+      "includeTypeHints": true
+    },
+    "java": {
+      "enabled": true,
+      "includeSpringPatterns": false,
+      "includeMavenConfig": false
+    },
+    "go": {
+      "enabled": true,
+      "includeGoRoutines": true,
+      "includeModules": true
+    },
+    "rust": {
+      "enabled": true,
+      "includeCargoConfig": true,
+      "includeOwnershipPatterns": true
+    }
+  },
+  "frameworks": {
+    "react": {
+      "enabled": true,
+      "includeHooks": true,
+      "includeTestingLibrary": true,
+      "includePerformanceOptimization": true
+    },
+    "nextjs": {
+      "enabled": true,
+      "includeAppRouter": true,
+      "includeServerComponents": true,
+      "includeISR": true
+    },
+    "vue": {
+      "enabled": true,
+      "includeComposition": true,
+      "includeVuex": true
+    },
+    "angular": {
+      "enabled": true,
+      "includeRxJS": true,
+      "includeNgRx": false
+    },
+    "express": {
+      "enabled": true,
+      "includeMiddleware": true,
+      "includeAuthentication": true,
+      "includeValidation": true
+    },
+    "fastify": {
+      "enabled": true,
+      "includePlugins": true,
+      "includeSchemas": true
+    },
+    "django": {
+      "enabled": true,
+      "includeDRF": true,
+      "includeAuthentication": true,
+      "includeTestCase": true
+    },
+    "flask": {
+      "enabled": true,
+      "includeBlueprints": true,
+      "includeSQLAlchemy": true,
+      "includeJWT": true
+    },
+    "fastapi": {
+      "enabled": true,
+      "includePydantic": true,
+      "includeAsyncPatterns": true,
+      "includeOpenAPI": true
+    },
+    "spring": {
+      "enabled": true,
+      "includeBootPatterns": true,
+      "includeJPA": false
+    }
+  },
+  "customSections": {
+    "includeProjectSpecific": true,
+    "includeTeamGuidelines": false,
+    "includeDeploymentNotes": false
+  },
+  "formatting": {
+    "maxLineLength": 120,
+    "useCodeBlocks": true,
+    "includeEmojis": true,
+    "sectionHeaders": "##"
+  },
+  "notifications": {
+    "onGeneration": true,
+    "onUpdate": true,
+    "onValidationIssues": false
+  },
+  "version": "1.0.0",
+  "lastUpdated": "2025-09-24T00:00:00.000Z"
+}

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

@@ -0,0 +1,51 @@
+{
+  "_description": "JavaScript Language Configuration - Defines JavaScript project detection patterns and best practices",
+  "_purpose": "This configuration helps the system recognize JavaScript projects and apply appropriate tooling and patterns",
+  "_used_in": [
+    "src/language/language-detector.js (project type detection)",
+    "src/language/framework-detector.js (JavaScript framework detection)",
+    "src/hooks/enhanced/personalization-hooks.js (language-specific behavior)"
+  ],
+
+  "name": "JavaScript",
+  "extensions": [".js", ".mjs", ".cjs"],
+  "_extensions_description": "File extensions that identify JavaScript files (.js=standard, .mjs=ES modules, .cjs=CommonJS)",
+
+  "packageFiles": ["package.json", ".eslintrc*", "babel.config.*"],
+  "_packageFiles_description": "Configuration files that indicate a JavaScript project and its tooling setup",
+  "testFrameworks": {
+    "_description": "Testing framework detection patterns and priority ordering for JavaScript projects",
+    "jest": {
+      "patterns": ["jest.config.js", "__tests__", ".test.js", ".spec.js"],
+      "priority": 1,
+      "_description": "Most popular React/Node.js testing framework"
+    },
+    "vitest": {
+      "patterns": ["vitest.config.js", "vite.config.js"],
+      "priority": 2,
+      "_description": "Fast testing framework for Vite-based projects"
+    },
+    "mocha": {
+      "patterns": ["mocha.opts", ".mocharc*"],
+      "priority": 3,
+      "_description": "Traditional JavaScript testing framework"
+    }
+  },
+
+  "bestPractices": [
+    "Use ES6+ features (arrow functions, destructuring, modules)",
+    "Prefer const/let over var",
+    "Use async/await over Promise chains",
+    "Implement proper error boundaries",
+    "Follow ESLint/Prettier configurations"
+  ],
+  "_bestPractices_description": "JavaScript coding standards and recommendations that agents should follow and suggest",
+
+  "concurrentPatterns": {
+    "_description": "Claude Code-specific patterns for optimal JavaScript development workflow",
+    "agentCoordination": "Use Claude Code's Task tool for parallel agent execution",
+    "fileOperations": "Batch all Read/Write/Edit operations in single message",
+    "bashCommands": "Execute multiple bash commands with && or ; separators",
+    "todoManagement": "Batch ALL todos in ONE TodoWrite call (5-10+ minimum)"
+  }
+}

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"
+  }
+}