@oh-my-pi/pi-coding-agent 14.9.2 → 14.9.5

package/src/eval/py/prelude.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 if "__omp_prelude_loaded__" not in globals():
     __omp_prelude_loaded__ = True
     from pathlib import Path
-    import os, json, shutil, subprocess
+    import os, json
     from IPython.display import display as _ipy_display, JSON
 
     _PRESENTABLE_REPRS = (
@@ -79,79 +79,6 @@ if "__omp_prelude_loaded__" not in globals():
             f.write(content)
         _emit_status("append", path=str(p), chars=len(content))
         return p
-    class ShellResult:
-        """Result from shell command execution."""
-        __slots__ = ("args", "stdout", "stderr", "returncode")
-        def __init__(self, args: str, stdout: str, stderr: str, returncode: int):
-            self.args = args
-            self.stdout = stdout
-            self.stderr = stderr
-            self.returncode = returncode
-
-        @property
-        def code(self) -> int:
-            return self.returncode
-
-        @property
-        def exit_code(self) -> int:
-            return self.returncode
-
-        def check_returncode(self) -> None:
-            if self.returncode != 0:
-                raise subprocess.CalledProcessError(
-                    self.returncode, self.args, output=self.stdout, stderr=self.stderr
-                )
-
-        def __repr__(self):
-            if self.returncode == 0:
-                return ""
-            return f"exit code {self.returncode}"
-
-        def __bool__(self):
-            return self.returncode == 0
-
-    def _make_shell_result(proc: subprocess.CompletedProcess[str], cmd: str) -> ShellResult:
-        """Create ShellResult and emit status."""
-        output = proc.stdout + proc.stderr if proc.stderr else proc.stdout
-        _emit_status("sh", cmd=cmd[:80], code=proc.returncode, output=output[:500])
-        return ShellResult(cmd, proc.stdout, proc.stderr, proc.returncode)
-
-    import signal as _signal
-
-    def _run_with_interrupt(args: list[str], cwd: str | None, timeout: int | None, cmd: str) -> ShellResult:
-        """Run subprocess with proper interrupt handling."""
-        proc = subprocess.Popen(
-            args,
-            cwd=cwd,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-            start_new_session=True,
-        )
-        try:
-            stdout, stderr = proc.communicate(timeout=timeout)
-        except KeyboardInterrupt:
-            os.killpg(proc.pid, _signal.SIGINT)
-            try:
-                stdout, stderr = proc.communicate(timeout=2)
-            except subprocess.TimeoutExpired:
-                os.killpg(proc.pid, _signal.SIGKILL)
-                stdout, stderr = proc.communicate()
-            result = subprocess.CompletedProcess(args, -_signal.SIGINT, stdout, stderr)
-            return _make_shell_result(result, cmd)
-        except subprocess.TimeoutExpired:
-            os.killpg(proc.pid, _signal.SIGKILL)
-            stdout, stderr = proc.communicate()
-            result = subprocess.CompletedProcess(args, -_signal.SIGKILL, stdout, stderr)
-            return _make_shell_result(result, cmd)
-        result = subprocess.CompletedProcess(args, proc.returncode, stdout, stderr)
-        return _make_shell_result(result, cmd)
-
-    def run(cmd: str, *, cwd: str | Path | None = None, timeout: int | None = None) -> ShellResult:
-        """Run a shell command. Returns ShellResult with stdout/stderr and returncode/exit_code fields."""
-        shell_path = shutil.which("bash") or shutil.which("sh") or "/bin/sh"
-        args = [shell_path, "-c", cmd]
-        return _run_with_interrupt(args, str(cwd) if cwd else None, timeout, cmd)
 
     def sort(text: str, *, reverse: bool = False, unique: bool = False) -> str:
         """Sort lines of text."""
@@ -268,12 +195,16 @@ if "__omp_prelude_loaded__" not in globals():
             output('explore_0', offset=10, limit=20)  # Lines 10-29
             output('explore_0', 'reviewer_1')  # Read multiple outputs
         """
-        session_file = os.environ.get("PI_SESSION_FILE")
-        if not session_file:
-            _emit_status("output", error="No session file available")
-            raise RuntimeError("No session - output artifacts unavailable")
-        
-        artifacts_dir = session_file.rsplit(".", 1)[0]  # Strip .jsonl extension
+        # Prefer PI_ARTIFACTS_DIR so subagents resolve through the parent's
+        # shared artifacts dir; fall back to deriving from PI_SESSION_FILE
+        # for legacy callers / top-level sessions where the two coincide.
+        artifacts_dir = os.environ.get("PI_ARTIFACTS_DIR")
+        if not artifacts_dir:
+            session_file = os.environ.get("PI_SESSION_FILE")
+            if not session_file:
+                _emit_status("output", error="No session file available")
+                raise RuntimeError("No session - output artifacts unavailable")
+            artifacts_dir = session_file.rsplit(".", 1)[0]  # Strip .jsonl extension
         if not Path(artifacts_dir).exists():
             _emit_status("output", error="Artifacts directory not found", path=artifacts_dir)
             raise RuntimeError(f"No artifacts directory found: {artifacts_dir}")

package/src/eval/sniff.ts

@@ -0,0 +1,28 @@
+import type { EvalLanguage } from "./types";
+
+/**
+ * Best-effort language sniff for cells with no explicit `language`.
+ *
+ * Order:
+ * 1. Shebang on first line (`#!/usr/bin/env python`, `#!/usr/bin/env node`, etc.)
+ * 2. Strong syntactic markers unique to one language. Bias false negatives over
+ *    false positives — anything ambiguous returns `undefined` and the caller
+ *    falls back to the default-backend rules.
+ */
+export function sniffEvalLanguage(code: string): EvalLanguage | undefined {
+	const stripped = code.replace(/^\s+/, "");
+	if (stripped.startsWith("#!")) {
+		const firstLine = stripped.split("\n", 1)[0]!.toLowerCase();
+		if (/(\bpython\d?\b|\bipython\b)/.test(firstLine)) return "python";
+		if (/(\bnode\b|\bbun\b|\bdeno\b|\bjavascript\b|\bjs\b)/.test(firstLine)) return "js";
+	}
+	const jsMarkers =
+		/(^|\n)\s*(const|let|var|async\s+function|function\s*\*?\s*[\w$]*\s*\(|import\s+[^\n]+\sfrom\s|export\s+(default|const|let|function|class|async)|require\s*\(|console\.\w+\s*\(|=>|;\s*$)/m;
+	const pyMarkers =
+		/(^|\n)\s*(def\s+\w+\s*\(|from\s+[\w.]+\s+import|import\s+\w+(\s+as\s+\w+)?\s*$|class\s+\w+\s*[(:]|print\s*\(|elif\s+[^\n]*:|with\s+[^\n]+:\s*$|@[\w.]+\s*$)/m;
+	const hasJs = jsMarkers.test(code);
+	const hasPy = pyMarkers.test(code);
+	if (hasJs && !hasPy) return "js";
+	if (hasPy && !hasJs) return "python";
+	return undefined;
+}

package/src/export/html/template.css

@@ -179,6 +179,10 @@
       color: var(--accent);
     }
 
+    .tree-role-developer {
+      color: var(--dim);
+    }
+
     .tree-role-assistant {
       color: var(--success);
     }
@@ -316,6 +320,14 @@
       position: relative;
     }
 
+    .user-message.developer-message {
+      opacity: 0.7;
+    }
+
+    .user-message.developer-message .markdown-content {
+      color: var(--dim);
+    }
+
     .assistant-message {
       padding: 0;
       position: relative;
@@ -650,6 +662,7 @@
       padding: var(--line-height);
       border-radius: 4px;
       margin-bottom: var(--line-height);
+      cursor: pointer;
     }
 
     .tools-header {
@@ -658,6 +671,35 @@
       margin-bottom: var(--line-height);
     }
 
+    .tools-list.collapsed .tools-header {
+      margin-bottom: 0;
+    }
+
+    .tools-list.collapsed .tools-content {
+      display: none;
+    }
+
+    .tools-list:not(.collapsed) .tools-collapsed {
+      display: none;
+    }
+
+    .tools-collapsed {
+      margin-top: 6px;
+      display: flex;
+      flex-wrap: wrap;
+      gap: 4px;
+    }
+
+    .tool-name-chip {
+      display: inline-block;
+      padding: 1px 6px;
+      border-radius: 3px;
+      background: var(--container-bg);
+      color: var(--text);
+      font-size: 11px;
+      font-weight: 500;
+    }
+
     .tool-item {
       font-size: 11px;
     }
@@ -726,6 +768,14 @@
       color: var(--warning);
     }
 
+    .tool-intent {
+      color: var(--muted);
+      font-style: italic;
+      font-size: 11px;
+      margin-bottom: 4px;
+      opacity: 0.85;
+    }
+
     .tool-args {
       margin-top: 4px;
       color: var(--toolOutput);