@adiontaegerron/claude-multi-terminal 2.5.2 → 3.0.1

package/.claude/commands/at.md

@@ -0,0 +1,232 @@
+# Direct Terminal Messaging with @ Syntax
+
+You are helping a user send commands directly to terminals using the @ messaging syntax.
+
+## Current Application Context
+
+The user has a multi-terminal application with advanced @ syntax for direct terminal communication:
+- `@terminal command` - Send command directly to named terminal
+- `@all command` - Send to all terminals
+- `@term1,term2 command` - Send to multiple terminals (comma-separated)
+- `@term1 @term2 command` - Send to multiple terminals (space-separated)
+- `@"Terminal Name" command` - Handle terminals with spaces in names
+
+## Your Task
+
+Help the user communicate directly with terminals using the flexible @ messaging syntax.
+
+### Basic Usage Patterns
+```
+@terminal command
+@"Terminal Name" command
+@all command
+@term1,term2,term3 command
+@term1 @term2 command
+```
+
+## Available Functions
+
+Key functions used:
+- `parseComplexCommand(message)` - Parses mixed @ and / syntax (renderer.js:346)
+- `executeAtCommand(message)` - Handles @ terminal messaging (renderer.js:792)
+- `findTerminal(identifier)` - Locates terminals by various methods
+- Auto-return functionality after 150ms delay
+
+## Syntax Variations
+
+### Single Terminal
+```
+@Terminal1 ls -la
+@"My Server" systemctl status nginx
+@database show tables;
+@1 pwd  # By position number
+```
+
+### Multiple Terminals (Comma-separated)
+```
+@server1,server2,server3 uptime
+@"Web Server","Database Server" df -h
+@term1,term2 git status
+```
+
+### Multiple Terminals (Space-separated)
+```
+@server1 @server2 @server3 whoami
+@"Production" @"Staging" docker ps
+@frontend @backend npm test
+```
+
+### All Terminals
+```
+@all pwd
+@all clear
+@all git pull
+@all "echo 'Hello from all terminals'"
+```
+
+## Advanced Features
+
+### Mixed Command Parsing
+The system supports complex commands mixing @ terminals and / commands:
+```
+@server1 ls /var/log @server2 ps aux /list
+@all pwd /send database "show tables;"
+```
+
+### Quoted Terminal Names
+Handle terminals with spaces or special characters:
+```
+@"My Production Server" systemctl restart nginx
+@"Database - Primary" mysql -u root -p
+@"Frontend Dev Environment" npm run dev
+```
+
+### Terminal Identification Methods
+1. **Exact name match** (case-insensitive)
+2. **Partial name match** 
+3. **Position number** (1-based)
+4. **Terminal ID** (internal identifier)
+
+## Auto-execution Features
+
+**Automatic return:**
+- Commands are automatically submitted after 150ms
+- No need for manual `/return` command
+- Seamless command execution experience
+
+**Plan mode integration:**
+- Respects "Send in Plan Mode" checkbox
+- Sends Shift+Tab twice if plan mode enabled
+- Auto-returns after plan mode activation
+
+**Default prompt integration:**
+- Respects "Use Default Prompt" setting
+- Prepends default prompt to non-slash commands
+- Configurable prompt text
+
+## Error Handling
+
+**Terminal not found:**
+- Shows specific terminals that weren't found
+- Lists available terminals for reference
+- Continues with found terminals if some succeed
+- Clear error messages for troubleshooting
+
+**Invalid syntax:**
+- Provides usage examples
+- Suggests correct @ syntax patterns
+- Explains terminal identification methods
+
+## Use Cases
+
+### Development Workflows
+```
+@frontend npm run build
+@backend npm test
+@database npm run migrate
+@all git status
+```
+
+### Server Management
+```
+@"Production Server" systemctl status nginx
+@"Staging Server" docker ps
+@all df -h
+@monitoring top
+```
+
+### Multi-environment Operations
+```
+@prod,staging,dev docker pull latest
+@"Web1" @"Web2" @"Web3" nginx -t
+@all "echo $NODE_ENV"
+```
+
+### Quick Diagnostics
+```
+@all uptime
+@all "ps aux | grep node"
+@servers1,server2 "netstat -tulpn | grep :80"
+```
+
+## Integration with Other Features
+
+**With slash commands:**
+```
+@server1 ls /send server2 pwd
+/list @all whoami
+```
+
+**With messaging panel:**
+- @ commands appear in message history
+- Tracked for coordination purposes
+- Visible in inter-terminal communication log
+
+**With quick messages:**
+- Message panel can use @ syntax
+- Dropdown integration for terminal selection
+- History tracking for sent messages
+
+## Performance Considerations
+
+**Parallel execution:**
+- Multiple terminals receive commands simultaneously
+- No blocking between terminal communications
+- Efficient for batch operations
+
+**Auto-return timing:**
+- 150ms delay allows command to be typed fully
+- Automatic submission reduces manual steps
+- Can be overridden with manual `/return` if needed
+
+## Best Practices
+
+### Terminal Naming
+- Use descriptive names for easy identification
+- Avoid special characters that complicate parsing
+- Consider consistent naming conventions
+- Rename terminals for better workflow organization
+
+### Command Safety
+```
+# Good - Clear target and safe command
+@database "SELECT COUNT(*) FROM users;"
+
+# Careful - Destructive command, verify target
+@production "rm -rf /tmp/cache"
+
+# Best - Use /list first to verify terminals
+/list
+@"Verified Production" systemctl restart nginx
+```
+
+### Multi-terminal Operations
+```
+# Coordinated deployment
+@all git pull
+@backend npm install
+@frontend npm run build
+@all pm2 restart all
+```
+
+## Troubleshooting
+
+**Terminal not responding:**
+1. Use `/list` to verify terminal exists
+2. Check terminal name spelling
+3. Try position number instead of name
+4. Use `/interrupt terminal` if hung
+
+**Commands not executing:**
+1. Verify @ syntax is correct
+2. Check for typos in terminal names
+3. Ensure commands are properly quoted
+4. Use `/return terminal` for manual execution
+
+**Partial execution:**
+1. Check which terminals succeeded
+2. Retry failed terminals individually
+3. Verify terminal states with `/list`
+4. Clear problematic terminals with `/clear`
+
+Focus on helping the user master the flexible @ syntax for efficient multi-terminal communication and command execution.

package/.claude/commands/clear.md

@@ -0,0 +1,169 @@
+# Clear Terminal Input Line
+
+You are helping a user clear the current input line in a specific terminal (equivalent to pressing Ctrl+C).
+
+## Current Application Context
+
+The user has a multi-terminal application where:
+- Terminals may have partially typed commands that need to be cleared
+- The `/clear <terminal>` command sends Ctrl+C to clear input
+- This interrupts current input without executing it
+- Also used for interrupting running commands
+
+## Your Task
+
+Help the user clear current input or interrupt commands in a specific terminal using the `/clear` slash command.
+
+### Usage Pattern
+```
+/clear <terminal>
+```
+
+### Terminal Identification
+Terminals can be identified by:
+1. **Exact name**: `Terminal 1`, `MyServer`, etc.
+2. **Position number**: `1`, `2`, `3` (1-based)
+3. **Partial name match**: `server` matches "MyServer"
+4. **Terminal ID**: `terminal-1`, `terminal-2`, etc.
+
+### Examples
+- `/clear Terminal1` - Clear input in Terminal1
+- `/clear 1` - Clear input in first terminal
+- `/clear "My Server"` - Clear in terminal with spaces in name
+- `/clear server` - Clear in terminal containing "server"
+- `/clear Database` - Clear current database command
+
+## Available Functions
+
+Key functions used:
+- `executeClearCommand(args)` - Processes clear command (renderer.js:770)
+- `findTerminal(identifier)` - Locates target terminal
+- `ipcRenderer.invoke('terminal:write', terminalId, '\x03')` - Sends Ctrl+C
+- Same function handles `/interrupt` command
+
+## Technical Details
+
+**What happens:**
+1. **Find target terminal** - Using findTerminal() function
+2. **Send Ctrl+C signal** - `\x03` control character
+3. **Clear current line** - Cancels current input
+4. **Interrupt execution** - Stops running commands
+5. **Provide feedback** - Confirm Ctrl+C sent
+
+**Ctrl+C character:**
+- `\x03` is the ASCII control character for Ctrl+C
+- Standard interrupt signal in Unix-like systems
+- Clears current input line if no command running
+- Interrupts/terminates running commands
+- Returns to fresh command prompt
+
+## Use Cases
+
+**Input Management:**
+- Clear partially typed commands
+- Cancel commands before execution
+- Start over with fresh command line
+- Remove unwanted input
+
+**Command Interruption:**
+- Stop long-running commands
+- Cancel infinite loops or hangs
+- Interrupt interactive programs
+- Emergency stop for runaway processes
+
+**Workflow Control:**
+- Reset terminal state
+- Clear before sending new commands
+- Ensure clean command environment
+- Standardize terminal state
+
+**Debug and Recovery:**
+- Escape from problematic commands
+- Reset terminals that seem "stuck"
+- Clear garbled or corrupted input
+- Recover from terminal errors
+
+## Command Behavior
+
+**When no command is running:**
+- Clears current input line
+- Returns to fresh prompt
+- Discards any typed text
+- Ready for new input
+
+**When command is running:**
+- Sends interrupt signal to process
+- May terminate the running command
+- Some commands may ignore Ctrl+C
+- Returns control to shell
+
+**Interactive programs:**
+- May exit the program
+- May return to program's main menu
+- Behavior depends on the specific program
+- Generally provides escape mechanism
+
+## Error Handling
+
+If terminal is not found:
+- Shows "Terminal 'name' not found"
+- Lists available terminals for reference
+- Suggests correct terminal identifiers
+- No action taken on non-existent terminals
+
+## Alternative Command
+
+**`/interrupt` command:**
+- Identical functionality to `/clear`
+- Same implementation in code
+- Alternative name for clarity
+- Use whichever feels more natural
+
+## Safety Considerations
+
+- **Data loss** - May lose unsaved work in interrupted commands
+- **Process state** - Running commands may be terminated abruptly
+- **File operations** - Interrupted file operations may leave partial results
+- **Confirmation** - Consider if the interruption is really needed
+
+## Integration Patterns
+
+**Before sending commands:**
+```
+/clear Terminal1
+@Terminal1 new-command
+```
+
+**Emergency stop:**
+```
+/clear all-terminals  # If available
+```
+
+**Workflow reset:**
+```
+/clear Database
+/send Database "show tables;"
+```
+
+## Related Commands
+
+- `/interrupt <terminal>` - Identical to `/clear`
+- `/return <terminal>` - Submit current input instead of clearing
+- `/send <terminal> <command>` - Send new command (may want to clear first)
+- `@terminal <command>` - Direct messaging (automatically handles input)
+
+## Best Practices
+
+**When to use:**
+- Before sending important commands
+- When terminal seems unresponsive
+- To stop long-running operations
+- When input line is corrupted
+
+**When to avoid:**
+- During critical file operations
+- When unsure about command state
+- If losing work would be problematic
+- For commands that handle interrupts poorly
+
+Focus on helping the user safely manage terminal input and interrupt problematic commands when necessary.

package/.claude/commands/close.md

@@ -0,0 +1,105 @@
+# Close Specific Terminal
+
+You are helping a user close a specific terminal in their multi-terminal desktop application.
+
+## Current Application Context
+
+The user has a multi-terminal application where:
+- Multiple terminals can be active simultaneously
+- Each terminal can be closed individually
+- Terminal processes are properly cleaned up when closed
+- The `/close <terminal>` command removes specific terminals
+
+## Your Task
+
+Help the user close a specific terminal using the `/close` slash command.
+
+### Usage Pattern
+```
+/close <terminal>
+```
+
+### Terminal Identification
+Terminals can be identified by:
+1. **Exact name**: `Terminal 1`, `MyServer`, etc.
+2. **Position number**: `1`, `2`, `3` (1-based)
+3. **Partial name match**: `server` matches "MyServer"
+4. **Terminal ID**: `terminal-1`, `terminal-2`, etc.
+
+### Examples
+- `/close Terminal1` - Close terminal named "Terminal1"
+- `/close 1` - Close the first terminal (by position)
+- `/close "My Server"` - Close terminal with spaces in name
+- `/close server` - Close terminal containing "server" in name
+- `/close MyDatabase` - Close specific database terminal
+
+## Available Functions
+
+Key functions used:
+- `executeCloseCommand(args)` - Processes the close command (renderer.js:727)
+- `closeTerminal(terminalId)` - Actually closes the terminal (renderer.js:311)
+- `findTerminal(identifier)` - Locates terminal by various methods
+- Proper cleanup of xterm.js, pty process, and DOM elements
+
+## Terminal Cleanup Process
+
+1. **Find target terminal** - Using findTerminal() function
+2. **Close pty process** - `ipcRenderer.invoke('terminal:close', terminalId)`
+3. **Dispose xterm.js** - Clean up terminal rendering
+4. **Remove DOM elements** - Remove terminal container from UI
+5. **Update terminal map** - Remove from internal tracking
+6. **Notify user** - Confirm successful closure
+
+## Safety Features
+
+- **Terminal validation** - Ensures terminal exists before closing
+- **Graceful cleanup** - Properly terminates all processes
+- **Error handling** - Shows available terminals if target not found
+- **Process termination** - Kills associated pty processes
+- **Memory cleanup** - Removes all references and listeners
+
+## Use Cases
+
+**Workflow Management:**
+- `/close Testing` - Done with testing, clean up
+- `/close 1` - Close first terminal by position
+- `/close "Old Project"` - Remove outdated workspace
+
+**Resource Management:**
+- Close unused terminals to free resources
+- Clean up completed tasks
+- Organize active workspace
+- Reduce visual clutter
+
+**Project Switching:**
+- `/close Frontend` - Switch from frontend work
+- `/close Database` - Done with database tasks
+- `/close Monitoring` - No longer need monitoring
+
+## Error Handling
+
+If terminal is not found:
+- Shows "Terminal 'name' not found"
+- Lists available terminals for reference
+- Suggests correct terminal identifiers
+- No action taken on non-existent terminals
+
+## Alternative Closure Methods
+
+- **UI close button** - Click × on terminal header
+- **Application shutdown** - Closes all terminals automatically
+- **Process exit** - Terminal closes when shell exits
+
+## Integration with Other Commands
+
+Before closing:
+- Use `/list` to see available terminals
+- Verify terminal name/ID is correct
+- Save any important work in the terminal
+
+After closing:
+- Use `/list` to confirm terminal is removed
+- Create new terminal with `/create` if needed
+- Reorganize remaining terminals as needed
+
+Focus on helping the user safely and efficiently manage their terminal workspace by closing terminals they no longer need.

package/.claude/commands/create.md

@@ -0,0 +1,83 @@
+# Create New Terminal
+
+You are helping a user create a new terminal instance in their multi-terminal desktop application.
+
+## Current Application Context
+
+The user has a multi-terminal application where:
+- New terminals can be created with optional custom names
+- Each terminal automatically starts with Claude Code
+- Terminals are managed by the `createTerminal()` function
+- Users can rename terminals later by double-clicking the title
+
+## Your Task
+
+Help the user create a new terminal using the `/create` slash command.
+
+### Usage Pattern
+```
+/create [name]
+```
+
+### Examples
+- `/create` - Create terminal with auto-generated name ("Terminal N")
+- `/create MyServer` - Create terminal named "MyServer"
+- `/create "Development Environment"` - Create with quoted name containing spaces
+- `/create API-Server` - Create terminal for API development
+- `/create Database` - Create terminal for database operations
+
+## Available Functions
+
+Key functions used:
+- `executeCreateCommand(args)` - Processes the create command (renderer.js:721)
+- `createTerminal(customName)` - Actually creates the terminal (renderer.js:149)
+- Auto-generates unique terminal ID (`terminal-N`)
+- Sets up xterm.js interface and node-pty backend
+
+## Terminal Creation Process
+
+1. **Generate unique ID** - `terminal-1`, `terminal-2`, etc.
+2. **Set display name** - Custom name or "Terminal N"
+3. **Create UI elements** - Header, xterm container, close button
+4. **Initialize xterm.js** - Terminal rendering with themes
+5. **Spawn pty process** - Backend shell process
+6. **Auto-start Claude** - Sends `claude\r` command
+7. **Set up event handlers** - Data flow, resize, focus
+
+## Terminal Features
+
+Each new terminal includes:
+- **Xterm.js interface** - Full terminal emulation
+- **Rename capability** - Double-click title to rename
+- **Close button** - Individual terminal management
+- **Auto-focus** - Ready for immediate use
+- **Claude Code integration** - Starts with Claude automatically
+- **Resize handling** - Responsive to window changes
+
+## Use Cases
+
+**Development Workflows:**
+- `/create Frontend` - For React/Vue development
+- `/create Backend` - For Node.js/Python services
+- `/create Database` - For database operations
+- `/create Testing` - For running tests
+
+**Server Management:**
+- `/create "Production Server"` - SSH to production
+- `/create "Staging Environment"` - Development testing
+- `/create Monitoring` - System monitoring tools
+
+**Project Organization:**
+- `/create "Project A"` - Separate project workspace
+- `/create Documentation` - For docs and notes
+- `/create Utilities` - For ad-hoc commands
+
+## Integration with Other Commands
+
+After creating a terminal:
+- Use `/list` to see the new terminal
+- Send commands with `@TerminalName command`
+- Manage with `/close TerminalName`
+- Control with `/return`, `/clear`, `/interrupt`
+
+Focus on helping the user create well-organized terminals that support their specific workflow needs.

package/.claude/commands/help.md

@@ -0,0 +1,85 @@
+# Show Available Commands
+
+You are helping a user understand all available commands in their multi-terminal desktop application.
+
+## Current Application Context
+
+The user has a multi-terminal application with:
+- Slash commands (`/command`) for system operations
+- @ syntax (`@terminal`) for direct terminal messaging
+- Various terminal management and communication features
+
+## Your Task
+
+Help the user understand all available commands and their usage patterns using the `/help` slash command.
+
+### Usage Pattern
+```
+/help
+```
+
+## Available Commands Overview
+
+### Slash Commands
+- `/send <terminal> <command>` - Send command to specific terminal
+- `/send-all <command>` - Send command to all terminals
+- `/list` - List all terminals
+- `/help` - Show available commands
+- `/create [name]` - Create new terminal with optional name
+- `/close <terminal>` - Close specific terminal
+- `/return <terminal>` - Submit current input in specified terminal (press Enter)
+- `/clear <terminal>` - Clear current input line in specified terminal (Ctrl+C)
+- `/interrupt <terminal>` - Interrupt current command in specified terminal (Ctrl+C)
+
+### @ Terminal Messaging Syntax
+- `@terminal <command>` - Send command directly to named terminal
+- `@"Terminal Name" <command>` - Terminal with spaces in name
+- `@term1,term2,term3 <command>` - Multiple terminals (comma-separated)
+- `@term1 @term2 <command>` - Multiple terminals (space-separated)
+- `@all <command>` - Send to all terminals
+
+## Available Functions
+
+Key functions used:
+- `executeHelpCommand()` - Shows command help (renderer.js:711)
+- Displays all available commands from `availableCommands` array
+- Includes both slash commands and @ syntax examples
+
+## Command Categories
+
+**Terminal Management:**
+- `/create [name]` - Create new terminals
+- `/close <terminal>` - Remove terminals
+- `/list` - View active terminals
+
+**Command Execution:**
+- `/send <terminal> <command>` - Targeted execution
+- `/send-all <command>` - Broadcast execution
+- `@terminal <command>` - Direct messaging
+
+**Terminal Control:**
+- `/return <terminal>` - Submit current input
+- `/clear <terminal>` - Clear input line
+- `/interrupt <terminal>` - Send Ctrl+C
+
+**Information:**
+- `/help` - Command reference
+- `/list` - Terminal overview
+
+## Usage Tips
+
+**Terminal Identification:**
+- Use terminal names, position numbers, or partial matches
+- Quote names with spaces: `@"My Server"`
+- Case-insensitive matching supported
+
+**Multi-terminal Operations:**
+- Comma-separated: `@term1,term2,term3 pwd`
+- Space-separated: `@term1 @term2 @term3 pwd`
+- All terminals: `@all pwd` or `/send-all pwd`
+
+**Command Combinations:**
+- `/list` → see terminals → `/send Terminal1 ls`
+- `/create MyServer` → `@MyServer ssh user@server`
+
+Focus on helping the user understand the full command system and choose the right approach for their workflow.