v0.2.2: UI improvements, interactive command handling, tool calling configuration

- Enhanced chat interface with styled user/assistant messages
- EOF-based input handling for interactive commands to prevent hangs
- Custom HTTP headers with tool name and repository link
- New tool_calling_type config parameter for model-specific tool calling
- Updated README with version badges and What's New section

Author: Vadim Mitroshkin

README.md

@@ -1,9 +1,22 @@
 # 🤖 SuperCoder
 
+[![Version](https://img.shields.io/badge/version-0.2.2-blue.svg)](https://github.com/Mage212/supercoder)
+[![Python](https://img.shields.io/badge/python-3.11+-green.svg)](https://python.org)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
 **AI Coding Assistant for the Terminal** — A powerful, extensible, and terminal-native coding agent designed to help you build, search, and fix code with natural language.
 
 ---
 
+## 🆕 What's New in v0.2.2
+
+- **Improved UI**: Enhanced chat interface with styled user/assistant messages and better visual feedback
+- **Interactive Command Execution**: EOF-based input handling to prevent command hangs
+- **Custom Headers**: Tool name and repository link now passed in HTTP headers for better API compatibility
+- **Tool Calling Configuration**: New `tool_calling_type` parameter in config to specify model-specific tool calling instructions (supports `supercoder`, `qwen_like`, `json_block`, `xml_function`)
+
+---
+
 ## ✨ Core Features
 
 ### 🔍 Code Search

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "supercoder"
-version = "0.2.0"
+version = "0.2.2"
 description = "AI Coding Assistant for the Terminal"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -9,7 +9,6 @@ authors = [
     {name = "SuperCoder Team"}
 ]
 keywords = ["ai", "coding", "assistant", "llm", "cli"]
-
 dependencies = [
     "openai>=2.13.0",
     "click>=8.3.1",
@@ -22,6 +21,11 @@ dependencies = [
     "tiktoken>=0.12.0",
 ]
 
+[project.urls]
+Homepage = "https://github.com/Mage212/supercoder"
+Repository = "https://github.com/Mage212/supercoder"
+Issues = "https://github.com/Mage212/supercoder/issues"
+
 [project.optional-dependencies]
 dev = [
     "pytest>=7.0.0",

requirements.txt

@@ -9,6 +9,7 @@ prompt-toolkit>=3.0.52
 tiktoken>=0.12.0
 pyyaml>=6.0.0
 pygments>=2.17.0
+questionary>=2.0.0
 
 # RepoMap
 tree-sitter-languages>=1.10.2

supercoder/__init__.py

@@ -1,3 +1,3 @@
 """SuperCoder - AI Coding Assistant for the Terminal."""
 
-__version__ = "0.2.0"
+__version__ = "0.2.2"

supercoder/agent/coder_agent.py

@@ -28,7 +28,8 @@ def __init__(
         tools: list[BaseTool] | None = None,
         context_config: ContextConfig | None = None,
         use_repo_map: bool = False,
-        repo_root: str = "."
+        repo_root: str = ".",
+        tool_calling_type: str = "supercoder"
     ):
         self.llm = llm
         self.tools = {t.definition.name: t for t in (tools or [])}
@@ -43,8 +44,17 @@ def __init__(
         self.rules_loader.ensure_rules_dir()  # Create .supercoder/rules/ if missing
         project_rules = self.rules_loader.get_rules_for_prompt()
 
+        # Store tool calling type for prompt generation
+        self.tool_calling_type = tool_calling_type
+        self._tools_list = tools or []  # Keep reference for prompt rebuilding
+        self._project_rules = project_rules
+        
         # Build system prompt template with tools and project rules
-        self.base_system_prompt = build_system_prompt(tools or [], rules=project_rules)
+        self.base_system_prompt = build_system_prompt(
+            self._tools_list, 
+            rules=project_rules, 
+            tool_calling_type=self.tool_calling_type
+        )
 
         # Setup context management
         config = context_config or ContextConfig()
@@ -77,6 +87,20 @@ def _update_system_prompt(self):
         # Log the updated system prompt
         get_logger().log_system_prompt(prompt)
 
+    def set_tool_calling_type(self, tool_calling_type: str) -> None:
+        """Update tool calling type and rebuild system prompt.
+        
+        Call this when switching to a model with a different tool_calling_type.
+        """
+        if tool_calling_type != self.tool_calling_type:
+            self.tool_calling_type = tool_calling_type
+            self.base_system_prompt = build_system_prompt(
+                self._tools_list,
+                rules=self._project_rules,
+                tool_calling_type=self.tool_calling_type
+            )
+            self._update_system_prompt()
+
     def chat_stream(self, user_message: str):
         """Process user message and yield response chunks.
         
@@ -142,7 +166,49 @@ def chat_stream(self, user_message: str):
                     continue
 
                 try:
-                    result = self.tools[name].execute(args)
+                    tool = self.tools[name]
+                    
+                    # Use streaming for command-exec to handle interactive commands
+                    if name == "command-exec" and hasattr(tool, 'execute_streaming'):
+                        result = ""
+                        process_to_kill = None
+                        
+                        for event in tool.execute_streaming(args):
+                            if event["type"] == "waiting_input":
+                                # Yield to REPL for user decision - REPL will kill the process if needed
+                                process_to_kill = event.get("process")
+                                yield {
+                                    "type": "command_waiting",
+                                    "content": event["content"],
+                                    "process": process_to_kill,
+                                    "tool_name": name
+                                }
+                                # After REPL handles it, the process is either killed or we continue
+                                # Check if process was killed
+                                if process_to_kill and process_to_kill.poll() is not None:
+                                    # Process was killed by REPL - tell model NOT to retry
+                                    partial_output = ''.join(event.get('stdout', []))
+                                    result = (
+                                        f"⚠️ INTERACTIVE PROCESS KILLED BY USER\n"
+                                        f"The command requires user input which cannot be provided in this environment.\n"
+                                        f"DO NOT attempt to run this command again.\n\n"
+                                        f"Partial output before kill:\n{partial_output}"
+                                    )
+                                    break
+                                # Otherwise continue waiting until timeout
+                            elif event["type"] == "output":
+                                # Incremental output - could stream to console
+                                pass
+                            elif event["type"] == "done":
+                                result = event["content"]
+                            elif event["type"] == "stalled":
+                                result = f"{event['content']}\n\n(waiting for command to complete...)"
+                            elif event["type"] == "error":
+                                result = event["content"]
+                    else:
+                        result = tool.execute(args)
+
+                    
                     yield {"type": "tool_result", "content": {"name": name, "result": result}}
                     # Log tool call and result
                     get_logger().log_tool_call(name, args)
@@ -162,6 +228,7 @@ def chat_stream(self, user_message: str):
             # Let agent continue with tool results (recursive call handling)
             yield from self.chat_stream("")
 
+
     def _extract_tool_call(self, text: str) -> dict | None:
         """Extract tool call from response text using multi-format parser."""
         result = self.tool_parser.parse(text)

supercoder/agent/prompts.py

@@ -1,10 +1,12 @@
 """System prompts for the agent."""
 
+from .tool_calling_prompts import get_tool_calling_prompt
+
 # Compact prompt optimized for local/smaller models
+# Tool calling instructions are injected dynamically based on model's tool_calling_type
 SYSTEM_PROMPT = """You are a coding assistant.
 
-# Tool Calling
-Call tools with <@TOOL>{{"name": "<tool-name>", "arguments": "<json-args>"}}</@TOOL>
+{tool_calling_instructions}
 
 Available tools:
 {tools}
@@ -45,12 +47,18 @@
 """
 
 
-def build_system_prompt(tools: list, rules: str = "") -> str:
+def build_system_prompt(
+    tools: list, 
+    rules: str = "", 
+    tool_calling_type: str = "supercoder"
+) -> str:
     """Build system prompt with available tools and project rules.
     
     Args:
         tools: List of available tools.
         rules: Optional project-specific rules to include.
+        tool_calling_type: Type of tool calling format to use in instructions.
+                          Valid: supercoder, qwen_like, json_block, xml_function
     """
     if not tools:
         tool_list = "(no tools available yet)"
@@ -60,11 +68,16 @@ def build_system_prompt(tools: list, rules: str = "") -> str:
             for t in tools
         )
 
-    prompt = SYSTEM_PROMPT.format(tools=tool_list)
+    # Get tool calling instructions for this model type
+    tool_calling_instructions = get_tool_calling_prompt(tool_calling_type)
+    
+    prompt = SYSTEM_PROMPT.format(
+        tools=tool_list,
+        tool_calling_instructions=tool_calling_instructions
+    )
 
     # Add project rules if provided
     if rules:
         prompt += f"\n{rules}"
 
     return prompt
-

supercoder/agent/tool_calling_prompts.py

@@ -0,0 +1,109 @@
+"""Tool calling prompt templates for different model types.
+
+Each model may expect tools to be called in a specific format.
+This module provides format-specific instructions that are injected
+into the system prompt based on the model's `tool_calling_type`.
+"""
+
+# Tool calling instruction templates for each supported type
+TOOL_CALLING_PROMPTS = {
+    # Our native format - most explicit and clear
+    "supercoder": """# Tool Calling
+Call tools with <@TOOL>{"name": "<tool-name>", "arguments": <json-args>}</@TOOL>
+
+**Example:**
+<@TOOL>{"name": "file-read", "arguments": {"path": "main.py"}}</@TOOL>
+
+**Multiple tool calls:**
+You can call multiple tools in one response:
+<@TOOL>{"name": "file-read", "arguments": {"path": "file1.py"}}</@TOOL>
+<@TOOL>{"name": "file-read", "arguments": {"path": "file2.py"}}</@TOOL>
+""",
+
+    # Qwen-style format used by gpt-oss, deepresearch, and similar models
+    "qwen_like": """# Tool Calling
+Call tools using this format:
+to=tool:<tool-name> <json-arguments>
+
+**Example:**
+to=tool:file-read {"path": "main.py"}
+
+**Available argument formats:**
+to=tool:code-edit {"file": "app.py", "operation": "create", "content": "print('hello')"}
+to=tool:command-exec {"command": "ls -la", "timeout": 30}
+to=tool:code-search {"query": "def main", "path": "."}
+to=tool:project-structure {"path": "."}
+
+**Important:** Always use valid JSON for arguments. Use double quotes for strings.
+""",
+
+    # JSON code block format - common with many instruction-tuned models
+    "json_block": """# Tool Calling
+Call tools using JSON code blocks:
+
+```json
+{"tool": "<tool-name>", "arguments": {"arg1": "value1", "arg2": "value2"}}
+```
+
+**Example:**
+```json
+{"tool": "file-read", "arguments": {"path": "main.py"}}
+```
+
+**For code-edit:**
+```json
+{"tool": "code-edit", "arguments": {"file": "app.py", "operation": "create", "content": "print('hello')"}}
+```
+
+**Important:** Use proper JSON formatting with double quotes.
+""",
+
+    # XML function call format
+    "xml_function": """# Tool Calling
+Call tools using XML syntax:
+
+<function_call name="<tool-name>">
+{"arg1": "value1", "arg2": "value2"}
+</function_call>
+
+**Example:**
+<function_call name="file-read">
+{"path": "main.py"}
+</function_call>
+
+**For code-edit:**
+<function_call name="code-edit">
+{"file": "app.py", "operation": "create", "content": "print('hello')"}
+</function_call>
+""",
+
+    # OpenAI-compatible function calling (for reference, though most use native)
+    "openai_native": """# Tool Calling
+You have access to tools. When you need to use a tool, respond with a function call.
+The system will execute the tool and provide results.
+
+Call tools by specifying the tool name and arguments in JSON format.
+""",
+}
+
+# Valid tool calling types for validation
+VALID_TOOL_CALLING_TYPES = set(TOOL_CALLING_PROMPTS.keys())
+
+
+def get_tool_calling_prompt(tool_calling_type: str) -> str:
+    """Get tool calling instructions for the specified type.
+    
+    Args:
+        tool_calling_type: The type of tool calling format to use.
+                          Valid values: supercoder, qwen_like, json_block, xml_function
+    
+    Returns:
+        String containing tool calling instructions for the system prompt.
+        Falls back to 'supercoder' format if type is unknown.
+    """
+    return TOOL_CALLING_PROMPTS.get(tool_calling_type, TOOL_CALLING_PROMPTS["supercoder"])
+
+
+def get_available_types() -> list[str]:
+    """Get list of available tool calling types."""
+    return list(TOOL_CALLING_PROMPTS.keys())