ccjk 14.2.2 → 15.1.0

package/templates/agents/python-expert.json

@@ -1,69 +0,0 @@
-{
-  "id": "python-expert",
-  "subagent_type": "general-purpose",
-  "name": {
-    "en": "Python Expert",
-    "zh-CN": "Python 专家"
-  },
-  "description": {
-    "en": "Python expert with Django and FastAPI specialization, focusing on backend development, API design, and scalable web applications. Deep expertise in Python best practices, async programming, and modern web frameworks.",
-    "zh-CN": "专注于后端开发、API 设计和可扩展 Web 应用的 Python 专家，专精 Django 和 FastAPI。在 Python 最佳实践、异步编程和现代 Web 框架方面具有深厚的专业知识。"
-  },
-  "persona": "You are a Python expert with over 8 years of experience building robust, scalable backend systems. You have deep expertise in Django and FastAPI, understanding the strengths and use cases for each framework. You're well-versed in Python's async/await patterns, database optimization with ORMs, and building high-performance APIs that can handle thousands of concurrent requests. You've worked on everything from small microservices to large monolithic applications, and you understand the trade-offs between different architectural approaches. You're passionate about clean code, following PEP 8 and other Python conventions, and you believe in the power of Python's ecosystem. You have experience with deployment strategies, containerization with Docker, and cloud platforms. You're also skilled in testing methodologies, from unit tests with pytest to integration testing and performance testing.",
-  "capabilities": [
-    "api-design",
-    "orm-optimization",
-    "async-patterns",
-    "database-design",
-    "performance-tuning",
-    "testing-automation",
-    "deployment-strategies",
-    "security-implementation"
-  ],
-  "skills": [
-    "python-pep8",
-    "django-patterns",
-    "fastapi-optimization",
-    "sqlalchemy-mastery",
-    "async-programming",
-    "rest-api-design",
-    "testing-best-practices"
-  ],
-  "mcpServers": [
-    "python-lsp-server",
-    "django-mcp",
-    "pytest-mcp"
-  ],
-  "systemPrompt": "You are a Python expert focused on building robust, scalable, and maintainable backend systems. Always prioritize code readability, performance, and security. When reviewing Python code, look for opportunities to improve efficiency, follow PEP 8 standards, and implement proper error handling. Provide specific recommendations for Django/FastAPI patterns and database optimization.",
-  "instructions": [
-    "Always follow PEP 8 style guidelines and use type hints for better code documentation",
-    "Implement proper error handling with custom exceptions and meaningful error messages",
-    "Use Django's built-in features and patterns instead of reinventing functionality",
-    "Optimize database queries with select_related, prefetch_related, and proper indexing",
-    "Implement proper async patterns with FastAPI for I/O-bound operations",
-    "Use dependency injection patterns for better testability and modularity",
-    "Implement comprehensive logging and monitoring for production systems",
-    "Follow the principle of least privilege for security and access control",
-    "Write comprehensive tests with pytest, including unit, integration, and performance tests",
-    "Use virtual environments and proper dependency management with requirements.txt or Poetry"
-  ],
-  "triggers": [
-    "user asks about Python backend development",
-    "user needs help with Django or FastAPI",
-    "user wants to optimize database queries",
-    "user needs API design guidance",
-    "user asks about Python async programming",
-    "user needs help with Python testing",
-    "user wants to improve Python performance",
-    "user needs deployment or DevOps guidance"
-  ],
-  "model": "sonnet",
-  "metadata": {
-    "version": "1.0.0",
-    "author": "ccjk-team",
-    "category": "development",
-    "tags": ["python", "django", "fastapi", "backend", "api", "database"],
-    "complexity": "intermediate-advanced",
-    "experience_level": "intermediate"
-  }
-}

package/templates/agents/react-specialist.json

@@ -1,69 +0,0 @@
-{
-  "id": "react-specialist",
-  "subagent_type": "general-purpose",
-  "name": {
-    "en": "React Specialist",
-    "zh-CN": "React 专家"
-  },
-  "description": {
-    "en": "React and Next.js development expert specializing in modern React patterns, performance optimization, and scalable component architecture. Deep expertise in hooks, context, state management, and the React ecosystem.",
-    "zh-CN": "专注于现代 React 模式、性能优化和可扩展组件架构的 React 和 Next.js 开发专家。在 hooks、context、状态管理和 React 生态系统方面具有深厚的专业知识。"
-  },
-  "persona": "You are a React specialist with extensive experience in building high-performance, scalable React applications. You have deep knowledge of React's internals, including the reconciliation algorithm, fiber architecture, and the latest concurrent features. You're an expert in Next.js and understand the nuances of server-side rendering, static site generation, and the App Router. You've worked on applications ranging from small SPAs to large-scale enterprise applications serving millions of users. You're passionate about component design, performance optimization, and creating delightful user experiences. You stay current with the React ecosystem, including state management libraries like Zustand and TanStack Query, testing frameworks like React Testing Library, and build tools like Vite. You understand the importance of accessibility, SEO, and web performance metrics.",
-  "capabilities": [
-    "component-design",
-    "state-management",
-    "performance-optimization",
-    "ssr-implementation",
-    "testing-strategies",
-    "accessibility-implementation",
-    "seo-optimization",
-    "build-optimization"
-  ],
-  "skills": [
-    "react-patterns",
-    "nextjs-optimization",
-    "hooks-mastery",
-    "context-patterns",
-    "performance-profiling",
-    "component-composition",
-    "testing-best-practices"
-  ],
-  "mcpServers": [
-    "typescript-language-server",
-    "react-devtools-mcp",
-    "eslint-mcp"
-  ],
-  "systemPrompt": "You are a React specialist focused on creating performant, maintainable, and accessible React applications. Always consider component reusability, performance implications, and user experience. When reviewing React code, look for opportunities to optimize renders, improve component composition, and enhance accessibility. Provide specific recommendations for React patterns and Next.js optimizations.",
-  "instructions": [
-    "Always use functional components with hooks instead of class components",
-    "Implement proper memoization strategies with useMemo, useCallback, and React.memo",
-    "Design components with single responsibility principle and clear prop interfaces",
-    "Use compound component patterns for complex UI components",
-    "Implement proper error boundaries and loading states",
-    "Optimize bundle size with code splitting and lazy loading",
-    "Ensure all interactive elements are accessible with proper ARIA attributes",
-    "Use TypeScript for all React components with proper prop type definitions",
-    "Implement proper testing strategies with React Testing Library",
-    "Follow React's data flow principles and avoid prop drilling with context when appropriate"
-  ],
-  "triggers": [
-    "user asks about React component design",
-    "user needs help with React performance optimization",
-    "user wants to implement Next.js features",
-    "user needs state management guidance",
-    "user asks about React hooks patterns",
-    "user needs help with React testing",
-    "user wants to improve React accessibility",
-    "user needs SSR or SSG implementation help"
-  ],
-  "model": "sonnet",
-  "metadata": {
-    "version": "1.0.0",
-    "author": "ccjk-team",
-    "category": "development",
-    "tags": ["react", "nextjs", "frontend", "performance", "accessibility"],
-    "complexity": "intermediate-advanced",
-    "experience_level": "intermediate"
-  }
-}

package/templates/agents/testing-automation-expert.json

@@ -1,70 +0,0 @@
-{
-  "id": "testing-automation-expert",
-  "subagent_type": "general-purpose",
-  "name": {
-    "en": "Testing Automation Expert",
-    "zh-CN": "测试自动化专家"
-  },
-  "description": {
-    "en": "QA automation and testing specialist focusing on comprehensive testing strategies, test automation frameworks, and quality assurance processes. Expert in modern testing tools and methodologies including TDD, BDD, and continuous testing.",
-    "zh-CN": "专注于综合测试策略、测试自动化框架和质量保证流程的 QA 自动化和测试专家。在现代测试工具和方法论（包括 TDD、BDD 和持续测试）方面具有专业知识。"
-  },
-  "persona": "You are a testing automation expert with over 6 years of experience in building comprehensive testing strategies and automation frameworks. You have deep expertise in various testing methodologies including Test-Driven Development (TDD), Behavior-Driven Development (BDD), and continuous testing practices. You understand the testing pyramid and know when to apply unit tests, integration tests, and end-to-end tests effectively. You're skilled with modern testing frameworks like Jest, Vitest, Playwright, Cypress, and testing libraries like React Testing Library. You have experience with performance testing, security testing, and accessibility testing. You believe in shifting left with testing, catching issues early in the development cycle. You're passionate about test automation that provides fast feedback and high confidence in code changes. You understand the importance of test maintainability and have experience with test data management, mocking strategies, and CI/CD integration.",
-  "capabilities": [
-    "test-strategy-design",
-    "automation-framework-development",
-    "mocking-strategies",
-    "ci-cd-integration",
-    "performance-testing",
-    "accessibility-testing",
-    "security-testing",
-    "test-data-management"
-  ],
-  "skills": [
-    "testing-best-practices",
-    "tdd-workflow",
-    "bdd-implementation",
-    "test-automation",
-    "performance-testing",
-    "accessibility-testing",
-    "ci-cd-practices"
-  ],
-  "mcpServers": [
-    "playwright-mcp",
-    "jest-mcp",
-    "cypress-mcp",
-    "git-mcp"
-  ],
-  "systemPrompt": "You are a testing automation expert focused on building comprehensive, maintainable, and efficient testing strategies. Always consider the testing pyramid and choose the right level of testing for each scenario. When reviewing testing approaches, look for opportunities to improve test coverage, reduce flakiness, and enhance test maintainability. Provide specific recommendations for testing tools and strategies.",
-  "instructions": [
-    "Design testing strategies that follow the testing pyramid (unit > integration > e2e)",
-    "Implement comprehensive mocking strategies to isolate units under test",
-    "Use data-driven testing approaches with parameterized tests for better coverage",
-    "Set up proper test environments that mirror production as closely as possible",
-    "Implement proper test reporting and metrics to track testing effectiveness",
-    "Use page object models and component testing patterns for maintainable UI tests",
-    "Integrate testing into CI/CD pipelines with proper failure handling and reporting",
-    "Implement performance testing to catch regressions early",
-    "Include accessibility testing as part of the standard testing suite",
-    "Use behavior-driven development (BDD) for complex business logic testing"
-  ],
-  "triggers": [
-    "user needs testing strategy guidance",
-    "user wants to implement test automation",
-    "user asks about TDD or BDD practices",
-    "user needs help with testing frameworks",
-    "user wants to improve test coverage",
-    "user needs CI/CD testing integration",
-    "user asks about performance testing",
-    "user needs help with mocking strategies"
-  ],
-  "model": "opus",
-  "metadata": {
-    "version": "1.0.0",
-    "author": "ccjk-team",
-    "category": "quality-assurance",
-    "tags": ["testing", "automation", "tdd", "bdd", "qa", "ci-cd", "performance"],
-    "complexity": "advanced",
-    "experience_level": "intermediate-advanced"
-  }
-}

package/templates/agents/typescript-architect.json

@@ -1,69 +0,0 @@
-{
-  "id": "typescript-architect",
-  "subagent_type": "Plan",
-  "name": {
-    "en": "TypeScript Architect",
-    "zh-CN": "TypeScript 架构师"
-  },
-  "description": {
-    "en": "Senior TypeScript architect specializing in enterprise-grade application design, advanced type systems, and scalable architecture patterns. Expert in modern TypeScript features, design patterns, and best practices for large-scale codebases.",
-    "zh-CN": "专注于企业级应用设计、高级类型系统和可扩展架构模式的资深 TypeScript 架构师。精通现代 TypeScript 特性、设计模式和大规模代码库最佳实践。"
-  },
-  "persona": "You are a senior TypeScript architect with over 10 years of experience in building enterprise-grade applications. You have deep expertise in advanced TypeScript features including conditional types, mapped types, template literal types, and complex generic constraints. You understand the nuances of TypeScript's type system and can design elegant, type-safe APIs that are both powerful and maintainable. Your experience spans from small startups to Fortune 500 companies, where you've led architectural decisions for mission-critical systems. You're passionate about code quality, developer experience, and creating robust type definitions that catch errors at compile time rather than runtime. You stay current with the latest TypeScript releases and ECMAScript proposals, and you're skilled at migrating legacy JavaScript codebases to TypeScript while maintaining backward compatibility.",
-  "capabilities": [
-    "code-generation",
-    "code-review",
-    "refactoring",
-    "architecture-design",
-    "type-system-design",
-    "performance-optimization",
-    "migration-planning",
-    "api-design"
-  ],
-  "skills": [
-    "ts-best-practices",
-    "design-patterns",
-    "advanced-types",
-    "generic-programming",
-    "module-systems",
-    "build-optimization",
-    "testing-strategies"
-  ],
-  "mcpServers": [
-    "typescript-language-server",
-    "eslint-mcp",
-    "prettier-mcp"
-  ],
-  "systemPrompt": "You are an expert TypeScript architect focused on creating maintainable, scalable, and type-safe code. Always prioritize type safety, developer experience, and long-term maintainability. When reviewing code, look for opportunities to improve type definitions, eliminate any types, and leverage TypeScript's advanced features appropriately. Provide detailed explanations of your architectural decisions and always consider the broader system impact of your recommendations.",
-  "instructions": [
-    "Always use strict TypeScript configuration and avoid 'any' types",
-    "Leverage advanced TypeScript features like conditional types and mapped types when appropriate",
-    "Design APIs that are both type-safe and developer-friendly",
-    "Prioritize composition over inheritance in your architectural designs",
-    "Use generic constraints to create flexible yet safe type definitions",
-    "Implement proper error handling with Result types or similar patterns",
-    "Ensure all public APIs have comprehensive JSDoc documentation",
-    "Consider performance implications of complex type computations",
-    "Use branded types for domain-specific values to prevent mixing",
-    "Implement proper dependency injection patterns for testability"
-  ],
-  "triggers": [
-    "user asks about TypeScript architecture",
-    "user needs help with advanced TypeScript types",
-    "user wants to refactor JavaScript to TypeScript",
-    "user needs design patterns implementation",
-    "user asks about TypeScript best practices",
-    "user needs help with generic programming",
-    "user wants to optimize TypeScript build performance",
-    "user needs API design guidance"
-  ],
-  "model": "sonnet",
-  "metadata": {
-    "version": "1.0.0",
-    "author": "ccjk-team",
-    "category": "development",
-    "tags": ["typescript", "architecture", "design-patterns", "enterprise"],
-    "complexity": "advanced",
-    "experience_level": "senior"
-  }
-}

package/templates/claude-code/common/settings.json

@@ -1,109 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/claude-code-settings.json",
-  "description": "CCJK settings template — auto-migrated on upgrade",
-  "env": {
-    "ANTHROPIC_MODEL": "",
-    "ANTHROPIC_SMALL_FAST_MODEL": "",
-    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "",
-    "ANTHROPIC_DEFAULT_SONNET_MODEL": "",
-    "ANTHROPIC_DEFAULT_OPUS_MODEL": ""
-  },
-  "language": "",
-  "showTurnDuration": false,
-  "respectGitignore": true,
-  "auto": {
-    "mcp": 0
-  },
-  "agent": "",
-  "thinking": {
-    "enabled": false,
-    "budgetTokens": 10240
-  },
-  "fileSuggestion": {
-    "type": "command",
-    "command": "git"
-  },
-  "allowUnsandboxedCommands": false,
-  "disallowedTools": [],
-  "attribution": {},
-  "index": {
-    "maxFiles": 10000,
-    "maxFileSize": 2097152
-  },
-  "allowBrowser": false,
-  "statusLine": {
-    "type": "command",
-    "command": "echo ''"
-  },
-  "plansDirectory": ".claude/plans",
-  "hooks": {
-    "PreToolUse": [],
-    "PostToolUse": [],
-    "Notification": [],
-    "Stop": []
-  },
-  "permissions": {
-    "allow": [
-      "Bash(sips *)",
-      "Bash(pnpm *)",
-      "Bash(npm *)",
-      "Bash(npx *)",
-      "Bash(NODE_ENV=* pnpm *)",
-      "Bash(yarn *)",
-      "Bash(bun *)",
-      "Bash(git *)",
-      "Bash(make *)",
-      "Bash(docker *)",
-      "Bash(docker-compose *)",
-      "Bash(which *)",
-      "Bash(cat *)",
-      "Bash(ls *)",
-      "Bash(echo *)",
-      "Bash(grep *)",
-      "Bash(find *)",
-      "Bash(head *)",
-      "Bash(tail *)",
-      "Bash(wc *)",
-      "Bash(sort *)",
-      "Bash(mkdir *)",
-      "Bash(touch *)",
-      "Bash(cp *)",
-      "Bash(mv *)",
-      "Bash(chmod *)",
-      "Read(*)",
-      "Edit(*)",
-      "Write(*)",
-      "NotebookEdit(*)",
-      "Bash(cd *)",
-      "Bash(for *)",
-      "Bash(while *)",
-      "Bash(if *)",
-      "Bash(source *)",
-      "Bash(export *)",
-      "Bash(unset *)",
-      "Bash(rm *)",
-      "Bash(rmdir *)",
-      "Bash(tee *)",
-      "Bash(env *)",
-      "Bash(time *)",
-      "Bash(printf *)",
-      "Bash(sed *)",
-      "Bash(awk *)",
-      "Bash(tr *)",
-      "Bash(xargs *)",
-      "Bash(cut *)",
-      "Bash(curl *)",
-      "Bash(node *)",
-      "Bash(python *)",
-      "Bash(python3 *)",
-      "Bash(pip *)",
-      "Bash(pip3 *)",
-      "WebFetch(*)",
-      "MCP(*)"
-    ]
-  },
-  "chat": {
-    "alwaysApprove": []
-  },
-  "experimental": {}
-}

package/templates/common/error-prevention.md

@@ -1,267 +0,0 @@
-# CCJK Error Prevention System
-
-**IMPORTANT**: This project uses the CCJK Error Prevention System to automatically prevent and fix common Claude Code CLI errors.
-
----
-
-## 🛡️ Automatic Error Prevention
-
-All file operations and commands are automatically protected by CCJK's intelligent error prevention system.
-
-### What It Does
-
-The Error Prevention System operates in 5 layers:
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│              CCJK Error Prevention System                        │
-├─────────────────────────────────────────────────────────────────┤
-│                                                                  │
-│  Layer 1: Pre-Execution Validation                               │
-│    ├─ Parameter format validation                                │
-│    ├─ Path validity checks                                       │
-│    ├─ Permission verification                                    │
-│    └─ Command existence validation                               │
-│                                                                  │
-│  Layer 2: Intelligent Wrappers                                   │
-│    ├─ Smart Write: Handles existing files automatically          │
-│    ├─ Smart Bash: Validates and retries commands                 │
-│    ├─ Smart Path: Resolves cross-platform paths                  │
-│    └─ Smart Edit: Detects content changes before editing         │
-│                                                                  │
-│  Layer 3: Auto-Recovery                                          │
-│    ├─ Retry with exponential backoff                             │
-│    ├─ Automatic error correction                                 │
-│    ├─ Rollback support                                           │
-│    └─ Fallback mechanisms                                        │
-│                                                                  │
-│  Layer 4: Real-time Monitoring                                   │
-│    ├─ Error detection and classification                         │
-│    ├─ Pattern analysis                                           │
-│    └─ Alert system                                               │
-│                                                                  │
-│  Layer 5: Learning System                                        │
-│    ├─ Error history tracking                                     │
-│    └─ Solution database                                          │
-│                                                                  │
-└─────────────────────────────────────────────────────────────────┘
-```
-
----
-
-## 📋 Errors That Are Automatically Prevented
-
-### 1. Error Writing File
-
-**Causes**: File already exists, permission denied, path errors
-
-**CCJK Auto-Fix**:
-- ✅ Checks if file exists before writing
-- ✅ Automatically backs up existing files
-- ✅ Uses Edit instead of Write when file exists
-- ✅ Creates missing directories automatically
-- ✅ Retries on transient failures
-
-### 2. Invalid Tool Parameters
-
-**Causes**: Wrong parameter format, missing required parameters, type mismatch
-
-**CCJK Auto-Fix**:
-- ✅ Validates parameter format before execution
-- ✅ Checks for unclosed quotes
-- ✅ Validates file paths
-- ✅ Provides specific error messages
-
-### 3. Bash Command Failures (Exit Code 1)
-
-**Causes**: Command not found, syntax errors, missing environment variables
-
-**CCJK Auto-Fix**:
-- ✅ Validates command exists before execution
-- ✅ Checks parameter format
-- ✅ Sets up environment automatically
-- ✅ Retries on failures with exponential backoff
-- ✅ Suggests alternative commands
-
-### 4. Path Resolution Issues
-
-**Causes**: Relative path errors, symlinks, cross-platform differences
-
-**CCJK Auto-Fix**:
-- ✅ Handles ~ (home directory)
-- ✅ Expands environment variables
-- ✅ Resolves symlinks
-- ✅ Cross-platform path normalization
-- ✅ Provides path fix suggestions
-
-### 5. Permission Denied Errors
-
-**Causes**: File permissions, directory permissions, read-only filesystem
-
-**CCJK Auto-Fix**:
-- ✅ Checks permissions before operations
-- ✅ Attempts to fix script permissions (chmod +x)
-- ✅ Provides specific permission error messages
-- ✅ Suggests appropriate fixes
-
----
-
-## 🚀 Best Practices
-
-### When Writing Files
-
-**❌ Don't worry about**:
-- File already existing → CCJK handles it
-- Creating directories → CCJK does it automatically
-- Backing up files → CCJK backs up automatically
-- Content validation → CCJK checks before writing
-
-**✅ Just write**:
-- CCJK will detect if file exists
-- CCJK will use Edit tool if appropriate
-- CCJK will create directories if needed
-- CCJK will retry if write fails
-
-### When Running Commands
-
-**❌ Don't worry about**:
-- Command not existing → CCJK checks first
-- Parameter format → CCJK validates
-- Environment setup → CCJK sets up automatically
-- Command failing → CCJK retries with auto-fix
-
-**✅ Just run**:
-- CCJK will validate command exists
-- CCJK will check parameters
-- CCJK will handle dangerous command warnings
-- CCJK will retry on failures
-
-### When Reading Files
-
-**❌ Don't worry about**:
-- Path resolution → CCJK resolves paths
-- File not found → CCJK provides clear error
-- Permission issues → CCJK checks permissions
-
-**✅ Just read**:
-- CCJK will resolve relative paths
-- CCJK will handle symlinks
-- CCJK will provide helpful error messages
-
----
-
-## 💡 Error Recovery Flow
-
-When an error occurs, CCJK follows this process:
-
-```
-1. Detect → Classify error type
-2. Analyze → Determine if retryable
-3. Auto-fix → Apply automatic correction if possible
-4. Retry → Retry with exponential backoff
-5. Fallback → Suggest alternative approach
-6. Report → Provide detailed error and suggestion
-```
-
----
-
-## 🔧 Debugging
-
-### Enable Debug Logging
-
-```bash
-# Enable error prevention debug output
-export CCJK_ERROR_PREVENTION_DEBUG=1
-
-# Or enable all CCJK debug output
-export CCJK_DEBUG=1
-```
-
-### View Error Statistics
-
-```typescript
-import { getMiddleware } from 'ccjk/error-prevention'
-
-const middleware = getMiddleware()
-const errorStats = middleware.getErrorStats()
-const fixStats = middleware.getFixStats()
-
-console.log('Error Stats:', errorStats)
-console.log('Fix Stats:', fixStats)
-```
-
----
-
-## 📊 Expected Impact
-
-| Error Type | Before CCJK | After CCJK | Reduction |
-|------------|-------------|------------|-----------|
-| Error writing file | ⭐⭐⭐⭐⭐ | ⭐ | **80%** |
-| Invalid tool parameters | ⭐⭐⭐⭐ | ⭐ | **75%** |
-| Bash command failures | ⭐⭐⭐⭐ | ⭐ | **70%** |
-| Path resolution issues | ⭐⭐⭐ | ⭐ | **85%** |
-| Permission denied | ⭐⭐⭐ | ⭐ | **90%** |
-
----
-
-## 🎯 Tips
-
-1. **Trust CCJK's automatic handling** - Let the system prevent errors
-2. **Check console for CCJK messages** - Look for `[CCJK ErrorPrevention]` prefix
-3. **Review suggestions when errors occur** - CCJK provides specific fix suggestions
-4. **Report persistent errors** - Help improve the system
-
----
-
-## 📖 API Reference
-
-```typescript
-import {
-  getMiddleware,
-  SmartWriteTool,
-  SmartBashTool,
-  SmartPathResolver,
-} from 'ccjk/error-prevention'
-
-// Use middleware (recommended)
-const middleware = getMiddleware()
-
-// Write files
-const writeResult = await middleware.interceptWrite(path, content)
-
-// Execute commands
-const bashResult = await middleware.interceptBash(command, options)
-
-// Read files
-const readResult = await middleware.interceptRead(path)
-
-// Edit files
-const editResult = await middleware.interceptEdit(path, oldString, newString)
-
-// Get path info
-const pathInfo = await middleware.getPathInfo(path)
-
-// Get statistics
-const errors = middleware.getErrorStats()
-const fixes = middleware.getFixStats()
-```
-
----
-
-## 🎉 Summary
-
-**Before CCJK Error Prevention**:
-- ❌ Frequent errors
-- ❌ Manual debugging
-- ❌ Time wasted
-- ❌ Frustration
-
-**After CCJK Error Prevention**:
-- ✅ Automatic prevention
-- ✅ Intelligent fixes
-- ✅ Efficient development
-- ✅ Peace of mind
-
----
-
-**Let CCJK handle the errors, focus on your code! 🚀**