code-puppy 0.0.83__py3-none-any.whl → 0.0.85__py3-none-any.whl

code_puppy/tools/command_runner.py

@@ -1,14 +1,117 @@
+import os
+import signal
 import subprocess
+import threading
 import time
-from typing import Any, Dict
+import traceback
+import sys
+from typing import Set
 
 from pydantic import BaseModel
 from pydantic_ai import RunContext
 from rich.markdown import Markdown
-from rich.syntax import Syntax
+from rich.text import Text
 
 from code_puppy.tools.common import console
 
+_AWAITING_USER_INPUT = False
+
+_CONFIRMATION_LOCK = threading.Lock()
+
+# Track running shell processes so we can kill them on Ctrl-C from the UI
+_RUNNING_PROCESSES: Set[subprocess.Popen] = set()
+_RUNNING_PROCESSES_LOCK = threading.Lock()
+_USER_KILLED_PROCESSES = set()
+
+def _register_process(proc: subprocess.Popen) -> None:
+    with _RUNNING_PROCESSES_LOCK:
+        _RUNNING_PROCESSES.add(proc)
+
+
+def _unregister_process(proc: subprocess.Popen) -> None:
+    with _RUNNING_PROCESSES_LOCK:
+        _RUNNING_PROCESSES.discard(proc)
+
+
+def _kill_process_group(proc: subprocess.Popen) -> None:
+    """Attempt to aggressively terminate a process and its group.
+
+    Cross-platform best-effort. On POSIX, uses process groups. On Windows, tries CTRL_BREAK_EVENT, then terminate().
+    """
+    try:
+        if sys.platform.startswith("win"):
+            try:
+                # Try a soft break first if the group exists
+                proc.send_signal(signal.CTRL_BREAK_EVENT)  # type: ignore[attr-defined]
+                time.sleep(0.8)
+            except Exception:
+                pass
+            if proc.poll() is None:
+                try:
+                    proc.terminate()
+                    time.sleep(0.8)
+                except Exception:
+                    pass
+            if proc.poll() is None:
+                try:
+                    proc.kill()
+                except Exception:
+                    pass
+            return
+
+        # POSIX
+        pid = proc.pid
+        try:
+            pgid = os.getpgid(pid)
+            os.killpg(pgid, signal.SIGTERM)
+            time.sleep(1.0)
+            if proc.poll() is None:
+                os.killpg(pgid, signal.SIGINT)
+                time.sleep(0.6)
+            if proc.poll() is None:
+                os.killpg(pgid, signal.SIGKILL)
+                time.sleep(0.5)
+        except (OSError, ProcessLookupError):
+            # Fall back to direct kill of the process
+            try:
+                if proc.poll() is None:
+                    proc.kill()
+            except (OSError, ProcessLookupError):
+                pass
+
+        if proc.poll() is None:
+            # Last ditch attempt; may be unkillable zombie
+            try:
+                for _ in range(3):
+                    os.kill(proc.pid, signal.SIGKILL)
+                    time.sleep(0.2)
+                    if proc.poll() is not None:
+                        break
+            except Exception:
+                pass
+    except Exception as e:
+        console.print(f"Kill process error: {e}")
+
+
+def kill_all_running_shell_processes() -> int:
+    """Kill all currently tracked running shell processes.
+
+    Returns the number of processes signaled.
+    """
+    procs: list[subprocess.Popen]
+    with _RUNNING_PROCESSES_LOCK:
+        procs = list(_RUNNING_PROCESSES)
+    count = 0
+    for p in procs:
+        try:
+            if p.poll() is None:
+                _kill_process_group(p)
+                count += 1
+                _USER_KILLED_PROCESSES.add(p.pid)
+        finally:
+            _unregister_process(p)
+    return count
+
 
 class ShellCommandOutput(BaseModel):
     success: bool
@@ -19,35 +122,250 @@ class ShellCommandOutput(BaseModel):
     exit_code: int | None
     execution_time: float | None
     timeout: bool | None = False
+    user_interrupted: bool | None = False
+
+
+def run_shell_command_streaming(
+    process: subprocess.Popen, timeout: int = 60, command: str = ""
+):
+    start_time = time.time()
+    last_output_time = [start_time]
+
+    ABSOLUTE_TIMEOUT_SECONDS = 270
+
+    stdout_lines = []
+    stderr_lines = []
+
+    stdout_thread = None
+    stderr_thread = None
+
+    def read_stdout():
+        try:
+            for line in iter(process.stdout.readline, ""):
+                if line:
+                    line = line.rstrip("\n\r")
+                    stdout_lines.append(line)
+                    console.log(line)
+                    last_output_time[0] = time.time()
+        except Exception:
+            pass
+
+    def read_stderr():
+        try:
+            for line in iter(process.stderr.readline, ""):
+                if line:
+                    line = line.rstrip("\n\r")
+                    stderr_lines.append(line)
+                    console.log(line)
+                    last_output_time[0] = time.time()
+        except Exception:
+            pass
+
+    def cleanup_process_and_threads(timeout_type: str = "unknown"):
+        nonlocal stdout_thread, stderr_thread
+
+        def nuclear_kill(proc):
+            _kill_process_group(proc)
+
+        try:
+            if process.poll() is None:
+                nuclear_kill(process)
+
+            try:
+                if process.stdout and not process.stdout.closed:
+                    process.stdout.close()
+                if process.stderr and not process.stderr.closed:
+                    process.stderr.close()
+                if process.stdin and not process.stdin.closed:
+                    process.stdin.close()
+            except (OSError, ValueError):
+                pass
+
+            # Unregister once we're done cleaning up
+            _unregister_process(process)
+
+            if stdout_thread and stdout_thread.is_alive():
+                stdout_thread.join(timeout=3)
+                if stdout_thread.is_alive():
+                    console.print(
+                        f"stdout reader thread failed to terminate after {timeout_type} seconds"
+                    )
+
+            if stderr_thread and stderr_thread.is_alive():
+                stderr_thread.join(timeout=3)
+                if stderr_thread.is_alive():
+                    console.print(
+                        f"stderr reader thread failed to terminate after {timeout_type} seconds"
+                    )
+
+        except Exception as e:
+            console.log(f"Error during process cleanup {e}")
+
+        execution_time = time.time() - start_time
+        return ShellCommandOutput(
+            **{
+                "success": False,
+                "command": command,
+                "stdout": "\n".join(stdout_lines[-1000:]),
+                "stderr": "\n".join(stderr_lines[-1000:]),
+                "exit_code": -9,
+                "execution_time": execution_time,
+                "timeout": True,
+                "error": f"Command timed out after {timeout} seconds",
+            }
+        )
+
+    try:
+        stdout_thread = threading.Thread(target=read_stdout, daemon=True)
+        stderr_thread = threading.Thread(target=read_stderr, daemon=True)
+
+        stdout_thread.start()
+        stderr_thread.start()
+
+        while process.poll() is None:
+            current_time = time.time()
+
+            if current_time - start_time > ABSOLUTE_TIMEOUT_SECONDS:
+                error_msg = Text()
+                error_msg.append(
+                    "Process killed: inactivity timeout reached", style="bold red"
+                )
+                console.print(error_msg)
+                return cleanup_process_and_threads("absolute")
+
+            if current_time - last_output_time[0] > timeout:
+                error_msg = Text()
+                error_msg.append(
+                    "Process killed: inactivity timeout reached", style="bold red"
+                )
+                console.print(error_msg)
+                return cleanup_process_and_threads("inactivity")
+
+            time.sleep(0.1)
+
+        if stdout_thread:
+            stdout_thread.join(timeout=5)
+        if stderr_thread:
+            stderr_thread.join(timeout=5)
+
+        exit_code = process.returncode
+        execution_time = time.time() - start_time
+
+        try:
+            if process.stdout and not process.stdout.closed:
+                process.stdout.close()
+            if process.stderr and not process.stderr.closed:
+                process.stderr.close()
+            if process.stdin and not process.stdin.closed:
+                process.stdin.close()
+        except (OSError, ValueError):
+            pass
+
+        _unregister_process(process)
+
+        if exit_code != 0:
+            console.print(
+                f"Command failed with exit code {exit_code}", style="bold red"
+            )
+            console.print(f"Took {execution_time:.2f}s", style="dim")
+            time.sleep(1)
+            return ShellCommandOutput(
+                success=False,
+                command=command,
+                error="""The process didn't exit cleanly! If the user_interrupted flag is true,
+                please stop all execution and ask the user for clarification!""",
+                stdout="\n".join(stdout_lines[-1000:]),
+                stderr="\n".join(stderr_lines[-1000:]),
+                exit_code=exit_code,
+                execution_time=execution_time,
+                timeout=False,
+                user_interrupted=process.pid in _USER_KILLED_PROCESSES
+            )
+        return ShellCommandOutput(
+            success=exit_code == 0,
+            command=command,
+            stdout="\n".join(stdout_lines[-1000:]),
+            stderr="\n".join(stderr_lines[-1000:]),
+            exit_code=exit_code,
+            execution_time=execution_time,
+            timeout=False,
+        )
+
+    except Exception as e:
+        return ShellCommandOutput(
+            success=False,
+            command=command,
+            error=f"Error durign streaming execution {str(e)}",
+            stdout="\n".join(stdout_lines[-1000:]),
+            stderr="\n".join(stderr_lines[-1000:]),
+            exit_code=-1,
+            timeout=False,
+        )
+
 
 def run_shell_command(
     context: RunContext, command: str, cwd: str = None, timeout: int = 60
 ) -> ShellCommandOutput:
+    command_displayed = False
     if not command or not command.strip():
         console.print("[bold red]Error:[/bold red] Command cannot be empty")
-        return ShellCommandOutput(**{"success": False, "error": "Command cannot be empty"})
+        return ShellCommandOutput(
+            **{"success": False, "error": "Command cannot be empty"}
+        )
     console.print(
         f"\n[bold white on blue] SHELL COMMAND [/bold white on blue] \U0001f4c2 [bold green]$ {command}[/bold green]"
     )
-    if cwd:
-        console.print(f"[dim]Working directory: {cwd}[/dim]")
-    console.print("[dim]" + "-" * 60 + "[/dim]")
     from code_puppy.config import get_yolo_mode
 
     yolo_mode = get_yolo_mode()
-    if not yolo_mode:
-        user_input = input("Are you sure you want to run this command? (yes/no): ")
-        if user_input.strip().lower() not in {"yes", "y"}:
-            console.print(
-                "[bold yellow]Command execution canceled by user.[/bold yellow]"
+
+    confirmation_lock_acquired = False
+
+    # Only ask for confirmation if we're in an interactive TTY and not in yolo mode.
+    if not yolo_mode and sys.stdin.isatty():
+        confirmation_lock_acquired = _CONFIRMATION_LOCK.acquire(blocking=False)
+        if not confirmation_lock_acquired:
+            return ShellCommandOutput(
+                success=False,
+                command=command,
+                error="Another command is currently awaiting confirmation",
             )
-            return ShellCommandOutput(**{
-                "success": False,
-                "command": command,
-                "error": "User canceled command execution",
-            })
-    try:
+
+        command_displayed = True
+
+        if cwd:
+            console.print(f"[dim] Working directory: {cwd} [/dim]")
+        time.sleep(0.2)
+        sys.stdout.write("Are you sure you want to run this command? (y(es)/n(o))\n")
+        sys.stdout.flush()
+
+        try:
+            user_input = input()
+            confirmed = user_input.strip().lower() in {"yes", "y"}
+        except (KeyboardInterrupt, EOFError):
+            console.print("\n Cancelled by user")
+            confirmed = False
+        finally:
+            if confirmation_lock_acquired:
+                _CONFIRMATION_LOCK.release()
+
+        if not confirmed:
+            result = ShellCommandOutput(
+                success=False, command=command, error="User rejected the command!"
+            )
+            return result
+    else:
         start_time = time.time()
+    try:
+        creationflags = 0
+        preexec_fn = None
+        if sys.platform.startswith("win"):
+            try:
+                creationflags = subprocess.CREATE_NEW_PROCESS_GROUP  # type: ignore[attr-defined]
+            except Exception:
+                creationflags = 0
+        else:
+            preexec_fn = os.setsid if hasattr(os, "setsid") else None
         process = subprocess.Popen(
             command,
             shell=True,
@@ -55,112 +373,33 @@ def run_shell_command(
             stderr=subprocess.PIPE,
             text=True,
             cwd=cwd,
+            bufsize=1,
+            universal_newlines=True,
+            preexec_fn=preexec_fn,
+            creationflags=creationflags,
         )
+        _register_process(process)
         try:
-            stdout, stderr = process.communicate(timeout=timeout)
-            exit_code = process.returncode
-            execution_time = time.time() - start_time
-            if stdout.strip():
-                console.print("[bold white]STDOUT:[/bold white]")
-                console.print(
-                    Syntax(
-                        stdout.strip(),
-                        "bash",
-                        theme="monokai",
-                        background_color="default",
-                    )
-                )
-            else:
-                console.print("[yellow]No STDOUT output[/yellow]")
-            if stderr.strip():
-                console.print("[bold yellow]STDERR:[/bold yellow]")
-                console.print(
-                    Syntax(
-                        stderr.strip(),
-                        "bash",
-                        theme="monokai",
-                        background_color="default",
-                    )
-                )
-            if exit_code == 0:
-                console.print(
-                    f"[bold green]✓ Command completed successfully[/bold green] [dim](took {execution_time:.2f}s)[/dim]"
-                )
-            else:
-                console.print(
-                    f"[bold red]✗ Command failed with exit code {exit_code}[/bold red] [dim](took {execution_time:.2f}s)[/dim]"
-                )
-            if not stdout.strip() and not stderr.strip():
-                console.print(
-                    "[bold yellow]This command produced no output at all![/bold yellow]"
-                )
-            console.print("[dim]" + "-" * 60 + "[/dim]\n")
-            return ShellCommandOutput(**{
-                "success": exit_code == 0,
-                "command": command,
-                "stdout": stdout,
-                "stderr": stderr,
-                "exit_code": exit_code,
-                "execution_time": execution_time,
-                "timeout": False,
-            })
-        except subprocess.TimeoutExpired:
-            process.kill()
-            stdout, stderr = process.communicate()
-            execution_time = time.time() - start_time
-            if stdout.strip():
-                console.print(
-                    "[bold white]STDOUT (incomplete due to timeout):[/bold white]"
-                )
-                console.print(
-                    Syntax(
-                        stdout.strip(),
-                        "bash",
-                        theme="monokai",
-                        background_color="default",
-                    )
-                )
-            if stderr.strip():
-                console.print("[bold yellow]STDERR:[/bold yellow]")
-                console.print(
-                    Syntax(
-                        stderr.strip(),
-                        "bash",
-                        theme="monokai",
-                        background_color="default",
-                    )
-                )
-            console.print(
-                f"[bold red]⏱ Command timed out after {timeout} seconds[/bold red] [dim](ran for {execution_time:.2f}s)[/dim]"
-            )
-            console.print("[dim]" + "-" * 60 + "[/dim]\n")
-            return ShellCommandOutput(**{
-                "success": False,
-                "command": command,
-                "stdout": stdout[-1000:],
-                "stderr": stderr[-1000:],
-                "exit_code": None,
-                "execution_time": execution_time,
-                "timeout": True,
-                "error": f"Command timed out after {timeout} seconds",
-            })
+            return run_shell_command_streaming(process, timeout=timeout, command=command)
+        finally:
+            # Ensure unregistration in case streaming returned early or raised
+            _unregister_process(process)
     except Exception as e:
-        console.print_exception(show_locals=True)
-        console.print("[dim]" + "-" * 60 + "[/dim]\n")
-        # Ensure stdout and stderr are always defined
+        console.print(traceback.format_exc())
         if "stdout" not in locals():
             stdout = None
         if "stderr" not in locals():
             stderr = None
-        return ShellCommandOutput(**{
-            "success": False,
-            "command": command,
-            "error": f"Error executing command: {str(e)}",
-            "stdout": stdout[-1000:] if stdout else None,
-            "stderr": stderr[-1000:] if stderr else None,
-            "exit_code": -1,
-            "timeout": False,
-        })
+        return ShellCommandOutput(
+            success=False,
+            command=command,
+            error=f"Error executing command {str(e)}",
+            stdout="\n".join(stdout[-1000:]) if stdout else None,
+            stderr="\n".join(stderr[-1000:]) if stderr else None,
+            exit_code=-1,
+            timeout=False,
+        )
+
 
 class ReasoningOutput(BaseModel):
     success: bool = True

code_puppy/tools/file_modifications.py

@@ -378,7 +378,9 @@ def register_file_modifications_tools(agent):
     """Attach file-editing tools to *agent* with mandatory diff rendering."""
 
     @agent.tool(retries=5)
-    def edit_file(context: RunContext, path: str = "", diff: str = "") -> EditFileOutput:
+    def edit_file(
+        context: RunContext, path: str = "", diff: str = ""
+    ) -> EditFileOutput:
         return EditFileOutput(**_edit_file(context, path, diff))
 
     @agent.tool(retries=5)

code_puppy/tools/file_operations.py

@@ -1,9 +1,9 @@
 # file_operations.py
 
 import os
-from typing import Any, Dict, List
+from typing import List
 
-from pydantic import BaseModel, StrictStr, StrictInt
+from pydantic import BaseModel
 from pydantic_ai import RunContext
 
 from code_puppy.tools.common import console
@@ -41,11 +41,15 @@ def _list_files(
             f"[bold red]Error:[/bold red] Directory '{directory}' does not exist"
         )
         console.print("[dim]" + "-" * 60 + "[/dim]\n")
-        return ListFileOutput(files=[ListedFile(path=None, type=None, full_path=None, depth=None)])
+        return ListFileOutput(
+            files=[ListedFile(path=None, type=None, full_path=None, depth=None)]
+        )
     if not os.path.isdir(directory):
         console.print(f"[bold red]Error:[/bold red] '{directory}' is not a directory")
         console.print("[dim]" + "-" * 60 + "[/dim]\n")
-        return ListFileOutput(files=[ListedFile(path=None, type=None, full_path=None, depth=None)])
+        return ListFileOutput(
+            files=[ListedFile(path=None, type=None, full_path=None, depth=None)]
+        )
     folder_structure = {}
     file_list = []
     for root, dirs, files in os.walk(directory):
@@ -57,13 +61,15 @@ def _list_files(
         if rel_path:
             dir_path = os.path.join(directory, rel_path)
             results.append(
-                ListedFile(**{
-                    "path": rel_path,
-                    "type": "directory",
-                    "size": 0,
-                    "full_path": dir_path,
-                    "depth": depth,
-                })
+                ListedFile(
+                    **{
+                        "path": rel_path,
+                        "type": "directory",
+                        "size": 0,
+                        "full_path": dir_path,
+                        "depth": depth,
+                    }
+                )
             )
             folder_structure[rel_path] = {
                 "path": rel_path,
@@ -131,9 +137,7 @@ def _list_files(
             return "\U0001f4c4"
 
     if results:
-        files = sorted(
-            [f for f in results if f.type == "file"], key=lambda x: x.path
-        )
+        files = sorted([f for f in results if f.type == "file"], key=lambda x: x.path)
         console.print(
             f"\U0001f4c1 [bold blue]{os.path.basename(directory) or directory}[/bold blue]"
         )
@@ -177,6 +181,7 @@ def _list_files(
 class ReadFileOutput(BaseModel):
     content: str | None
 
+
 def _read_file(context: RunContext, file_path: str) -> ReadFileOutput:
     file_path = os.path.abspath(file_path)
     console.print(
@@ -191,7 +196,7 @@ def _read_file(context: RunContext, file_path: str) -> ReadFileOutput:
         with open(file_path, "r", encoding="utf-8") as f:
             content = f.read()
         return ReadFileOutput(content=content)
-    except Exception as exc:
+    except Exception:
         return ReadFileOutput(content="FILE NOT FOUND")
 
 
@@ -200,12 +205,12 @@ class MatchInfo(BaseModel):
     line_number: int | None
     line_content: str | None
 
+
 class GrepOutput(BaseModel):
     matches: List[MatchInfo]
 
-def _grep(
-    context: RunContext, search_string: str, directory: str = "."
-) -> GrepOutput:
+
+def _grep(context: RunContext, search_string: str, directory: str = ".") -> GrepOutput:
     matches: List[MatchInfo] = []
     directory = os.path.abspath(directory)
     console.print(
@@ -229,11 +234,13 @@ def _grep(
                 with open(file_path, "r", encoding="utf-8", errors="ignore") as fh:
                     for line_number, line_content in enumerate(fh, 1):
                         if search_string in line_content:
-                            match_info = MatchInfo(**{
-                                "file_path": file_path,
-                                "line_number": line_number,
-                                "line_content": line_content.strip(),
-                            })
+                            match_info = MatchInfo(
+                                **{
+                                    "file_path": file_path,
+                                    "line_number": line_number,
+                                    "line_content": line_content.strip(),
+                                }
+                            )
                             matches.append(match_info)
                             # console.print(
                             #     f"[green]Match:[/green] {file_path}:{line_number} - {line_content.strip()}"

{code_puppy-0.0.83.dist-info → code_puppy-0.0.85.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.83
+Version: 0.0.85
 Summary: Code generation agent
 Author: Michael Pfaffenberger
 License: MIT

code_puppy-0.0.85.dist-info/RECORD

@@ -0,0 +1,30 @@
+code_puppy/__init__.py,sha256=CWH46ZAmJRmHAbOiAhG07OrWYEcEt4yvDTkZU341Wag,169
+code_puppy/agent.py,sha256=7_1FpGPnw8U632OXP0hLmFIozfVvllF491q8gCpaa8c,3284
+code_puppy/agent_prompts.py,sha256=wTah_TvakCMhkb_KwuWCsw4_UR1QsjTZeOT1I8at_nc,6593
+code_puppy/config.py,sha256=r5nw5ChOP8xd_K5yo8U5OtO2gy2bFhARiyNtDp1JrwQ,5013
+code_puppy/main.py,sha256=qtBokZZfPQRGF91KNl_n_ywutONwF2f-zTwmt_ROsEU,11080
+code_puppy/message_history_processor.py,sha256=o5RNa-i7q_btYWJVaJFhRB2np58kObIDhQW2hZSRiKw,9244
+code_puppy/model_factory.py,sha256=HXuFHNkVjkCcorAd3ScFmSvBILO932UTq6OmNAqisT8,10898
+code_puppy/models.json,sha256=jr0-LW87aJS79GosVwoZdHeeq5eflPzgdPoMbcqpVA8,2728
+code_puppy/state_management.py,sha256=JkTkmq6f9rl_RHPDoBqJvbAzgaMsIkJf-k38ragItIo,1692
+code_puppy/summarization_agent.py,sha256=jHUQe6iYJsMT0ywEwO7CrhUIKEamO5imhAsDwvNuvow,2684
+code_puppy/version_checker.py,sha256=aRGulzuY4C4CdFvU1rITduyL-1xTFsn4GiD1uSfOl_Y,396
+code_puppy/command_line/__init__.py,sha256=y7WeRemfYppk8KVbCGeAIiTuiOszIURCDjOMZv_YRmU,45
+code_puppy/command_line/file_path_completion.py,sha256=gw8NpIxa6GOpczUJRyh7VNZwoXKKn-yvCqit7h2y6Gg,2931
+code_puppy/command_line/meta_command_handler.py,sha256=L7qP2g0Faz0V7bMH4YK3s03OWWuQFtK7Sh-Kt2zmmEQ,6182
+code_puppy/command_line/model_picker_completion.py,sha256=NkyZZG7IhcVWSJ3ADytwCA5f8DpNeVs759Qtqs4fQtY,3733
+code_puppy/command_line/motd.py,sha256=FoZsiVpXGF8WpAmEJX4O895W7MDuzCtNWvFAOShxUXY,1572
+code_puppy/command_line/prompt_toolkit_completion.py,sha256=_gP0FIOgHDNHTTWLNL0XNzr6sO0ISe7Mec1uQNo9kcM,8337
+code_puppy/command_line/utils.py,sha256=7eyxDHjPjPB9wGDJQQcXV_zOsGdYsFgI0SGCetVmTqE,1251
+code_puppy/tools/__init__.py,sha256=WTHYIfRk2KMmk6o45TELpbB3GIiAm8s7GmfJ7Zy_tww,503
+code_puppy/tools/command_runner.py,sha256=iYXAauCmntHgRcPOoMavslQ7oVFQhL0hYmjVUu6ezpk,14354
+code_puppy/tools/common.py,sha256=M53zhiXZAmPdvi1Y_bzCxgvEmifOvRRJvYPARYRZqHw,2253
+code_puppy/tools/file_modifications.py,sha256=BzQrGEacS2NZr2ru9N30x_Qd70JDudBKOAPO1XjBohg,13861
+code_puppy/tools/file_operations.py,sha256=ypk4yL90LDSVRr0xyWafttzt956J_nXhhenCXhOOit8,11326
+code_puppy/tools/ts_code_map.py,sha256=o-u8p5vsYwitfDtVEoPS-7MwWn2xHzwtIQLo1_WMhQs,17647
+code_puppy-0.0.85.data/data/code_puppy/models.json,sha256=jr0-LW87aJS79GosVwoZdHeeq5eflPzgdPoMbcqpVA8,2728
+code_puppy-0.0.85.dist-info/METADATA,sha256=mGczXN9Szot3pRImK59UT27eZq4apINNkrZxBTzUY6w,6351
+code_puppy-0.0.85.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+code_puppy-0.0.85.dist-info/entry_points.txt,sha256=d8YkBvIUxF-dHNJAj-x4fPEqizbY5d_TwvYpc01U5kw,58
+code_puppy-0.0.85.dist-info/licenses/LICENSE,sha256=31u8x0SPgdOq3izJX41kgFazWsM43zPEF9eskzqbJMY,1075
+code_puppy-0.0.85.dist-info/RECORD,,