✨ code exec

Author: FJRG2007

dymo-code.spec

@@ -12,6 +12,17 @@ block_cipher = None
 # Get the project root
 project_root = Path(SPECPATH)
 
+# Check for icon file and report status
+icon_path = project_root / 'docs' / 'images' / 'icon.ico'
+icon_exists = icon_path.exists()
+print(f"[BUILD INFO] Project root: {project_root}")
+print(f"[BUILD INFO] Icon path: {icon_path}")
+print(f"[BUILD INFO] Icon exists: {icon_exists}")
+if icon_exists:
+    print(f"[BUILD INFO] Icon size: {icon_path.stat().st_size} bytes")
+else:
+    print(f"[BUILD WARNING] Icon file not found! The executable will have no icon.")
+
 # Get certifi certificate path for SSL support
 try:
     import certifi
@@ -134,5 +145,5 @@ exe = EXE(
     target_arch=None,
     codesign_identity=None,
     entitlements_file=None,
-    icon=str(project_root / 'docs' / 'images' / 'icon.ico') if (project_root / 'docs' / 'images' / 'icon.ico').exists() else None,
+    icon=str(icon_path) if icon_exists else None,
 )

src/config.py

@@ -341,108 +341,98 @@ def items(self):
 # System Prompt
 # ═══════════════════════════════════════════════════════════════════════════════
 
-SYSTEM_PROMPT = """You are a helpful AI coding assistant running in a terminal environment. You are concise, precise, and focused on helping users with their tasks.
-
-## CRITICAL RULES
-
-### 1. TASK DIVISION - BREAK DOWN COMPLEX REQUESTS
-
-**IMPORTANT:** When you receive a complex request that involves multiple steps or creating a complete project, you MUST use the `spawn_agents` tool to divide the work into manageable tasks.
-
-**CRITICAL LIMITS:**
-- Maximum 5 tasks per spawn_agents call
-- If you need more than 5 tasks, work in BATCHES (call spawn_agents multiple times)
-- Group related items into single tasks (e.g., "Create 5 sorting algorithm files" instead of 5 separate tasks)
-
-**When to use `spawn_agents`:**
-- Initializing a complete project (Astro, React, Next.js, etc.)
-- Creating multiple files or components
-- Tasks with 3+ distinct steps
-- Building features that require setup, implementation, and configuration
-
-**How to divide tasks:**
-1. Analyze the request and identify logical subtasks
-2. Group similar items (e.g., all sorting algorithms = 1 task, all search algorithms = 1 task)
-3. Maximum 5 tasks per call - if more needed, execute in batches
-4. Use `sequential: true` when tasks depend on each other
-
-**Example - "Create an algorithm repository with 30 algorithms":**
-WRONG: 30 separate tasks (exceeds limit)
-CORRECT: Group by category into 5 or fewer tasks:
-- Task 1: "Create 8 sorting algorithm files (bubble, merge, quick, heap, insertion, selection, radix, shell)"
-- Task 2: "Create 7 search algorithm files (binary, linear, jump, interpolation, exponential, fibonacci, ternary)"
-- Task 3: "Create 8 graph algorithm files (dijkstra, BFS, DFS, bellman-ford, floyd-warshall, kruskal, prim, a-star)"
-- Task 4: "Create 7 data structure files (binary-trees, linked-lists, hash-tables, stacks-queues, avl-trees, red-black-trees, tries)"
-
-**Example - "Initialize an Astro project with a search feature":**
-- Task 1: "Initialize Astro project with TypeScript and install dependencies"
-- Task 2: "Create layout and base components"
-- Task 3: "Create search component with fuse.js"
-- Task 4: "Create example algorithm pages"
-- Task 5: "Configure routing and final setup"
-
-**Benefits:**
-- Prevents context exhaustion in a single prompt
-- Respects system limits (max 5 tasks)
-- Each task gets full attention
-- Easier to track progress and debug
-
-### 2. COMPLETE THE USER'S REQUEST - NO MORE, NO LESS
-
-Do exactly what the user asks:
-- If user says "create a file" → Create the file with `create_file`. Done.
-- If user says "create a folder and a file" → Create both. Done.
-- If user says "create and run" → Create the file AND run it.
-
-**DO NOT automatically run code after creating it** unless the user specifically asks to run it.
-
-### 3. USE TOOLS, DON'T SHOW CODE
-
-When asked to CREATE a file:
-- Use `create_file` tool - don't just display code as text
-- The diff display will show the user what was created
-
-### 4. YOUR AVAILABLE TOOLS
-
-| Tool Name | When to Use |
-|-----------|-------------|
-| `list_files_in_dir` | List files/folders in a directory |
-| `read_file` | Read content of a file |
-| `create_folder` | Create a new directory |
-| `create_file` | Create or write a file |
-| `move_path` | Move or rename a file/folder |
-| `delete_path` | Delete a file/folder (asks for confirmation) |
-| `run_command` | Execute a system command |
-| `spawn_agents` | Divide complex tasks into subtasks |
-
-**Use these exact names. No prefixes like "repo_browser." etc.**
-
-### 5. WHEN TO RUN CODE
-
-**RUN code ONLY when:**
-- User explicitly says "run", "execute", "test", or "try"
-- User asks to see output/results
-
-**DO NOT automatically run code when:**
-- User just says "create a file"
-- User says "make a script"
-- User says "write code for X"
-
-### 6. CODE QUALITY
-
-When writing code:
-- Write complete, working code
-- Follow language best practices
-- Python: Don't put newlines inside f-strings
-
-### 7. RESPONDING TO REQUESTS
-
-Keep responses brief after tool use:
-- "Created `filename.py`" - done
-- Don't repeat the entire file content
-- Don't explain every line unless asked
-
-## Environment
+SYSTEM_PROMPT = """You are an expert AI coding assistant with direct access to the user's system through tools. Your primary mode of operation is ACTION, not description.
+
+## CORE PRINCIPLES
+
+### 1. ACT, DON'T JUST DESCRIBE
+- When asked to do something → USE TOOLS to do it
+- Don't explain what you "would do" → DO IT
+- Don't show code in chat → CREATE files with tools
+- The user can see results through tool outputs
+
+### 2. SOLVE PROBLEMS COMPLETELY
+When given a task:
+1. **Understand** - Read relevant files if needed
+2. **Plan** - Break down into steps (use spawn_agents for complex tasks)
+3. **Execute** - Use tools to implement the solution
+4. **Verify** - Run/test to confirm it works
+5. **Iterate** - If something fails, FIX IT and try again
+
+**NEVER give up after one failure.** Debug, fix, and retry.
+
+### 3. VERIFY YOUR WORK
+After making changes:
+- Run the code to check for errors
+- Read the file to confirm changes were applied
+- Test the functionality if possible
+- If something breaks, investigate and fix it
+
+### 4. ITERATE UNTIL SUCCESS
+- Error in code? → Read the error, fix it, run again
+- File not created? → Check the path, try again
+- Test failed? → Debug, modify, retest
+- Keep iterating until the task is COMPLETE
+
+## TOOLS AVAILABLE
+
+| Tool | Purpose |
+|------|---------|
+| `list_files_in_dir` | Explore directory structure |
+| `read_file` | Read file contents |
+| `create_folder` | Create directories |
+| `create_file` | Create or modify files |
+| `move_path` | Rename or move files |
+| `delete_path` | Remove files (with confirmation) |
+| `run_command` | Execute shell commands (output streams in real-time) |
+| `spawn_agents` | Divide complex tasks (max 5 subtasks) |
+| `glob_search` | Find files by pattern |
+| `grep_search` | Search file contents |
+| `web_search` | Search the internet |
+| `fetch_url` | Get web page content |
+
+## TASK DIVISION (spawn_agents)
+
+For complex tasks with 3+ steps:
+- Use `spawn_agents` to parallelize work
+- Maximum 5 tasks per call (batch if needed)
+- Group related items (e.g., "Create all sorting algorithms")
+- Use `sequential: true` for dependent tasks
+
+**Example - "Create an algorithm repository":**
+- Task 1: "Create sorting algorithm files (bubble, merge, quick, heap)"
+- Task 2: "Create search algorithm files (binary, linear, jump)"
+- Task 3: "Create graph algorithm files (dijkstra, BFS, DFS)"
+
+## RESPONSE STYLE
+
+- **Brief after actions**: "Created `file.py`" - done
+- **Don't repeat file contents** unless asked
+- **Don't over-explain** - the user sees tool results
+- **Be direct**: Do what's asked, no more, no less
+
+## ERROR HANDLING
+
+When something fails:
+1. Read the error message carefully
+2. Identify the root cause
+3. Fix the issue
+4. Run again to verify
+5. Repeat until resolved
+
+**Example workflow:**
+```
+User: "Create a Python script that fetches weather data and run it"
+
+Your approach:
+1. create_file → weather.py with API code
+2. run_command → python weather.py
+3. If error → read error, fix code, run again
+4. If missing module → run_command pip install X, then retry
+5. Continue until it works or you've exhausted options
+```
+
+## ENVIRONMENT
 - OS: {os_info}
 - Working Directory: {cwd}
 """

src/tools.py

@@ -211,9 +211,10 @@ def create_file(file_path: str = "", content: str = "") -> str:
         return f"Error: {str(e)}"
 
 
-def run_command(command: str = "") -> str:
-    """Execute a shell command and return output"""
-    if not command: return "Error: command is required"
+def run_command(command: str = "", timeout: int = 300) -> str:
+    """Execute a shell command with real-time output streaming"""
+    if not command:
+        return "Error: command is required"
 
     # Check command permissions before executing
     try:
@@ -223,22 +224,55 @@ def run_command(command: str = "") -> str:
     except ImportError:
         pass  # If module not available, allow execution
 
+    from .ui import StreamingConsole
+
+    # Truncate command for title display
+    display_cmd = command[:60] + "..." if len(command) > 60 else command
+
+    console_display = StreamingConsole(title=display_cmd)
+    console_display.start()
+
+    output_lines = []
+    exit_code = 0
+
     try:
-        result = subprocess.run(
+        # Use Popen for streaming output
+        process = subprocess.Popen(
             command,
             shell=True,
-            capture_output=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,  # Merge stderr into stdout for proper ordering
             text=True,
-            timeout=30,
-            cwd=os.getcwd()
+            bufsize=1,  # Line buffered
+            cwd=os.getcwd(),
+            env={**os.environ, 'PYTHONUNBUFFERED': '1'}  # Force unbuffered Python
         )
-        output = ""
-        if result.stdout: output += result.stdout
-        if result.stderr: output += f"\n[stderr]\n{result.stderr}" if output else result.stderr
-        if result.returncode != 0: output += f"\n[exit code: {result.returncode}]"
-        return output.strip() if output.strip() else "(No output)"
-    except subprocess.TimeoutExpired: return "Error: Command timed out after 30 seconds."
-    except Exception as e: return f"Error: {str(e)}"
+
+        # Read output line by line as it's produced
+        for line in iter(process.stdout.readline, ''):
+            if line:
+                output_lines.append(line)
+                console_display.append(line)
+
+        process.wait(timeout=timeout)
+        exit_code = process.returncode
+
+    except subprocess.TimeoutExpired:
+        process.kill()
+        console_display.append("[Command timed out!]")
+        exit_code = -1
+    except Exception as e:
+        console_display.append(f"[Error: {str(e)}]")
+        exit_code = -1
+
+    console_display.finish(exit_code)
+
+    # Return complete output for tool result
+    result = ''.join(output_lines)
+    if exit_code != 0:
+        result += f"\n[exit code: {exit_code}]"
+
+    return result.strip() if result.strip() else "(No output)"
 
 
 def move_path(source: str = "", destination: str = "") -> str:

src/ui.py

@@ -1048,4 +1048,71 @@ def print_keybindings():
         console.print(table)
         console.print()
 
-    except ImportError: console.print(f"\n[{COLORS['error']}]Keybinding system not available.[/]\n")
+    except ImportError: console.print(f"\n[{COLORS['error']}]Keybinding system not available.[/]\n")
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# Streaming Console for Real-Time Command Output
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class StreamingConsole:
+    """Live updating console panel for command output with ANSI color support"""
+
+    def __init__(self, title: str = "Console", max_lines: int = 100):
+        self.title = title
+        self.lines = []
+        self.live = None
+        self.max_lines = max_lines
+        self.exit_code = None
+
+    def start(self):
+        """Start the live display"""
+        from rich.live import Live
+        self.live = Live(
+            self._render(),
+            console=console,
+            refresh_per_second=15,
+            transient=True  # Will be replaced by final static panel
+        )
+        self.live.start()
+
+    def append(self, line: str):
+        """Append a line of output"""
+        self.lines.append(line.rstrip('\n\r'))
+        # Keep last N lines for scrollback
+        if len(self.lines) > self.max_lines:
+            self.lines = self.lines[-self.max_lines:]
+        if self.live:
+            self.live.update(self._render())
+
+    def _render(self):
+        """Render the panel with current output"""
+        # Use Text.from_ansi to preserve colors from command output
+        if self.lines:
+            content = '\n'.join(self.lines)
+            text = Text.from_ansi(content)
+        else:
+            text = Text("Waiting for output...", style=f"dim {COLORS['muted']}")
+
+        # Title with exit code if finished
+        title = f"[bold cyan]$ {self.title}[/bold cyan]"
+        if self.exit_code is not None:
+            code_style = COLORS['success'] if self.exit_code == 0 else COLORS['error']
+            title += f" [{code_style}](exit: {self.exit_code})[/{code_style}]"
+
+        return Panel(
+            text,
+            title=title,
+            title_align="left",
+            border_style=COLORS['muted'],
+            box=ROUNDED,
+            padding=(0, 1)
+        )
+
+    def finish(self, exit_code: int):
+        """Finish streaming and show final static panel"""
+        self.exit_code = exit_code
+        if self.live:
+            self.live.stop()
+        # Print final static panel that persists
+        console.print(self._render())

static-api/version.json

@@ -1,3 +1,3 @@
 {
-    "version": "0.0.0.24"
+    "version": "0.0.0.25"
 }