Update pygmyclaw_multitool.py

pygmyclaw_multitool.py

@@ -1,7 +1,11 @@
 #!/usr/bin/env python3
 """
 PygmyClaw Multitool – Contains the actual tool implementations.
+Works both as:
+1) CLI tool (stdin → stdout JSON)
+2) Python module (import + run_tool())
 """
+
 import json
 import sys
 import os
@@ -10,11 +14,15 @@ import time
 from pathlib import Path
 
 SCRIPT_DIR = Path(__file__).parent.resolve()
+
 ERROR_LOG = SCRIPT_DIR / "error_log.json"
+
 MAX_LOG_ENTRIES = 1000
 
+
 # ----------------------------------------------------------------------
 # Tool definitions
+
 TOOLS = {
     "list_tools_detailed": {
         "name": "list_tools_detailed",
@@ -22,12 +30,14 @@ TOOLS = {
         "parameters": {},
         "func": "do_list_tools"
     },
+
     "sys_info": {
         "name": "sys_info",
         "description": "Get system information (OS, Python version, etc.).",
         "parameters": {},
         "func": "do_sys_info"
     },
+
     "log_error": {
         "name": "log_error",
         "description": "Log an error message to the error log.",
@@ -37,6 +47,7 @@ TOOLS = {
         },
         "func": "do_log_error"
     },
+
     "echo": {
         "name": "echo",
         "description": "Echo the input text (for testing).",
@@ -45,19 +56,30 @@ TOOLS = {
     }
 }
 
+
+# ----------------------------------------------------------------------
+# Tool Implementations
+
+
 def do_list_tools():
-    """Return the list of tools with their metadata."""
+    """Return the list of tools with metadata."""
+
     tools_list = []
+
     for name, info in TOOLS.items():
+
         tools_list.append({
             "name": name,
             "description": info["description"],
             "parameters": info["parameters"]
         })
+
     return {"tools": tools_list}
 
+
 def do_sys_info():
     """Return system information."""
+
     return {
         "os": platform.system(),
         "os_release": platform.release(),
@@ -65,74 +87,124 @@ def do_sys_info():
         "hostname": platform.node()
     }
 
+
 def do_log_error(msg, trace=""):
-    """Append an error to the error log file."""
+    """Append an error to the error log."""
+
     entry = {
         "timestamp": time.time(),
         "msg": msg,
         "trace": trace
     }
+
     try:
+
         if ERROR_LOG.exists():
+
             with open(ERROR_LOG) as f:
                 log = json.load(f)
+
         else:
+
             log = []
+
         log.append(entry)
-        # Keep only last MAX_LOG_ENTRIES
+
         if len(log) > MAX_LOG_ENTRIES:
             log = log[-MAX_LOG_ENTRIES:]
-        with open(ERROR_LOG, 'w') as f:
+
+        with open(ERROR_LOG, "w") as f:
             json.dump(log, f, indent=2)
+
         return {"status": "logged"}
+
     except Exception as e:
+
         return {"error": f"Failed to write log: {e}"}
 
+
 def do_echo(text):
-    """Echo the input."""
+    """Echo input."""
+
     return {"echo": text}
 
+
 # ----------------------------------------------------------------------
-# Main dispatcher
+# INTERNAL TOOL EXECUTOR (used by PygmyClaw agent)
+
+def run_tool(action, **params):
+    """
+    Run tool programmatically.
+
+    Example:
+        run_tool("sys_info")
+        run_tool("echo", text="hello")
+    """
+
+    tool = TOOLS.get(action)
+
+    if not tool:
+        return {"error": f"Unknown tool '{action}'"}
+
+    func_name = tool["func"]
+
+    try:
+
+        if func_name == "do_list_tools":
+            return do_list_tools()
+
+        elif func_name == "do_sys_info":
+            return do_sys_info()
+
+        elif func_name == "do_log_error":
+            return do_log_error(
+                params.get("msg"),
+                params.get("trace", "")
+            )
+
+        elif func_name == "do_echo":
+            return do_echo(params.get("text"))
+
+        else:
+            return {"error": f"Unknown function '{func_name}'"}
+
+    except Exception as e:
+
+        return {"error": f"Tool execution failed: {e}"}
+
+
+# ----------------------------------------------------------------------
+# CLI Dispatcher (existing behavior preserved)
+
 def main():
+
     try:
-        data = json.loads(sys.stdin.read())
+
+        raw = sys.stdin.read()
+
+        if not raw:
+            print(json.dumps({"error": "No input"}))
+            return
+
+        data = json.loads(raw)
+
         action = data.get("action")
+
         if not action:
+
             print(json.dumps({"error": "No action specified"}))
             return
 
-        # Find the tool
-        tool_info = TOOLS.get(action)
-        if not tool_info:
-            print(json.dumps({"error": f"Unknown action '{action}'"}))
-            return
+        params = {k: v for k, v in data.items() if k != "action"}
 
-        # Call the corresponding function
-        func_name = tool_info["func"]
-        if func_name == "do_list_tools":
-            result = do_list_tools()
-        elif func_name == "do_sys_info":
-            result = do_sys_info()
-        elif func_name == "do_log_error":
-            msg = data.get("msg")
-            trace = data.get("trace", "")
-            if msg is None:
-                result = {"error": "Missing 'msg' parameter"}
-            else:
-                result = do_log_error(msg, trace)
-        elif func_name == "do_echo":
-            text = data.get("text")
-            if text is None:
-                result = {"error": "Missing 'text' parameter"}
-            else:
-                result = do_echo(text)
-        else:
-            result = {"error": f"Internal error: unknown function {func_name}"}
+        result = run_tool(action, **params)
 
         print(json.dumps(result))
+
     except Exception as e:
+
         print(json.dumps({"error": f"Multitool exception: {e}"}))
 
+
 if __name__ == "__main__":
-    main()
+    main()