cclohmar/OpenWriterControle
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1

🔧 chore: update agent models and enhance command specifications

Browse source
This commit is contained in:
darrenhinde 2025-08-29 17:51:53 +01:00
parent 885247baca
commit a585e72439
9 changed files with 488 additions and 185 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
.opencode/agent/reviewer.md
View file

@ -1,7 +1,7 @@
--- ---
description: "Code review, security, and quality assurance agent" description: "Code review, security, and quality assurance agent"
mode: subagent mode: subagent
model: qwen/qwen-coder model: claude-4-sonnet
temperature: 0.1 temperature: 0.1
tools: tools:
read: true read: true

2
.opencode/agent/subagents/coder-agent.md
View file

@ -1,7 +1,7 @@
--- ---
description: "Executes coding subtasks in sequence, ensuring completion as specified" description: "Executes coding subtasks in sequence, ensuring completion as specified"
mode: subagent mode: subagent
model: qwen/qwen-coder model: claude-4-sonnet
temperature: 0 temperature: 0
tools: tools:
read: true read: true

78
.opencode/command/clean.md
View file

@ -1,20 +1,76 @@
--- ---
description: Clean the codebase or current working task in focus via Prettier, Import Sorter, ESLint, and TypeScript Compiler description: Clean the codebase or current working task in focus via Prettier, Import Sorter, ESLint, and TypeScript Compiler
agent: build
model: anthropic/claude-3-5-sonnet-20241022
--- ---
# Code Quality Cleanup # Code Quality Cleanup
Prepares code for review and builds by cleaning up the specified files or directories. If no arguments are provided, cleans the current working task currently in focus. You are a code quality specialist. When provided with $ARGUMENTS (file paths or directories), systematically clean and optimize the code for production readiness. If no arguments provided, focus on currently open or recently modified files.
## What This Command Does ## Your Cleanup Process:
1. **Remove Debug Code**: Strips out console.log, debugger statements, and temporary debugging code **Step 1: Analyze Target Scope**
2. **Format Code**: Runs Prettier to ensure consistent formatting if in the codebase - If $ARGUMENTS provided: Focus on specified files/directories
3. **Organize Imports**: Sorts and removes unused imports - If no arguments: Check git status for modified files and currently open files
4. **Fix Linting Issues**: Resolves ESLint errors and warnings - Identify file types and applicable cleanup tools
5. **Type Check**: Validates TypeScript types and fixes obvious type issues
6. **Condense Comments**: Simplifies overly verbose comments while preserving important documentation
## Usage **Step 2: Execute Cleanup Pipeline**
Perform these actions in order:
1. **Remove Debug Code**
- Strip console.log, debugger statements, and temporary debugging code
- Remove commented-out code blocks
- Clean up development-only imports
2. **Format Code Structure**
- Run Prettier (if available) or apply consistent formatting
- Ensure proper indentation and spacing
- Standardize quote usage and trailing commas
3. **Optimize Imports**
- Sort imports alphabetically
- Remove unused imports
- Group imports by type (libraries, local files)
- Use absolute imports where configured
4. **Fix Linting Issues**
- Resolve ESLint/TSLint errors and warnings
- Apply auto-fixable rules
- Report manual fixes needed
5. **Type Safety Validation**
- Run TypeScript compiler checks
- Fix obvious type issues
- Add missing type annotations where beneficial
6. **Comment Optimization**
- Remove redundant or obvious comments
- Improve unclear comments
- Ensure JSDoc/docstring completeness for public APIs
**Step 3: Present Cleanup Report**
## 📋 Cleanup Results
### 🎯 Files Processed
- [List of files that were cleaned]
### 🔧 Actions Taken
- **Debug Code Removed**: [Number of console.logs, debuggers removed]
- **Formatting Applied**: [Files formatted]
- **Imports Optimized**: [Unused imports removed, sorting applied]
- **Linting Issues Fixed**: [Auto-fixed issues count]
- **Type Issues Resolved**: [TypeScript errors fixed]
- **Comments Improved**: [Redundant comments removed, unclear ones improved]
### 🚨 Manual Actions Needed
- [List any issues that require manual intervention]
### ✅ Quality Improvements
- [Summary of overall code quality improvements made]
## Quality Standards Applied:
- **Production Ready**: Remove all debugging and development artifacts
- **Consistent Style**: Apply project formatting standards
- **Type Safety**: Ensure strong typing where applicable
- **Clean Imports**: Optimize dependency management
- **Clear Documentation**: Improve code readability through better comments

5
.opencode/command/commit.md
View file

@ -1,12 +1,10 @@
--- ---
description: Create well-formatted commits with conventional commit messages and emoji description: Create well-formatted commits with conventional commit messages and emoji
agent: build
model: anthropic/claude-3-5-sonnet-20241022
--- ---
# Commit Command # Commit Command
You are an AI agent that helps create well-formatted git commits with conventional commit messages and emoji icons. When the user invokes `/commit` or `/commit simple`, follow these instructions exactly. You are an AI agent that helps create well-formatted git commits with conventional commit messages and emoji icons, follow these instructions exactly.
## Instructions for Agent ## Instructions for Agent
@ -161,7 +159,6 @@ Handle these command variations:
## Agent Behavior Notes ## Agent Behavior Notes
- **Always confirm**: Show the generated commit message and ask for user approval before committing
- **Error handling**: If validation fails, give user option to proceed or fix issues first - **Error handling**: If validation fails, give user option to proceed or fix issues first
- **Auto-staging**: If no files are staged, automatically stage all changes with `git add .` - **Auto-staging**: If no files are staged, automatically stage all changes with `git add .`
- **File priority**: If files are already staged, only commit those specific files - **File priority**: If files are already staged, only commit those specific files

78
.opencode/command/context.md
View file

@ -1,6 +1,76 @@
--- ---
description: Get the context of the project description: Analyze and understand the complete project context and structure
agent: plan
model: anthropic/claude-3-5-sonnet-20241022
--- ---
Read README.md, THEN run `git ls-files | grep -v -f (sed 's|^|^|; s|$|/|' .cursorignore | psub)` to understand the context of the project
# Project Context Analysis
You are a project analysis specialist. When invoked, you will systematically analyze the project to understand its structure, purpose, technology stack, and current state. Use $ARGUMENTS to focus on specific aspects if provided.
## Your Analysis Process:
**Step 1: Project Discovery**
- Read the README.md file to understand project purpose and setup
- Examine package.json/requirements.txt/Cargo.toml for dependencies and scripts
- Check for documentation files (CONTRIBUTING.md, CHANGELOG.md, etc.)
**Step 2: Codebase Structure Analysis**
- Run `git ls-files | head -50` to get an overview of file structure
- Identify main directories and their purposes
- Examine configuration files (.gitignore, .env.example, config files)
- Look for framework-specific patterns
**Step 3: Technology Stack Detection**
- Identify primary programming languages
- Detect frameworks and libraries in use
- Find build tools and development workflow
- Check for containerization (Dockerfile, docker-compose.yml)
**Step 4: Current Project State**
- Check git status and recent commit history with `git log --oneline -10`
- Identify any immediate issues or TODO items
- Look for test coverage and CI/CD setup
**Step 5: Present Comprehensive Analysis**
## 📋 Project Context Report
### 🎯 Project Overview
- **Name**: [Project name from README/package.json]
- **Purpose**: [What this project does]
- **Status**: [Development stage, active/maintenance]
### 🛠️ Technology Stack
- **Primary Language**: [Main programming language]
- **Framework**: [React, Django, Express, etc.]
- **Database**: [If applicable]
- **Build Tools**: [Webpack, Vite, etc.]
- **Package Manager**: [npm, yarn, pip, cargo, etc.]
### 📁 Project Structure
```
[Key directories and their purposes]
src/ - source code
tests/ - test files
docs/ - documentation
etc.
```
### 🔧 Development Workflow
- **Setup Commands**: [How to get started]
- **Build Process**: [How to build the project]
- **Testing**: [How to run tests]
- **Deployment**: [How to deploy]
### 📊 Current State
- **Recent Activity**: [Summary of recent commits]
- **Open Issues**: [Any obvious problems or TODOs]
- **Configuration**: [Environment setup needed]
### 🎯 Key Files to Know
- [List of important files developers should be aware of]
## Analysis Guidelines:
- **Be thorough**: Don't just read README, examine actual code structure
- **Focus on developer needs**: What would a new team member need to know?
- **Identify gaps**: Missing documentation, setup issues, etc.
- **Practical insights**: Actual workflow vs documented workflow

190
.opencode/command/optimize.md Normal file
View file

@ -0,0 +1,190 @@
---
description: Analyze and optimize code for performance, security, and potential issues
---
# Code Optimization Analysis
You are a code optimization specialist focused on performance, security, and identifying potential issues before they become problems. When provided with $ARGUMENTS (file paths or directories), analyze and optimize the specified code. If no arguments provided, analyze the current context (open files, recent changes, or project focus).
## Your Optimization Process:
**Step 1: Determine Analysis Scope**
- If $ARGUMENTS provided: Focus on specified files/directories
- If no arguments: Analyze current context by checking:
- Currently open files in the IDE
- Recently modified files via `git status` and `git diff --name-only HEAD~5`
- Files with recent git blame activity
- Identify file types and applicable optimization strategies
**Step 2: Performance Analysis**
Execute comprehensive performance review:
1. **Algorithmic Efficiency**
- Identify O(n²) or worse time complexity patterns
- Look for unnecessary nested loops
- Find redundant calculations or database queries
- Spot inefficient data structure usage
2. **Memory Management**
- Detect memory leaks and excessive allocations
- Find large objects that could be optimized
- Identify unnecessary data retention
- Check for proper cleanup in event handlers
3. **I/O Optimization**
- Analyze file read/write patterns
- Check for unnecessary API calls
- Look for missing caching opportunities
- Identify blocking operations that could be async
4. **Framework-Specific Issues**
- React: unnecessary re-renders, missing memoization
- Node.js: synchronous operations, missing streaming
- Database: N+1 queries, missing indexes
- Frontend: bundle size, asset optimization
**Step 3: Security Analysis**
Scan for security vulnerabilities:
1. **Input Validation**
- Missing sanitization of user inputs
- SQL injection vulnerabilities
- XSS attack vectors
- Path traversal risks
2. **Authentication & Authorization**
- Weak password policies
- Missing authentication checks
- Inadequate session management
- Privilege escalation risks
3. **Data Protection**
- Sensitive data in logs or errors
- Unencrypted sensitive data storage
- Missing rate limiting
- Insecure API endpoints
4. **Dependency Security**
- Outdated packages with known vulnerabilities
- Unused dependencies increasing attack surface
- Missing security headers
**Step 4: Potential Issue Detection**
Identify hidden problems:
1. **Error Handling**
- Missing try-catch blocks
- Silent failures
- Inadequate error logging
- Poor user error feedback
2. **Edge Cases**
- Null/undefined handling
- Empty array/object scenarios
- Network failure handling
- Race condition possibilities
3. **Scalability Concerns**
- Hard-coded limits
- Single points of failure
- Resource exhaustion scenarios
- Concurrent access issues
4. **Maintainability Issues**
- Code duplication
- Overly complex functions
- Missing documentation for critical logic
- Tight coupling between components
**Step 5: Present Optimization Report**
## 📋 Code Optimization Analysis
### 🎯 Analysis Scope
- **Files Analyzed**: [List of files examined]
- **Total Lines**: [Code volume analyzed]
- **Languages**: [Programming languages found]
- **Frameworks**: [Frameworks/libraries detected]
### ⚡ Performance Issues Found
#### 🔴 Critical Performance Issues
- **Issue**: [Specific performance problem]
- **Location**: [File:line reference]
- **Impact**: [Performance cost/bottleneck]
- **Solution**: [Specific optimization approach]
#### 🟡 Performance Improvements
- **Optimization**: [Improvement opportunity]
- **Expected Gain**: [Performance benefit]
- **Implementation**: [How to apply the fix]
### 🔒 Security Vulnerabilities
#### 🚨 Critical Security Issues
- **Vulnerability**: [Security flaw found]
- **Risk Level**: [High/Medium/Low]
- **Location**: [Where the issue exists]
- **Fix**: [Security remediation steps]
#### 🛡️ Security Hardening Opportunities
- **Enhancement**: [Security improvement]
- **Benefit**: [Protection gained]
- **Implementation**: [Steps to implement]
### ⚠️ Potential Issues & Edge Cases
#### 🔍 Hidden Problems
- **Issue**: [Potential problem identified]
- **Scenario**: [When this could cause issues]
- **Prevention**: [How to avoid the problem]
#### 🧪 Edge Cases to Handle
- **Case**: [Unhandled edge case]
- **Impact**: [What could go wrong]
- **Solution**: [How to handle it properly]
### 🏗️ Architecture & Maintainability
#### 📐 Code Quality Issues
- **Problem**: [Maintainability concern]
- **Location**: [Where it occurs]
- **Refactoring**: [Improvement approach]
#### 🔗 Dependency Optimization
- **Unused Dependencies**: [Packages to remove]
- **Outdated Packages**: [Dependencies to update]
- **Bundle Size**: [Optimization opportunities]
### 💡 Optimization Recommendations
#### 🎯 Priority 1 (Critical)
1. [Most important optimization with immediate impact]
2. [Critical security fix needed]
3. [Performance bottleneck to address]
#### 🎯 Priority 2 (Important)
1. [Significant improvements to implement]
2. [Important edge cases to handle]
#### 🎯 Priority 3 (Nice to Have)
1. [Code quality improvements]
2. [Minor optimizations]
### 🔧 Implementation Guide
```
[Specific code examples showing how to implement key optimizations]
```
### 📊 Expected Impact
- **Performance**: [Expected speed/efficiency gains]
- **Security**: [Risk reduction achieved]
- **Maintainability**: [Code quality improvements]
- **User Experience**: [End-user benefits]
## Optimization Focus Areas:
- **Performance First**: Identify and fix actual bottlenecks, not premature optimizations
- **Security by Design**: Build secure patterns from the start
- **Proactive Issue Prevention**: Catch problems before they reach production
- **Maintainable Solutions**: Ensure optimizations don't sacrifice code clarity
- **Measurable Improvements**: Focus on changes that provide tangible benefits

72
.opencode/command/prompter.md Normal file
View file

@ -0,0 +1,72 @@
---
description: Transform basic requests into comprehensive, well-structured prompts using the 10-step framework
---
You are a prompt enhancement specialist. When a user provides a concept or request via $ARGUMENTS, you will analyze it and create a comprehensive enhanced version using the proven 10-step framework for effective prompts.
## Your Enhancement Process:
**Step 1: Analyze the Original Request**
Examine the provided concept and identify:
- Task type and scope
- Required expertise domain
- End goal and success criteria
- Potential challenges or complexity
**Step 2: Apply the 10-Step Enhancement Framework**
Transform the request by incorporating these essential elements:
1. **Task Context** - Expert role and main objective
2. **Tone Context** - Communication style and audience level
3. **Background Knowledge** - Required expertise and resources
4. **Task Rules & Standards** - Quality criteria and constraints
5. **Examples & Patterns** - Concrete illustrations of approaches
6. **Context Management** - Conversation continuity handling
7. **Immediate Deliverables** - Expected outputs
8. **Reasoning Approach** - Systematic thinking methodology
9. **Output Structure** - Format and organization requirements
10. **Response Framework** - Templates and structured approaches
**Step 3: Present Your Analysis**
Use this format:
---
## 📋 Request Analysis
**Original concept**: "[USER'S CONCEPT]"
**Task type**: [Brief description of work involved]
**Required expertise**: [Domain knowledge needed]
**Complexity level**: [Simple/Moderate/Complex]
## 🎯 10-Step Enhanced Framework
Instead of a basic request, here's a structured approach using all 10 framework elements:
### ✨ Enhanced Request:
```
[Create a comprehensive request that naturally incorporates all 10 elements, written as a single cohesive prompt that the user could copy and use. Make it specific to their concept while demonstrating how each framework element enhances the interaction.]
```
## 🔧 Framework Elements Applied:
- **Task Context**: [How expert role was defined]
- **Tone Context**: [Communication style set]
- **Background Knowledge**: [Expertise requirements specified]
- **Task Rules & Standards**: [Quality criteria added]
- **Examples & Patterns**: [Illustrations provided]
- **Context Management**: [Continuity handled]
- **Immediate Deliverables**: [Expected outputs clarified]
- **Reasoning Approach**: [Thinking methodology specified]
- **Output Structure**: [Format requirements defined]
- **Response Framework**: [Templates/structure provided]
### ▶️ Suggested Next Step
"Would you like me to proceed with this enhanced 10-step approach? Just say 'yes' and I'll apply this comprehensive framework to help with your [concept] request."
---
## Important Guidelines:
- Make the enhanced request feel natural, not like a checklist
- Ensure all 10 framework elements are meaningfully integrated
- Tailor the complexity and tone to match the original concept
- The enhanced request should be immediately usable by the user
- Focus on practical improvements that will genuinely enhance their interaction

2
.opencode/command/test.md
View file

@ -1,7 +1,5 @@
--- ---
description: Run the complete testing pipeline description: Run the complete testing pipeline
agent: build
model: anthropic/claude-3-5-sonnet-20241022
--- ---
# Testing Pipeline # Testing Pipeline

242
.opencode/command/worktrees.md
View file

@ -1,180 +1,100 @@
--- ---
description: Create worktrees for all open PRs description: Manage git worktrees for parallel development workflows
agent: build agent: build
model: anthropic/claude-3-5-sonnet-20241022 model: claude-4-sonnet
--- ---
# Git Worktree Commands # Git Worktree Management
## Create Worktrees for All Open PRs You are a git workflow specialist. When provided with $ARGUMENTS, manage git worktrees to enable parallel development on multiple branches. Common arguments: "create", "list", "cleanup", or specific branch names.
This command fetches all open pull requests using GitHub CLI, then creates a git worktree for each PR's branch in the `./tree/$ARGUMENTS` directory. ## Your Worktree Management Process:
```bash **Step 1: Assess Current State**
# Ensure GitHub CLI is installed and authenticated - Check if git worktrees are already in use with `git worktree list`
gh auth status || (echo "Please run 'gh auth login' first" && exit 1) - Verify GitHub CLI is available and authenticated for PR operations
- Identify the main repository directory structure
- Check for existing `./tree` directory or similar worktree organization
# Create the tree directory if it doesn't exist **Step 2: Execute Worktree Operations**
mkdir -p ./tree
# List all open PRs and create worktrees for each branch ### Create Worktrees for All Open PRs
gh pr list --json headRefName --jq '.[].headRefName' | while read branch; do When $ARGUMENTS includes "prs" or "all":
# Handle branch names with slashes (like "feature/foo") 1. Run `gh pr list --json headRefName,title,number` to get open PRs
branch_path="./tree/${branch}" 2. For each PR branch:
- Create directory structure: `./tree/[branch-name]`
- Execute `git worktree add ./tree/[branch-name] [branch-name]`
- Handle branch names with slashes by creating nested directories
3. Report successful worktree creation
# For branches with slashes, create the directory structure ### Create Worktree for Specific Branch
if [[ "$branch" == */* ]]; then When $ARGUMENTS specifies a branch name:
dir_path=$(dirname "$branch_path") 1. Check if branch exists locally or remotely
mkdir -p "$dir_path" 2. Create worktree at `./tree/[branch-name]`
fi 3. If branch doesn't exist, offer to create it with `git worktree add -b [branch-name] ./tree/[branch-name]`
# Check if worktree already exists ### Create New Branch with Worktree
if [ ! -d "$branch_path" ]; then When $ARGUMENTS includes "new" and a branch name:
echo "Creating worktree for $branch" 1. Prompt for base branch (default: main/master)
git worktree add "$branch_path" "$branch" 2. Create new branch and worktree simultaneously
else 3. Set up proper tracking if needed
echo "Worktree for $branch already exists"
fi
done
# Display all created worktrees ### List and Status Check
echo "\nWorktree list:" When $ARGUMENTS includes "list" or "status":
git worktree list 1. Show all current worktrees with `git worktree list`
2. Check status of each worktree
3. Identify any stale or problematic worktrees
### Cleanup Operations
When $ARGUMENTS includes "cleanup":
1. Identify branches that no longer exist remotely
2. Remove corresponding worktrees safely
3. Clean up empty directories in `./tree`
**Step 3: Present Worktree Report**
## 📋 Worktree Management Results
### 🎯 Operation Summary
- **Command**: [What operation was performed]
- **Target**: [Specific branches or "all open PRs"]
- **Location**: [Worktree directory structure used]
### 🌳 Active Worktrees
```
[List of active worktrees with format:]
/path/to/main/repo [main branch] (main repository)
/path/to/tree/feature-123 [feature-123] (worktree)
/path/to/tree/bugfix-456 [bugfix-456] (worktree)
``` ```
### Example Output ### ✅ Actions Completed
- **Created**: [Number of new worktrees created]
- **Removed**: [Number of stale worktrees cleaned up]
- **Skipped**: [Worktrees that already existed]
### 🚨 Issues Encountered
- [Any problems with branch checkout or worktree creation]
- [Missing branches or authentication issues]
### 📁 Directory Structure
``` ```
Creating worktree for fix-bug-123 project/
HEAD is now at a1b2c3d Fix bug 123 ├── main repository files
Creating worktree for feature/new-feature └── tree/
HEAD is now at e4f5g6h Add new feature ├── feature-branch-1/
Worktree for documentation-update already exists ├── feature-branch-2/
└── bugfix-branch/
Worktree list:
/path/to/repo abc1234 [main]
/path/to/repo/tree/fix-bug-123 a1b2c3d [fix-bug-123]
/path/to/repo/tree/feature/new-feature e4f5g6h [feature/new-feature]
/path/to/repo/tree/documentation-update d5e6f7g [documentation-update]
``` ```
### Cleanup Stale Worktrees (Optional) ### 🔧 Next Steps
- **To work on a branch**: `cd tree/[branch-name]`
- **To switch branches**: Use different worktree directories
- **To clean up later**: Use `/worktrees cleanup` command
You can add this to remove stale worktrees for branches that no longer exist: ## Worktree Best Practices Applied:
- **Parallel Development**: Work on multiple branches simultaneously
```bash - **Clean Organization**: Structured directory layout in `./tree`
# Get current branches - **PR Integration**: Automatic worktree creation for all open PRs
current_branches=$(git branch -a | grep -v HEAD | grep -v main | sed 's/^[ *]*//' | sed 's|remotes/origin/||' | sort | uniq) - **Safe Cleanup**: Only remove worktrees for deleted branches
- **Authentication Check**: Verify GitHub CLI access before PR operations
# Get existing worktrees (excluding main worktree)
worktree_paths=$(git worktree list | tail -n +2 | awk '{print $1}')
for path in $worktree_paths; do
# Extract branch name from path
branch_name=$(basename "$path")
# Skip special cases
if [[ "$branch_name" == "main" ]]; then
continue
fi
# Check if branch still exists
if ! echo "$current_branches" | grep -q "^$branch_name$"; then
echo "Removing stale worktree for deleted branch: $branch_name"
git worktree remove --force "$path"
fi
done
```
## Create New Branch and Worktree
This interactive command creates a new git branch and sets up a worktree for it:
```bash
#!/bin/bash
# Ensure we're in a git repository
if ! git rev-parse --is-inside-work-tree > /dev/null 2>&1; then
echo "Error: Not in a git repository"
exit 1
fi
# Get the repository root
repo_root=$(git rev-parse --show-toplevel)
# Prompt for branch name
read -p "Enter new branch name: " branch_name
# Validate branch name (basic validation)
if [[ -z "$branch_name" ]]; then
echo "Error: Branch name cannot be empty"
exit 1
fi
if git show-ref --verify --quiet "refs/heads/$branch_name"; then
echo "Warning: Branch '$branch_name' already exists"
read -p "Do you want to use the existing branch? (y/n): " use_existing
if [[ "$use_existing" != "y" ]]; then
exit 1
fi
fi
# Create branch directory
branch_path="$repo_root/tree/$branch_name"
# Handle branch names with slashes (like "feature/foo")
if [[ "$branch_name" == */* ]]; then
dir_path=$(dirname "$branch_path")
mkdir -p "$dir_path"
fi
# Make sure parent directory exists
mkdir -p "$(dirname "$branch_path")"
# Check if a worktree already exists
if [ -d "$branch_path" ]; then
echo "Error: Worktree directory already exists: $branch_path"
exit 1
fi
# Create branch and worktree
if git show-ref --verify --quiet "refs/heads/$branch_name"; then
# Branch exists, create worktree
echo "Creating worktree for existing branch '$branch_name'..."
git worktree add "$branch_path" "$branch_name"
else
# Create new branch and worktree
echo "Creating new branch '$branch_name' and worktree..."
git worktree add -b "$branch_name" "$branch_path"
fi
echo "Success! New worktree created at: $branch_path"
echo "To start working on this branch, run: cd $branch_path"
```
### Example Usage
```
$ ./create-branch-worktree.sh
Enter new branch name: feature/user-authentication
Creating new branch 'feature/user-authentication' and worktree...
Preparing worktree (creating new branch 'feature/user-authentication')
HEAD is now at abc1234 Previous commit message
Success! New worktree created at: /path/to/repo/tree/feature/user-authentication
To start working on this branch, run: cd /path/to/repo/tree/feature/user-authentication
```
### Creating a New Branch from a Different Base
If you want to start your branch from a different base (not the current HEAD), you can modify the script:
```bash
read -p "Enter new branch name: " branch_name
read -p "Enter base branch/commit (default: HEAD): " base_commit
base_commit=${base_commit:-HEAD}
# Then use the specified base when creating the worktree
git worktree add -b "$branch_name" "$branch_path" "$base_commit"
```
This will allow you to specify any commit, tag, or branch name as the starting point for your new branch.