gitarsenal-cli 1.9.65 → 1.9.67

package/.venv_status.json

@@ -1 +1 @@
-{"created":"2025-08-14T08:39:09.974Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}
+{"created":"2025-08-14T20:59:50.666Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}

package/bin/gitarsenal.js

@@ -695,6 +695,7 @@ keysCmd
 program
   .option('-r, --repo <url>', 'GitHub repository URL')
   .option('-g, --gpu <type>', 'GPU type (A10G, A100, H100, T4, L4, L40S, V100)')
+  .option('-c, --gpu-count <number>', 'Number of GPUs to use (1-8)', '1')
   .option('-v, --volume <n>', 'Name of persistent volume')
   .option('-y, --yes', 'Skip confirmation prompts')
   .option('-m, --manual', 'Disable automatic setup command detection')
@@ -743,6 +744,7 @@ async function runContainerCommand(options) {
     // If repo URL not provided, prompt for it
     let repoUrl = options.repoUrl || options.repo;
     let gpuType = options.gpu;
+    let gpuCount = parseInt(options.gpuCount) || 1;
     let volumeName = options.volumeName || options.volume;
     let skipConfirmation = options.yes;
     let useApi = !options.manual;
@@ -830,6 +832,27 @@ async function runContainerCommand(options) {
       gpuType = gpuAnswers.gpuType;
     }
 
+    // Prompt for GPU count if not already specified via CLI
+    if (!options.gpuCount || gpuCount === 1) {
+      const gpuCountAnswers = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'gpuCount',
+          message: 'How many GPUs do you need?',
+          choices: [
+            { name: '1 GPU', value: 1 },
+            { name: '2 GPUs', value: 2 },
+            { name: '3 GPUs', value: 3 },
+            { name: '4 GPUs', value: 4 },
+            { name: '6 GPUs', value: 6 },
+            { name: '8 GPUs', value: 8 }
+          ],
+          default: gpuCount
+        }
+      ]);
+      gpuCount = gpuCountAnswers.gpuCount;
+    }
+
     // Prompt for persistent volume
     if (!volumeName && !skipConfirmation) {
       const volumeAnswers = await inquirer.prompt([
@@ -927,6 +950,7 @@ async function runContainerCommand(options) {
       await runContainer({
         repoUrl,
         gpuType,
+        gpuCount,
         volumeName,
         setupCommands,
         useApi,

package/kill_claude/.claude/settings.local.json

@@ -0,0 +1,9 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(python test:*)",
+      "Bash(python:*)"
+    ],
+    "defaultMode": "acceptEdits"
+  }
+}

package/kill_claude/README.md

@@ -0,0 +1,265 @@
+# Claude Code Agent
+
+A comprehensive Python implementation that replicates Claude Code's functionality by orchestrating all available tools to handle user queries intelligently.
+
+## 🎯 Overview
+
+This project contains:
+- **All 16 Claude Code tool definitions** as individual Python modules
+- **Main orchestrator** (`claude_code_agent.py`) that handles user queries
+- **Query parsing and intent recognition** system
+- **Task management** with automatic todo list creation
+- **Interactive CLI mode** similar to Claude Code's interface
+
+## 📁 Project Structure
+
+```
+kill_claude/
+├── claude_code_agent.py          # Main orchestrator file
+├── example_usage.py               # Usage examples and demos
+├── README.md                      # This file
+├── 
+├── Tool Definitions:
+├── task_tool.py                   # Task/Agent management
+├── bash_tool.py                   # Command execution
+├── glob_tool.py                   # File pattern matching
+├── grep_tool.py                   # Content search
+├── ls_tool.py                     # Directory listing
+├── read_tool.py                   # File reading
+├── edit_tool.py                   # File editing
+├── multiedit_tool.py              # Multiple file edits
+├── write_tool.py                  # File writing
+├── notebook_edit_tool.py          # Jupyter notebook editing
+├── web_fetch_tool.py              # Web content fetching
+├── web_search_tool.py             # Web searching
+├── todo_write_tool.py             # Task management
+├── bash_output_tool.py            # Background shell output
+├── kill_bash_tool.py              # Shell termination
+├── exit_plan_mode_tool.py         # Plan mode management
+└──
+└── Documentation (from Claude Code):
+    ├── claude-code-*.md            # Claude Code internal docs
+    └── ...
+```
+
+## 🚀 Features
+
+### Core Capabilities
+- **File Operations**: Read, write, edit, list files and directories
+- **Search**: Content search in files, web search, pattern matching
+- **Code Execution**: Run bash commands, package managers, git operations
+- **Web Access**: Fetch web content, search the internet
+- **Task Management**: Automatic todo list creation for complex tasks
+- **Planning**: Support for multi-step task planning and execution
+
+### Intelligent Query Processing
+- **Intent Recognition**: Automatically detects what the user wants to do
+- **Tool Selection**: Chooses appropriate tools based on query analysis
+- **Parameter Extraction**: Extracts relevant parameters from natural language
+- **Context Awareness**: Maintains conversation context and task state
+
+### Interactive Features
+- **CLI Mode**: Interactive command-line interface
+- **Help System**: Built-in help and tool documentation
+- **Error Handling**: Graceful error handling and user feedback
+- **Task Tracking**: Visual task management with status updates
+
+## 🛠️ Installation
+
+1. **Clone or download** all the files to a directory
+2. **Install dependencies** (if needed):
+   ```bash
+   pip install dataclasses  # Python 3.6 only, built-in for 3.7+
+   ```
+3. **Make the main script executable**:
+   ```bash
+   chmod +x claude_code_agent.py
+   ```
+
+## 💻 Usage
+
+### Interactive Mode
+Launch the interactive CLI:
+```bash
+python claude_code_agent.py
+```
+
+Example interaction:
+```
+🤖 Claude Code Agent - Interactive Mode
+Type 'help' for available commands, 'exit' to quit
+--------------------------------------------------
+
+👤 You: read main.py
+🤖 Claude Code Agent:
+Processing query: read main.py
+Detected intent: file_operation (confidence: 0.80)
+Suggested tools: Read
+
+Reading file: main.py
+[file contents...]
+
+👤 You: implement user authentication system
+🤖 Claude Code Agent:
+Processing query: implement user authentication system  
+Detected intent: complex_task (confidence: 0.90)
+Suggested tools: TodoWrite, Task
+
+Complex task identified. I've created a todo list to track progress...
+```
+
+### Single Query Mode
+Process a single query from command line:
+```bash
+python claude_code_agent.py "search for TODO comments"
+python claude_code_agent.py "run pytest tests/"
+python claude_code_agent.py "list all Python files"
+```
+
+### Example Usage
+Run the examples to see all capabilities:
+```bash
+python example_usage.py
+```
+
+## 📋 Supported Query Types
+
+### File Operations
+- `"read main.py"` - Read file contents
+- `"list files"` - List directory contents  
+- `"find *.py"` - Find files matching patterns
+- `"edit config.json"` - Edit file contents
+
+### Search Operations
+- `"search for TODO comments"` - Search in file contents
+- `"find functions named login"` - Search for specific patterns
+- `"web search Python best practices"` - Search the web
+
+### Code Execution  
+- `"run pytest"` - Execute commands
+- `"git status"` - Git operations
+- `"npm install express"` - Package management
+
+### Web Access
+- `"fetch https://api.github.com"` - Fetch web content
+- `"search web for AI news"` - Web search
+
+### Complex Tasks
+- `"implement REST API"` - Multi-step development tasks
+- `"build chat application"` - Complex project creation
+- `"setup CI/CD pipeline"` - Infrastructure tasks
+
+## 🧠 How It Works
+
+### 1. Query Parsing
+The agent analyzes user input using:
+- **Pattern matching** against common command structures
+- **Keyword detection** for intent classification
+- **Parameter extraction** from natural language
+- **Confidence scoring** for tool selection
+
+### 2. Intent Recognition
+Classifies queries into categories:
+- `FILE_OPERATION` - File and directory operations
+- `SEARCH` - Content and web searching
+- `CODE_EXECUTION` - Running commands and scripts
+- `WEB_ACCESS` - Web content and APIs
+- `COMPLEX_TASK` - Multi-step development tasks
+- `TASK_MANAGEMENT` - Todo and planning operations
+
+### 3. Tool Orchestration
+- **Automatic tool selection** based on intent and patterns
+- **Parameter mapping** from parsed query to tool arguments
+- **Sequential execution** for multi-step operations
+- **Error handling** with user-friendly messages
+
+### 4. Task Management
+For complex queries, automatically:
+- **Creates todo lists** to track progress
+- **Breaks down tasks** into manageable steps
+- **Updates status** as work progresses
+- **Manages context** across tool executions
+
+## 🎨 Customization
+
+### Adding New Tools
+1. Create a new tool file following the existing pattern:
+```python
+class MyNewTool:
+    name = "MyNewTool"
+    
+    @staticmethod
+    def schema():
+        return { /* JSON schema */ }
+    
+    def execute(self, **kwargs):
+        # Tool implementation
+        pass
+```
+
+2. Import and register in `claude_code_agent.py`:
+```python
+from my_new_tool import MyNewTool
+
+# In ClaudeCodeAgent.__init__:
+self.tools['MyNewTool'] = MyNewTool()
+```
+
+### Adding Query Patterns
+Add new patterns to `tool_patterns` in `ClaudeCodeAgent`:
+```python
+self.tool_patterns = {
+    r'\b(my|custom)\s+pattern\b': 'MyNewTool',
+    # ... existing patterns
+}
+```
+
+### Customizing Intent Recognition
+Modify the `parse_query` method to add new intents or improve classification logic.
+
+## 🔧 Technical Details
+
+### Architecture
+- **Modular design** with separate tool definitions
+- **Plugin-style architecture** for easy tool addition
+- **State management** for conversation context
+- **Event-driven execution** based on query parsing
+
+### Error Handling
+- **Graceful degradation** when tools fail
+- **User-friendly error messages**
+- **Logging and debugging** support
+- **Recovery mechanisms** for common issues
+
+### Performance
+- **Lazy loading** of tool resources
+- **Caching** for repeated operations
+- **Parallel execution** where possible
+- **Memory-efficient** query processing
+
+## 📖 Examples
+
+See `example_usage.py` for comprehensive examples of:
+- File operations workflow
+- Development task management
+- Debugging procedures  
+- Research and learning workflows
+- Interactive feature demonstrations
+
+## 🤝 Contributing
+
+This project replicates Claude Code's functionality for educational and research purposes. To contribute:
+
+1. **Add new tools** following the existing patterns
+2. **Improve query parsing** with better pattern recognition
+3. **Enhance error handling** for edge cases
+4. **Add more examples** and use cases
+5. **Optimize performance** for large codebases
+
+## 📄 License
+
+This project is for educational purposes and demonstrates how Claude Code's functionality can be replicated using Python. Please respect Claude Code's actual terms of service when using this educational implementation.
+
+---
+
+**Built with ❤️ to understand and replicate Claude Code's powerful agent capabilities**