gitarsenal-cli 1.9.65 → 1.9.67

package/kill_claude/tools/todo_write_tool.py

@@ -0,0 +1,114 @@
+"""
+TodoWrite Tool Definition
+
+Use this tool to create and manage a structured task list for your current coding session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
+It also helps the user understand the progress of the task and overall progress of their requests.
+
+When to Use This Tool
+Use this tool proactively in these scenarios:
+
+1. Complex multi-step tasks - When a task requires 3 or more distinct steps or actions
+2. Non-trivial and complex tasks - Tasks that require careful planning or multiple operations
+3. User explicitly requests todo list - When the user directly asks you to use the todo list
+4. User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)
+5. After receiving new instructions - Immediately capture user requirements as todos
+6. When you start working on a task - Mark it as in_progress BEFORE beginning work. Ideally you should only have one todo as in_progress at a time
+7. After completing a task - Mark it as completed and add any new follow-up tasks discovered during implementation
+
+When NOT to Use This Tool
+
+Skip using this tool when:
+1. There is only a single, straightforward task
+2. The task is trivial and tracking it provides no organizational benefit
+3. The task can be completed in less than 3 trivial steps
+4. The task is purely conversational or informational
+
+NOTE that you should not use this tool if there is only one trivial task to do. In this case you are better off just doing the task directly.
+
+Task States and Management
+
+1. Task States: Use these states to track progress:
+   - pending: Task not yet started
+   - in_progress: Currently working on (limit to ONE task at a time)
+   - completed: Task finished successfully
+
+2. Task Management:
+   - Update task status in real-time as you work
+   - Mark tasks complete IMMEDIATELY after finishing (don't batch completions)
+   - Only have ONE task in_progress at any time
+   - Complete current tasks before starting new ones
+   - Remove tasks that are no longer relevant from the list entirely
+
+3. Task Completion Requirements:
+   - ONLY mark a task as completed when you have FULLY accomplished it
+   - If you encounter errors, blockers, or cannot finish, keep the task as in_progress
+   - When blocked, create a new task describing what needs to be resolved
+   - Never mark a task as completed if:
+     - Tests are failing
+     - Implementation is partial
+     - You encountered unresolved errors
+     - You couldn't find necessary files or dependencies
+
+4. Task Breakdown:
+   - Create specific, actionable items
+   - Break complex tasks into smaller, manageable steps
+   - Use clear, descriptive task names
+
+When in doubt, use this tool. Being proactive with task management demonstrates attentiveness and ensures you complete all requirements successfully.
+"""
+
+from typing import List, Literal
+
+class TodoItem:
+    """Represents a single todo item."""
+    def __init__(self, content: str, status: Literal["pending", "in_progress", "completed"], id: str):
+        self.content = content
+        self.status = status
+        self.id = id
+
+class TodoWriteTool:
+    """Tool for creating and managing a structured task list."""
+    
+    name = "TodoWrite"
+    
+    @staticmethod
+    def schema():
+        return {
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "additionalProperties": False,
+            "properties": {
+                "todos": {
+                    "description": "The updated todo list",
+                    "items": {
+                        "additionalProperties": False,
+                        "properties": {
+                            "content": {
+                                "minLength": 1,
+                                "type": "string"
+                            },
+                            "id": {
+                                "type": "string"
+                            },
+                            "status": {
+                                "enum": ["pending", "in_progress", "completed"],
+                                "type": "string"
+                            }
+                        },
+                        "required": ["content", "status", "id"],
+                        "type": "object"
+                    },
+                    "type": "array"
+                }
+            },
+            "required": ["todos"],
+            "type": "object"
+        }
+    
+    def execute(self, todos: List[dict]):
+        """
+        Create and manage a structured task list.
+        
+        Args:
+            todos: The updated todo list, each item should contain content, status, and id
+        """
+        pass

package/kill_claude/tools/web_fetch_tool.py

@@ -0,0 +1,55 @@
+"""
+WebFetch Tool Definition
+
+- Fetches content from a specified URL and processes it using an AI model
+- Takes a URL and a prompt as input
+- Fetches the URL content, converts HTML to markdown
+- Processes the content with the prompt using a small, fast model
+- Returns the model's response about the content
+- Use this tool when you need to retrieve and analyze web content
+
+Usage notes:
+  - IMPORTANT: If an MCP-provided web fetch tool is available, prefer using that tool instead of this one, as it may have fewer restrictions. All MCP-provided tools start with "mcp__".
+  - The URL must be a fully-formed valid URL
+  - HTTP URLs will be automatically upgraded to HTTPS
+  - The prompt should describe what information you want to extract from the page
+  - This tool is read-only and does not modify any files
+  - Results may be summarized if the content is very large
+  - Includes a self-cleaning 15-minute cache for faster responses when repeatedly accessing the same URL
+  - When a URL redirects to a different host, the tool will inform you and provide the redirect URL in a special format. You should then make a new WebFetch request with the redirect URL to fetch the content.
+"""
+
+class WebFetchTool:
+    """Tool for fetching and analyzing web content."""
+    
+    name = "WebFetch"
+    
+    @staticmethod
+    def schema():
+        return {
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "additionalProperties": False,
+            "properties": {
+                "prompt": {
+                    "description": "The prompt to run on the fetched content",
+                    "type": "string"
+                },
+                "url": {
+                    "description": "The URL to fetch content from",
+                    "format": "uri",
+                    "type": "string"
+                }
+            },
+            "required": ["url", "prompt"],
+            "type": "object"
+        }
+    
+    def execute(self, url: str, prompt: str):
+        """
+        Fetch content from a URL and process it using an AI model.
+        
+        Args:
+            url: The URL to fetch content from
+            prompt: The prompt to run on the fetched content
+        """
+        pass

package/kill_claude/tools/web_search_tool.py

@@ -0,0 +1,58 @@
+"""
+WebSearch Tool Definition
+
+- Allows Claude to search the web and use the results to inform responses
+- Provides up-to-date information for current events and recent data
+- Returns search result information formatted as search result blocks
+- Use this tool for accessing information beyond Claude's knowledge cutoff
+- Searches are performed automatically within a single API call
+
+Usage notes:
+  - Domain filtering is supported to include or block specific websites
+  - Web search is only available in the US
+  - Account for "Today's date" in <env>. For example, if <env> says "Today's date: 2025-07-01", and the user wants the latest docs, do not use 2024 in the search query. Use 2025.
+"""
+
+from typing import List, Optional
+
+class WebSearchTool:
+    """Tool for searching the web and accessing up-to-date information."""
+    
+    name = "WebSearch"
+    
+    @staticmethod
+    def schema():
+        return {
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "additionalProperties": False,
+            "properties": {
+                "allowed_domains": {
+                    "description": "Only include search results from these domains",
+                    "items": {"type": "string"},
+                    "type": "array"
+                },
+                "blocked_domains": {
+                    "description": "Never include search results from these domains",
+                    "items": {"type": "string"},
+                    "type": "array"
+                },
+                "query": {
+                    "description": "The search query to use",
+                    "minLength": 2,
+                    "type": "string"
+                }
+            },
+            "required": ["query"],
+            "type": "object"
+        }
+    
+    def execute(self, query: str, allowed_domains: Optional[List[str]] = None, blocked_domains: Optional[List[str]] = None):
+        """
+        Search the web for information.
+        
+        Args:
+            query: The search query to use
+            allowed_domains: Only include search results from these domains
+            blocked_domains: Never include search results from these domains
+        """
+        pass

package/kill_claude/tools/write_tool.py

@@ -0,0 +1,46 @@
+"""
+Write Tool Definition
+
+Writes a file to the local filesystem.
+
+Usage:
+- This tool will overwrite the existing file if there is one at the provided path.
+- If this is an existing file, you MUST use the Read tool first to read the file's contents. This tool will fail if you did not read the file first.
+- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.
+- NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.
+- Only use emojis if the user explicitly requests it. Avoid writing emojis to files unless asked.
+"""
+
+class WriteTool:
+    """Tool for writing files to the local filesystem."""
+    
+    name = "Write"
+    
+    @staticmethod
+    def schema():
+        return {
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "additionalProperties": False,
+            "properties": {
+                "content": {
+                    "description": "The content to write to the file",
+                    "type": "string"
+                },
+                "file_path": {
+                    "description": "The absolute path to the file to write (must be absolute, not relative)",
+                    "type": "string"
+                }
+            },
+            "required": ["file_path", "content"],
+            "type": "object"
+        }
+    
+    def execute(self, file_path: str, content: str):
+        """
+        Write a file to the local filesystem.
+        
+        Args:
+            file_path: The absolute path to the file to write (must be absolute, not relative)
+            content: The content to write to the file
+        """
+        pass

package/lib/sandbox.js

@@ -30,6 +30,7 @@ function getPythonScriptPath() {
  * @param {Object} options - Container options
  * @param {string} options.repoUrl - GitHub repository URL
  * @param {string} options.gpuType - GPU type
+ * @param {number} options.gpuCount - Number of GPUs (default: 1)
  * @param {string} options.volumeName - Volume name
  * @param {Array<string>} options.setupCommands - Setup commands
  * @param {boolean} options.useApi - Whether to use the API to fetch setup commands
@@ -40,6 +41,7 @@ async function runContainer(options) {
   const { 
     repoUrl, 
     gpuType, 
+    gpuCount = 1,
     volumeName, 
     setupCommands = [], 
     useApi = true,
@@ -94,6 +96,7 @@ async function runContainer(options) {
   
   // Add normal arguments
   if (gpuType) args.push('--gpu', gpuType);
+  if (gpuCount && gpuCount > 1) args.push('--gpu-count', gpuCount.toString());
   if (repoUrl) args.push('--repo-url', repoUrl);
   
   if (volumeName) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitarsenal-cli",
-  "version": "1.9.65",
+  "version": "1.9.67",
   "description": "CLI tool for creating Modal sandboxes with GitHub repositories",
   "main": "index.js",
   "bin": {