makecoder 4.0.56 → 4.0.58

package/scripts/postinstall.js

@@ -86,21 +86,21 @@ function main() {
         }
 
         const homeDir = os.homedir();
-        const claudeDestDir = path.join(homeDir, '.claude');
-        const claudeSrcDir = path.join(__dirname, '..', 'claude');
-        
-        if (!fs.existsSync(claudeSrcDir)) {
-            console.log('Claude directory not found, skipping postinstall setup');
+        const coderDestDir = path.join(homeDir, '.coder');
+        const coderSrcDir = path.join(__dirname, '..', 'packages');
+
+        if (!fs.existsSync(coderSrcDir)) {
+            console.log('Source directory not found, skipping postinstall setup');
             return;
         }
-        
-        if (!fs.existsSync(claudeDestDir)) {
-            fs.mkdirSync(claudeDestDir, { recursive: true });
-            console.log('Created .claude directory in home folder');
+
+        if (!fs.existsSync(coderDestDir)) {
+            fs.mkdirSync(coderDestDir, { recursive: true });
+            console.log('Created .coder directory in home folder');
         }
-        
-        copyRecursive(claudeSrcDir, claudeDestDir);
-        console.log('Successfully copied claude configuration files to ~/.claude (existing files overwritten)');
+
+        copyRecursive(coderSrcDir, coderDestDir);
+        console.log('Successfully copied configuration files to ~/.coder (existing files overwritten)');
         
     } catch (error) {
         console.error('Error during postinstall setup:', error.message);

package/claude/commands/dev/ultra-think.md

@@ -1,153 +0,0 @@
-# Deep Analysis and Problem Solving Mode
-
-Deep analysis and problem solving mode
-
-## Instructions
-
-1. **Initialize Ultra Think Mode**
-   - Acknowledge the request for enhanced analytical thinking
-   - Set context for deep, systematic reasoning
-   - Prepare to explore the problem space comprehensively
-
-2. **Parse the Problem or Question**
-   - Extract the core challenge from: **$ARGUMENTS**
-   - Identify all stakeholders and constraints
-   - Recognize implicit requirements and hidden complexities
-   - Question assumptions and surface unknowns
-
-3. **Multi-Dimensional Analysis**
-   Approach the problem from multiple angles:
-   
-   ### Technical Perspective
-   - Analyze technical feasibility and constraints
-   - Consider scalability, performance, and maintainability
-   - Evaluate security implications
-   - Assess technical debt and future-proofing
-   
-   ### Business Perspective
-   - Understand business value and ROI
-   - Consider time-to-market pressures
-   - Evaluate competitive advantages
-   - Assess risk vs. reward trade-offs
-   
-   ### User Perspective
-   - Analyze user needs and pain points
-   - Consider usability and accessibility
-   - Evaluate user experience implications
-   - Think about edge cases and user journeys
-   
-   ### System Perspective
-   - Consider system-wide impacts
-   - Analyze integration points
-   - Evaluate dependencies and coupling
-   - Think about emergent behaviors
-
-4. **Generate Multiple Solutions**
-   - Brainstorm at least 3-5 different approaches
-   - For each approach, consider:
-     - Pros and cons
-     - Implementation complexity
-     - Resource requirements
-     - Potential risks
-     - Long-term implications
-   - Include both conventional and creative solutions
-   - Consider hybrid approaches
-
-5. **Deep Dive Analysis**
-   For the most promising solutions:
-   - Create detailed implementation plans
-   - Identify potential pitfalls and mitigation strategies
-   - Consider phased approaches and MVPs
-   - Analyze second and third-order effects
-   - Think through failure modes and recovery
-
-6. **Cross-Domain Thinking**
-   - Draw parallels from other industries or domains
-   - Apply design patterns from different contexts
-   - Consider biological or natural system analogies
-   - Look for innovative combinations of existing solutions
-
-7. **Challenge and Refine**
-   - Play devil's advocate with each solution
-   - Identify weaknesses and blind spots
-   - Consider "what if" scenarios
-   - Stress-test assumptions
-   - Look for unintended consequences
-
-8. **Synthesize Insights**
-   - Combine insights from all perspectives
-   - Identify key decision factors
-   - Highlight critical trade-offs
-   - Summarize innovative discoveries
-   - Present a nuanced view of the problem space
-
-9. **Provide Structured Recommendations**
-   Present findings in a clear structure:
-   ```
-   ## Problem Analysis
-   - Core challenge
-   - Key constraints
-   - Critical success factors
-   
-   ## Solution Options
-   ### Option 1: [Name]
-   - Description
-   - Pros/Cons
-   - Implementation approach
-   - Risk assessment
-   
-   ### Option 2: [Name]
-   [Similar structure]
-   
-   ## Recommendation
-   - Recommended approach
-   - Rationale
-   - Implementation roadmap
-   - Success metrics
-   - Risk mitigation plan
-   
-   ## Alternative Perspectives
-   - Contrarian view
-   - Future considerations
-   - Areas for further research
-   ```
-
-10. **Meta-Analysis**
-    - Reflect on the thinking process itself
-    - Identify areas of uncertainty
-    - Acknowledge biases or limitations
-    - Suggest additional expertise needed
-    - Provide confidence levels for recommendations
-
-## Usage Examples
-
-```bash
-# Architectural decision
-/project:ultra-think Should we migrate to microservices or improve our monolith?
-
-# Complex problem solving
-/project:ultra-think How do we scale our system to handle 10x traffic while reducing costs?
-
-# Strategic planning
-/project:ultra-think What technology stack should we choose for our next-gen platform?
-
-# Design challenge
-/project:ultra-think How can we improve our API to be more developer-friendly while maintaining backward compatibility?
-```
-
-## Key Principles
-
-- **First Principles Thinking**: Break down to fundamental truths
-- **Systems Thinking**: Consider interconnections and feedback loops
-- **Probabilistic Thinking**: Work with uncertainties and ranges
-- **Inversion**: Consider what to avoid, not just what to do
-- **Second-Order Thinking**: Consider consequences of consequences
-
-## Output Expectations
-
-- Comprehensive analysis (typically 2-4 pages of insights)
-- Multiple viable solutions with trade-offs
-- Clear reasoning chains
-- Acknowledgment of uncertainties
-- Actionable recommendations
-- Novel insights or perspectives

package/claude/commands/docs/generate-api-documentation.md

@@ -1,80 +0,0 @@
-# Generate API Documentation
-
-Auto-generate API reference documentation
-
-## Instructions
-
-1. **API Documentation Strategy Analysis**
-   - Analyze current API structure and endpoints
-   - Identify documentation requirements (REST, GraphQL, gRPC, etc.)
-   - Assess existing code annotations and documentation
-   - Determine documentation output formats and hosting requirements
-   - Plan documentation automation and maintenance strategy
-
-2. **Documentation Tool Selection**
-   - Choose appropriate API documentation tools:
-     - **OpenAPI/Swagger**: REST API documentation with Swagger UI
-     - **Redoc**: Modern OpenAPI documentation renderer
-     - **GraphQL**: GraphiQL, Apollo Studio, GraphQL Playground
-     - **Postman**: API documentation with collections
-     - **Insomnia**: API documentation and testing
-     - **API Blueprint**: Markdown-based API documentation
-     - **JSDoc/TSDoc**: Code-first documentation generation
-   - Consider factors: API type, team workflow, hosting, interactivity
-
-3. **Code Annotation and Schema Definition**
-   - Add comprehensive code annotations for API endpoints
-   - Define request/response schemas and data models
-   - Add parameter descriptions and validation rules
-   - Document authentication and authorization requirements
-   - Add example requests and responses
-
-4. **API Specification Generation**
-   - Set up automated API specification generation from code
-   - Configure OpenAPI/Swagger specification generation
-   - Set up schema validation and consistency checking
-   - Configure API versioning and changelog generation
-   - Set up specification file management and version control
-
-5. **Interactive Documentation Setup**
-   - Configure interactive API documentation with try-it-out functionality
-   - Set up API testing and example execution
-   - Configure authentication handling in documentation
-   - Set up request/response validation and examples
-   - Configure API endpoint categorization and organization
-
-6. **Documentation Content Enhancement**
-   - Add comprehensive API guides and tutorials
-   - Create authentication and authorization documentation
-   - Add error handling and status code documentation
-   - Create SDK and client library documentation
-   - Add rate limiting and usage guidelines
-
-7. **Documentation Hosting and Deployment**
-   - Set up documentation hosting and deployment
-   - Configure documentation website generation and styling
-   - Set up custom domain and SSL configuration
-   - Configure documentation search and navigation
-   - Set up documentation analytics and usage tracking
-
-8. **Automation and CI/CD Integration**
-   - Configure automated documentation generation in CI/CD pipeline
-   - Set up documentation deployment automation
-   - Configure documentation validation and quality checks
-   - Set up documentation change detection and notifications
-   - Configure documentation testing and link validation
-
-9. **Multi-format Documentation Generation**
-   - Generate documentation in multiple formats (HTML, PDF, Markdown)
-   - Set up downloadable documentation packages
-   - Configure offline documentation access
-   - Set up documentation API for programmatic access
-   - Configure documentation syndication and distribution
-
-10. **Maintenance and Quality Assurance**
-    - Set up documentation quality monitoring and validation
-    - Configure documentation feedback and improvement workflows
-    - Set up documentation analytics and usage metrics
-    - Create documentation maintenance procedures and guidelines
-    - Train team on documentation best practices and tools
-    - Set up documentation review and approval processes

package/claude/commands/git/commit.md

@@ -1,63 +0,0 @@
-# Commit
-
-Create well-formatted commits with conventional commit messages and emojis.
-
-## Features:
-
-- Runs pre-commit checks by default (lint, build, generate docs)
-- Automatically stages files if none are staged
-- Uses conventional commit format with descriptive emojis
-- Suggests splitting commits for different concerns
-- Maintain good submission formatting, do not include invisible characters in submissions, use utf-8 encoding for submissions
-- NEVER include ANSI color codes or escape sequences in commit messages
-- Do NOT add "🤖 Generated with [Claude Code]" or "Co-Authored-By: Claude" signatures to commit messages
-
-## Usage:
-
-- `/commit` - Standard commit with pre-commit checks
-- `/commit --no-verify` - Skip pre-commit checks
-
-## Commit Types:
-
-| Emoji                  | Devmoji Code      | Description                                                                                                       |
-| ---------------------- | ----------------- | ----------------------------------------------------------------------------------------------------------------- |
-| :sparkles:             | `:feat:`          | **feat:** a new feature                                                                                           |
-| :bug:                  | `:fix:`           | **fix:** a bug fix                                                                                                |
-| :books:                | `:docs:`          | **docs:** documentation only changes                                                                              |
-| :art:                  | `:style:`         | **style:** changes that do not affect the meaning of the code (white-space, formatting, missing semi-colons, etc) |
-| :recycle:              | `:refactor:`      | **refactor:** a code change that neither fixes a bug nor adds a feature                                           |
-| :zap:                  | `:perf:`          | **perf:** a code change that improves performance                                                                 |
-| :rotating_light:       | `:test:`          | **test:** adding missing or correcting existing tests                                                             |
-| :wrench:               | `:chore:`         | **chore:** changes to the build process or auxiliary tools and libraries such as documentation generation         |
-| :rocket:               | `:chore-release:` | **chore(release):** code deployment or publishing to external repositories                                        |
-| :link:                 | `:chore-deps:`    | **chore(deps):** add or delete dependencies                                                                       |
-| :package:              | `:build:`         | **build:** changes related to build processes                                                                     |
-| :construction_worker:  | `:ci:`            | **ci:** updates to the continuous integration system                                                              |
-| :rocket:               | `:release:`       | code deployment or publishing to external repositories                                                            |
-| :lock:                 | `:security:`      | Fixing security issues.                                                                                           |
-| :globe_with_meridians: | `:i18n:`          | Internationalization and localization.                                                                            |
-| :boom:                 | `:breaking:`      | Introducing breaking changes.                                                                                     |
-| :gear:                 | `:config:`        | Changing configuration files.                                                                                     |
-| :heavy_plus_sign:      | `:add:`           | add something                                                                                                     |
-| :heavy_minus_sign:     | `:remove:`        | remove something                                                                                                  |
-
-## Process:
-
-1. Check for staged changes (`git status`)
-2. If no staged changes, review and stage appropriate files
-3. Run pre-commit checks (unless --no-verify)
-4. Analyze changes to determine commit type
-5. Generate descriptive commit message (plain text only, no color codes)
-6. Include scope if applicable: `type(scope): description`
-7. Add body for complex changes explaining why
-8. Execute commit with clean message formatting
-
-## Best Practices:
-
-- Keep commits atomic and focused
-- Write in imperative mood ("Add feature" not "Added feature")
-- Explain why, not just what
-- Reference issues/PRs when relevant
-- Split unrelated changes into separate commits
-- Use clean, plain text commit messages without color codes or signatures
-- Prefer emoji codes (:gear:) over actual emoji characters (⚙️) for better compatibility and readability

package/claude/commands/git/status.md

@@ -1,39 +0,0 @@
-# Git Status Command
-
-Show detailed git repository status
-
-*Command originally created by IndyDevDan (YouTube: https://www.youtube.com/@indydevdan) / DislerH (GitHub: https://github.com/disler)*
-
-## Instructions
-
-Analyze the current state of the git repository by performing the following steps:
-
-1. **Run Git Status Commands**
-   - Execute `git status` to see current working tree state
-   - Run `git diff HEAD origin/main` to check differences with remote
-   - Execute `git branch --show-current` to display current branch
-   - Check for uncommitted changes and untracked files
-
-2. **Analyze Repository State**
-   - Identify staged vs unstaged changes
-   - List any untracked files
-   - Check if branch is ahead/behind remote
-   - Review any merge conflicts if present
-
-3. **Read Key Files**
-   - Review README.md for project context
-   - Check for any recent changes in important files
-   - Understand project structure if needed
-
-4. **Provide Summary**
-   - Current branch and its relationship to main/master
-   - Number of commits ahead/behind
-   - List of modified files with change types
-   - Any action items (commits needed, pulls required, etc.)
-
-This command helps developers quickly understand:
-- What changes are pending
-- The repository's sync status
-- Whether any actions are needed before continuing work
-
-Arguments: $ARGUMENTS

package/claude/commands/setup/migrate-to-typescript.md

@@ -1,76 +0,0 @@
-# Migrate to TypeScript
-
-Migrate JavaScript project to TypeScript
-
-## Instructions
-
-1. **Project Analysis and Migration Planning**
-   - Analyze current JavaScript codebase structure and complexity
-   - Identify external dependencies and their TypeScript support
-   - Assess project size and determine migration approach (gradual vs. complete)
-   - Review existing build system and bundling configuration
-   - Create migration timeline and phased approach plan
-
-2. **TypeScript Installation and Configuration**
-   - Install TypeScript and related dependencies (@types packages)
-   - Create comprehensive tsconfig.json with strict configuration
-   - Configure path mapping and module resolution
-   - Set up incremental compilation and build optimization
-   - Configure TypeScript for different environments (development, production, testing)
-
-3. **Build System Integration**
-   - Update build tools to support TypeScript compilation
-   - Configure webpack, Vite, or other bundlers for TypeScript
-   - Set up development server with TypeScript support
-   - Configure hot module replacement for TypeScript files
-   - Update build scripts and package.json configurations
-
-4. **File Migration Strategy**
-   - Start with configuration files and utility modules
-   - Migrate from least to most complex modules
-   - Rename .js files to .ts/.tsx incrementally
-   - Update import/export statements to use TypeScript syntax
-   - Handle mixed JavaScript/TypeScript codebase during transition
-
-5. **Type Definitions and Interfaces**
-   - Create comprehensive type definitions for project-specific types
-   - Install @types packages for external dependencies
-   - Define interfaces for API responses and data structures
-   - Create custom type declarations for untyped libraries
-   - Set up shared types and interfaces across modules
-
-6. **Code Transformation and Type Annotation**
-   - Add explicit type annotations to function parameters and return types
-   - Convert JavaScript classes to TypeScript with proper typing
-   - Transform object literals to typed interfaces
-   - Add generic types for reusable components and functions
-   - Handle complex types like union types, mapped types, and conditional types
-
-7. **Error Resolution and Type Safety**
-   - Resolve TypeScript compiler errors systematically
-   - Fix type mismatches and undefined behavior
-   - Handle null and undefined values with strict null checks
-   - Configure ESLint rules for TypeScript best practices
-   - Set up type checking in CI/CD pipeline
-
-8. **Testing and Validation**
-   - Update test files to TypeScript
-   - Configure testing framework for TypeScript support
-   - Add type testing with tools like tsd or @typescript-eslint
-   - Validate type safety in test suites
-   - Set up type coverage reporting
-
-9. **Developer Experience Enhancement**
-   - Configure IDE/editor for optimal TypeScript support
-   - Set up IntelliSense and auto-completion
-   - Configure debugging for TypeScript source maps
-   - Set up type-aware linting and formatting
-   - Create TypeScript-specific code snippets and templates
-
-10. **Documentation and Team Onboarding**
-    - Update project documentation for TypeScript setup
-    - Create TypeScript coding standards and best practices guide
-    - Document migration decisions and type system architecture
-    - Set up type documentation generation
-    - Train team members on TypeScript development workflows
-    - Create troubleshooting guide for common TypeScript issues

package/claude/commands/test/generate-test-cases.md

@@ -1,76 +0,0 @@
-# Generate Test Cases
-
-Generate comprehensive test cases automatically
-
-## Instructions
-
-1. **Target Analysis and Scope Definition**
-   - Parse target file or function from arguments: `$ARGUMENTS`
-   - If no target specified, analyze current directory and prompt for specific target
-   - Examine the target code structure, dependencies, and complexity
-   - Identify function signatures, parameters, return types, and side effects
-   - Determine testing scope (unit, integration, or both)
-
-2. **Code Structure Analysis**
-   - Analyze function logic, branching, and control flow
-   - Identify input validation, error handling, and edge cases
-   - Examine external dependencies, API calls, and database interactions
-   - Review data transformations and business logic
-   - Identify async operations and error scenarios
-
-3. **Test Case Generation Strategy**
-   - Generate positive test cases for normal operation flows
-   - Create negative test cases for error conditions and invalid inputs
-   - Generate edge cases for boundary conditions and limits
-   - Create integration test cases for external dependencies
-   - Generate performance test cases for complex operations
-
-4. **Unit Test Implementation**
-   - Create test file following project naming conventions
-   - Set up test framework imports and configuration
-   - Generate test suites organized by functionality
-   - Create comprehensive test cases with descriptive names
-   - Implement proper setup and teardown for each test
-
-5. **Mock and Stub Generation**
-   - Identify external dependencies requiring mocking
-   - Generate mock implementations for APIs and services
-   - Create stub data for database and file system operations
-   - Set up spy functions for monitoring function calls
-   - Configure mock return values and error scenarios
-
-6. **Data-Driven Test Generation**
-   - Create test data sets for various input scenarios
-   - Generate parameterized tests for multiple input combinations
-   - Create fixtures for complex data structures
-   - Set up test data factories for consistent data generation
-   - Generate property-based test cases for comprehensive coverage
-
-7. **Integration Test Scenarios**
-   - Generate tests for component interactions
-   - Create end-to-end workflow test cases
-   - Generate API integration test scenarios
-   - Create database integration tests with real data
-   - Generate cross-module integration test cases
-
-8. **Error Handling and Exception Testing**
-   - Generate tests for all error conditions and exceptions
-   - Create tests for timeout and network failure scenarios
-   - Generate tests for invalid input validation
-   - Create tests for resource exhaustion and limits
-   - Generate tests for concurrent access and race conditions
-
-9. **Test Quality and Coverage**
-   - Ensure comprehensive code coverage for target functions
-   - Generate tests for all code branches and paths
-   - Create tests for both success and failure scenarios
-   - Validate test assertions are meaningful and specific
-   - Ensure tests are isolated and independent
-
-10. **Test Documentation and Maintenance**
-    - Generate clear test descriptions and documentation
-    - Create comments explaining complex test scenarios
-    - Document test data requirements and setup procedures
-    - Generate test maintenance guidelines and best practices
-    - Create test execution and debugging instructions
-    - Validate generated tests execute successfully and provide meaningful feedback