juno-code 1.0.33 → 1.0.35

package/dist/templates/services/claude.py

@@ -51,6 +51,7 @@ class ClaudeService:
         self.verbose = False
         # User message truncation: -1 = no truncation, N = truncate to N lines
         self.user_message_truncate = int(os.environ.get("CLAUDE_USER_MESSAGE_PRETTY_TRUNCATE", "4"))
+        self.last_result_event: Optional[Dict[str, Any]] = None
 
     def expand_model_shorthand(self, model: str) -> str:
         """
@@ -529,6 +530,20 @@ Environment Variables:
             print(f"Executing: {' '.join(cmd)}", file=sys.stderr)
             print("-" * 80, file=sys.stderr)
 
+        capture_path = os.environ.get("JUNO_SUBAGENT_CAPTURE_PATH")
+
+        def write_capture_file():
+            """Persist the final result event for programmatic capture without affecting screen output."""
+            if not capture_path or not self.last_result_event:
+                return
+            try:
+                Path(capture_path).write_text(
+                    json.dumps(self.last_result_event, ensure_ascii=False),
+                    encoding="utf-8"
+                )
+            except Exception as e:
+                print(f"Warning: Failed to write capture file: {e}", file=sys.stderr)
+
         try:
             # Change to project directory before running
             original_cwd = os.getcwd()
@@ -549,9 +564,19 @@ Environment Variables:
             # This allows users to pipe to jq and see output as it streams
             if process.stdout:
                 for line in process.stdout:
+                    raw_line = line.strip()
+                    # Capture the raw final result event for programmatic consumption
+                    try:
+                        parsed_raw = json.loads(raw_line)
+                        if isinstance(parsed_raw, dict) and parsed_raw.get("type") == "result":
+                            self.last_result_event = parsed_raw
+                    except json.JSONDecodeError:
+                        # Ignore non-JSON lines here; pretty formatter will handle them
+                        pass
+
                     # Apply pretty formatting if enabled
                     if pretty:
-                        formatted_line = self.pretty_format_json(line.strip())
+                        formatted_line = self.pretty_format_json(raw_line)
                         if formatted_line:
                             print(formatted_line, flush=True)
                     else:
@@ -567,6 +592,9 @@ Environment Variables:
                 if stderr_output:
                     print(stderr_output, file=sys.stderr)
 
+            # Persist the raw final result event for programmatic capture
+            write_capture_file()
+
             # Restore original working directory
             os.chdir(original_cwd)
 
@@ -577,12 +605,14 @@ Environment Variables:
             if process:
                 process.terminate()
                 process.wait()
+            write_capture_file()
             # Restore original working directory
             if 'original_cwd' in locals():
                 os.chdir(original_cwd)
             return 130
         except Exception as e:
             print(f"Error executing claude: {e}", file=sys.stderr)
+            write_capture_file()
             # Restore original working directory
             if 'original_cwd' in locals():
                 os.chdir(original_cwd)

package/dist/templates/services/codex.py

@@ -34,6 +34,7 @@ class CodexService:
         self.prompt = ""
         self.additional_args: List[str] = []
         self.verbose = False
+        self._item_counter = 0
 
     def expand_model_shorthand(self, model: str) -> str:
         """
@@ -128,6 +129,108 @@ Environment Variables:
 
         return parser.parse_args()
 
+    def _first_nonempty_str(self, *values: Optional[str]) -> str:
+        """Return the first non-empty string value."""
+        for val in values:
+            if isinstance(val, str) and val != "":
+                return val
+        return ""
+
+    def _extract_content_text(self, payload: dict) -> str:
+        """Join text-like fields from content arrays (item.* schema)."""
+        content = payload.get("content") if isinstance(payload, dict) else None
+        parts: List[str] = []
+        if isinstance(content, list):
+            for entry in content:
+                if not isinstance(entry, dict):
+                    continue
+                text_val = (
+                    entry.get("text")
+                    or entry.get("message")
+                    or entry.get("output_text")
+                    or entry.get("input_text")
+                )
+                if isinstance(text_val, str) and text_val != "":
+                    parts.append(text_val)
+        return "\n".join(parts) if parts else ""
+
+    def _extract_command_output_text(self, payload: dict) -> str:
+        """Extract aggregated/command output from various item.* layouts."""
+        if not isinstance(payload, dict):
+            return ""
+        result = payload.get("result") if isinstance(payload.get("result"), dict) else None
+        content_text = self._extract_content_text(payload)
+        return self._first_nonempty_str(
+            payload.get("aggregated_output"),
+            payload.get("output"),
+            payload.get("formatted_output"),
+            result.get("aggregated_output") if result else None,
+            result.get("output") if result else None,
+            result.get("formatted_output") if result else None,
+            content_text,
+        )
+
+    def _extract_reasoning_text(self, payload: dict) -> str:
+        """Extract reasoning text from legacy and item.* schemas."""
+        if not isinstance(payload, dict):
+            return ""
+        reasoning_obj = payload.get("reasoning") if isinstance(payload.get("reasoning"), dict) else None
+        result_obj = payload.get("result") if isinstance(payload.get("result"), dict) else None
+        content_text = self._extract_content_text(payload)
+        return self._first_nonempty_str(
+            payload.get("text"),
+            payload.get("reasoning_text"),
+            reasoning_obj.get("text") if reasoning_obj else None,
+            result_obj.get("text") if result_obj else None,
+            content_text,
+        )
+
+    def _extract_message_text(self, payload: dict) -> str:
+        """Extract final/assistant message text from item.* schemas."""
+        if not isinstance(payload, dict):
+            return ""
+        result_obj = payload.get("result") if isinstance(payload.get("result"), dict) else None
+        content_text = self._extract_content_text(payload)
+        return self._first_nonempty_str(
+            payload.get("message"),
+            payload.get("text"),
+            payload.get("final"),
+            result_obj.get("message") if result_obj else None,
+            result_obj.get("text") if result_obj else None,
+            content_text,
+        )
+
+    def _parse_item_number(self, item_id: str) -> Optional[int]:
+        """Return numeric component from item_{n} ids or None if unparseable."""
+        if not isinstance(item_id, str):
+            return None
+        item_id = item_id.strip()
+        if not item_id.startswith("item_"):
+            return None
+        try:
+            return int(item_id.split("item_", 1)[1])
+        except Exception:
+            return None
+
+    def _normalize_item_id(self, payload: dict, outer_type: str) -> Optional[str]:
+        """
+        Prefer the existing id on item.* payloads; otherwise synthesize sequential item_{n}.
+        Maintains a per-run counter so missing ids still expose turn counts.
+        """
+        item_id = payload.get("id") if isinstance(payload, dict) else None
+        if isinstance(item_id, str) and item_id.strip():
+            parsed = self._parse_item_number(item_id)
+            if parsed is not None and parsed + 1 > self._item_counter:
+                self._item_counter = parsed + 1
+            return item_id.strip()
+
+        if isinstance(outer_type, str) and outer_type.startswith("item."):
+            generated = f"item_{self._item_counter}"
+            self._item_counter += 1
+            return generated
+
+        return None
+
     def read_prompt_file(self, file_path: str) -> str:
         """Read prompt from a file"""
         try:
@@ -190,12 +293,18 @@ Environment Variables:
 
         return cmd
 
-    def _format_msg_pretty(self, obj: dict) -> Optional[str]:
+    def _format_msg_pretty(
+        self,
+        msg_type: str,
+        payload: dict,
+        outer_type: str = "",
+        item_id: Optional[str] = None,
+    ) -> Optional[str]:
         """
         Pretty format for specific msg types to be human readable while
         preserving a compact JSON header line that includes the msg.type.
 
-        - agent_message: render 'message' field as multi-line text
+        - agent_message/message/assistant: render message text as multi-line block
         - agent_reasoning: render 'text' field as multi-line text
         - exec_command_end: only output 'formatted_output' (suppress other fields)
         - token_count: fully suppressed (no final summary emission)
@@ -203,41 +312,96 @@ Environment Variables:
         Returns a string to print, or None to fall back to raw printing.
         """
         try:
-            msg = obj.get("msg") or {}
-            msg_type = (msg.get("type") or "").strip()
             now = datetime.now().strftime("%I:%M:%S %p")
-
-            # agent_message → show 'message' human-readable
-            if msg_type == "agent_message":
-                content = msg.get("message", "")
-                header = {"type": msg_type, "datetime": now}
-                if "\n" in content:
-                    return json.dumps(header, ensure_ascii=False) + "\nmessage:\n" + content
-                header["message"] = content
-                return json.dumps(header, ensure_ascii=False)
+            msg_type = (msg_type or "").strip()
+            header_type = (outer_type or msg_type).strip()
+            base_type = header_type or msg_type or "message"
+
+            def make_header(type_value: str):
+                hdr = {"type": type_value, "datetime": now}
+                if item_id:
+                    hdr["id"] = item_id
+                if outer_type and msg_type and outer_type != msg_type:
+                    hdr["item_type"] = msg_type
+                return hdr
+
+            header = make_header(base_type)
+
+            if isinstance(payload, dict):
+                if item_id and "id" not in payload:
+                    payload["id"] = item_id
+                if payload.get("command"):
+                    header["command"] = payload.get("command")
+                if payload.get("status"):
+                    header["status"] = payload.get("status")
+                if payload.get("state") and not header.get("status"):
+                    header["status"] = payload.get("state")
 
             # agent_reasoning → show 'text' human-readable
-            if msg_type == "agent_reasoning":
-                content = msg.get("text", "")
-                header = {"type": msg_type, "datetime": now}
+            if msg_type in {"agent_reasoning", "reasoning"}:
+                content = self._extract_reasoning_text(payload)
+                header = make_header(header_type or msg_type)
                 if "\n" in content:
                     return json.dumps(header, ensure_ascii=False) + "\ntext:\n" + content
                 header["text"] = content
                 return json.dumps(header, ensure_ascii=False)
 
+            if msg_type in {"agent_message", "message", "assistant_message", "assistant"}:
+                content = self._extract_message_text(payload)
+                header = make_header(header_type or msg_type)
+                if "\n" in content:
+                    return json.dumps(header, ensure_ascii=False) + "\nmessage:\n" + content
+                if content != "":
+                    header["message"] = content
+                    return json.dumps(header, ensure_ascii=False)
+                if header_type:
+                    return json.dumps(header, ensure_ascii=False)
+
             # exec_command_end → only show 'formatted_output'
             if msg_type == "exec_command_end":
-                formatted_output = msg.get("formatted_output", "")
+                formatted_output = payload.get("formatted_output", "") if isinstance(payload, dict) else ""
                 header = {"type": msg_type, "datetime": now}
                 if "\n" in formatted_output:
                     return json.dumps(header, ensure_ascii=False) + "\nformatted_output:\n" + formatted_output
                 header["formatted_output"] = formatted_output
                 return json.dumps(header, ensure_ascii=False)
 
+            # item.* schema → command_execution blocks
+            if msg_type == "command_execution":
+                aggregated_output = self._extract_command_output_text(payload)
+                if "\n" in aggregated_output:
+                    return json.dumps(header, ensure_ascii=False) + "\naggregated_output:\n" + aggregated_output
+                if aggregated_output:
+                    header["aggregated_output"] = aggregated_output
+                    return json.dumps(header, ensure_ascii=False)
+                # No output (likely item.started) – still show header if it carries context
+                if header_type:
+                    return json.dumps(header, ensure_ascii=False)
+
             return None
         except Exception:
             return None
 
+    def _normalize_event(self, obj_dict: dict):
+        """
+        Normalize legacy (msg-based) and new item.* schemas into a common tuple.
+        Returns (msg_type, payload_dict, outer_type).
+        """
+        msg = obj_dict.get("msg") if isinstance(obj_dict.get("msg"), dict) else {}
+        outer_type = (obj_dict.get("type") or "").strip()
+        item = obj_dict.get("item") if isinstance(obj_dict.get("item"), dict) else None
+
+        msg_type = (msg.get("type") or "").strip() if isinstance(msg, dict) else ""
+        payload = msg if isinstance(msg, dict) else {}
+
+        if not msg_type and item is not None:
+            msg_type = (item.get("type") or "").strip() or outer_type
+            payload = item
+        elif not msg_type:
+            msg_type = outer_type
+
+        return msg_type, payload, outer_type
+
     def run_codex(self, cmd: List[str], verbose: bool = False) -> int:
         """Execute the codex command and stream output with filtering and pretty-printing
 
@@ -260,6 +424,9 @@ Environment Variables:
                 parts = [p.strip() for p in env_val.split(",") if p.strip()]
                 hide_types.update(parts)
 
+        # Reset per-run item counter for synthesized ids
+        self._item_counter = 0
+
         # We fully suppress all token_count events (do not emit even at end)
         last_token_count = None
 
@@ -274,119 +441,124 @@ Environment Variables:
                 universal_newlines=True
             )
 
+            def split_json_stream(text: str):
+                objs = []
+                buf: List[str] = []
+                depth = 0
+                in_str = False
+                esc = False
+                started = False
+                for ch in text:
+                    if in_str:
+                        buf.append(ch)
+                        if esc:
+                            esc = False
+                        elif ch == '\\':
+                            esc = True
+                        elif ch == '"':
+                            in_str = False
+                        continue
+                    if ch == '"':
+                        in_str = True
+                        buf.append(ch)
+                        continue
+                    if ch == '{':
+                        depth += 1
+                        started = True
+                        buf.append(ch)
+                        continue
+                    if ch == '}':
+                        depth -= 1
+                        buf.append(ch)
+                        if started and depth == 0:
+                            candidate = ''.join(buf).strip().strip("'\"")
+                            if candidate:
+                                objs.append(candidate)
+                            buf = []
+                            started = False
+                        continue
+                    if started:
+                        buf.append(ch)
+                remainder = ''.join(buf) if buf else ""
+                return objs, remainder
+
+            def handle_obj(obj_dict: dict):
+                nonlocal last_token_count
+                msg_type_inner, payload_inner, outer_type_inner = self._normalize_event(obj_dict)
+                item_id_inner = self._normalize_item_id(payload_inner, outer_type_inner)
+
+                if (
+                    item_id_inner
+                    and isinstance(obj_dict.get("item"), dict)
+                    and not obj_dict["item"].get("id")
+                ):
+                    obj_dict["item"]["id"] = item_id_inner
+
+                if msg_type_inner == "token_count":
+                    last_token_count = obj_dict
+                    return  # suppress
+
+                if msg_type_inner and msg_type_inner in hide_types:
+                    return  # suppress
+
+                pretty_line_inner = self._format_msg_pretty(
+                    msg_type_inner,
+                    payload_inner,
+                    outer_type_inner,
+                    item_id=item_id_inner,
+                )
+                if pretty_line_inner is not None:
+                    print(pretty_line_inner, flush=True)
+                else:
+                    # print normalized JSON
+                    print(json.dumps(obj_dict, ensure_ascii=False), flush=True)
+
+            pending = ""
+
             if process.stdout:
                 for raw_line in process.stdout:
-                    line = raw_line.rstrip("\n")
-                    if not line:
+                    combined = pending + raw_line
+                    if not combined.strip():
+                        pending = ""
                         continue
-                    # Try to parse NDJSON and filter by msg.type
-                    try:
-                        obj = None
-                        s = line.strip()
 
-                        # Direct JSON line
-                        if s.startswith("{") and s.endswith("}"):
-                            try:
-                                obj = json.loads(s)
-                            except Exception:
-                                obj = None
-
-                        # Attempt to extract JSON object substring if noise surrounds it
-                        if obj is None:
-                            lbrace = s.find("{")
-                            rbrace = s.rfind("}")
-                            if lbrace != -1 and rbrace != -1 and rbrace > lbrace:
-                                candidate = s[lbrace:rbrace + 1]
-                                try:
-                                    obj = json.loads(candidate)
-                                    s = candidate  # normalized JSON text
-                                except Exception:
-                                    obj = None
-
-                        def handle_obj(obj_dict: dict):
-                            nonlocal last_token_count
-                            msg = obj_dict.get("msg") or {}
-                            msg_type_inner = (msg.get("type") or "").strip()
-
-                            if msg_type_inner == "token_count":
-                                last_token_count = obj_dict
-                                return  # suppress
-
-                            if msg_type_inner and msg_type_inner in hide_types:
-                                return  # suppress
-
-                            pretty_line_inner = self._format_msg_pretty(obj_dict)
-                            if pretty_line_inner is not None:
-                                print(pretty_line_inner, flush=True)
-                            else:
-                                # print normalized JSON
-                                print(json.dumps(obj_dict, ensure_ascii=False), flush=True)
-
-                        if isinstance(obj, dict):
-                            handle_obj(obj)
+                    # If no braces present at all, treat as plain text (with suppression)
+                    if "{" not in combined and "}" not in combined:
+                        lower = combined.lower()
+                        if (
+                            '"token_count"' in lower
+                            or '"exec_command_output_delta"' in lower
+                            or '"turn_diff"' in lower
+                        ):
+                            pending = ""
                             continue
-                        
-                        # If line appears to contain multiple concatenated JSON objects,
-                        # split by top-level brace balancing while respecting strings
-                        def split_concatenated_json(text: str):
-                            objs = []
-                            buf = []
-                            depth = 0
-                            in_str = False
-                            esc = False
-                            started = False
-                            for ch in text:
-                                if in_str:
-                                    buf.append(ch)
-                                    if esc:
-                                        esc = False
-                                    elif ch == '\\':
-                                        esc = True
-                                    elif ch == '"':
-                                        in_str = False
-                                    continue
-                                # not in string
-                                if ch == '"':
-                                    in_str = True
-                                    buf.append(ch)
-                                    continue
-                                if ch == '{':
-                                    depth += 1
-                                    started = True
-                                    buf.append(ch)
-                                    continue
-                                if ch == '}':
-                                    depth -= 1
-                                    buf.append(ch)
-                                    if started and depth == 0:
-                                        candidate = ''.join(buf).strip().strip("'\"")
-                                        if candidate:
-                                            objs.append(candidate)
-                                        buf = []
-                                        started = False
-                                    continue
-                                # accumulate only if currently collecting an object
-                                if started:
-                                    buf.append(ch)
-                            return objs
-
-                        parts = split_concatenated_json(s)
-                        if parts:
-                            for part in parts:
-                                try:
-                                    sub = json.loads(part)
-                                    if isinstance(sub, dict):
-                                        handle_obj(sub)
-                                    else:
-                                        low = part.lower()
-                                        if (
-                                            '"token_count"' in low
-                                            or '"exec_command_output_delta"' in low
-                                            or '"turn_diff"' in low
-                                        ):
-                                            continue
-                                        print(part, flush=True)
-                                except Exception:
+                        print(combined, end="" if combined.endswith("\n") else "\n", flush=True)
+                        pending = ""
+                        continue
+
+                    # Preserve and emit any prefix before the first brace
+                    first_brace = combined.find("{")
+                    if first_brace > 0:
+                        prefix = combined[:first_brace]
+                        lower_prefix = prefix.lower()
+                        if (
+                            '"token_count"' not in lower_prefix
+                            and '"exec_command_output_delta"' not in lower_prefix
+                            and '"turn_diff"' not in lower_prefix
+                            and prefix.strip()
+                        ):
+                            print(prefix, end="" if prefix.endswith("\n") else "\n", flush=True)
+                        combined = combined[first_brace:]
+
+                    parts, pending = split_json_stream(combined)
+
+                    if parts:
+                        for part in parts:
+                            try:
+                                sub = json.loads(part)
+                                if isinstance(sub, dict):
+                                    handle_obj(sub)
+                                else:
                                     low = part.lower()
                                     if (
                                         '"token_count"' in low
@@ -395,31 +567,47 @@ Environment Variables:
                                     ):
                                         continue
                                     print(part, flush=True)
-                            continue
-                        else:
-                            # If not valid JSON, suppress known noisy tokens by string search
-                            lower = s.lower()
-                            if (
-                                '"type"' in lower
-                                and (
-                                    '"token_count"' in lower
-                                    or '"exec_command_output_delta"' in lower
-                                    or '"turn_diff"' in lower
-                                )
-                            ):
-                                # Best-effort suppression for malformed lines containing noisy types
-                                continue
-                            # Not JSON and not noisy → passthrough
-                            print(raw_line, end="", flush=True)
-                    except Exception:
-                        # On parsing error, last-gasp suppression by substring match
-                        if (
-                            '"token_count"' in raw_line
-                            or '"exec_command_output_delta"' in raw_line
-                            or '"turn_diff"' in raw_line
-                        ):
-                            continue
-                        print(raw_line, end="", flush=True)
+                            except Exception:
+                                low = part.lower()
+                                if (
+                                    '"token_count"' in low
+                                    or '"exec_command_output_delta"' in low
+                                    or '"turn_diff"' in low
+                                ):
+                                    continue
+                                print(part, flush=True)
+                        continue
+
+                    # No complete object found yet; keep buffering if likely in the middle of one
+                    if pending:
+                        continue
+
+                    # Fallback for malformed/non-JSON lines that still contain braces
+                    lower = combined.lower()
+                    if (
+                        '"token_count"' in lower
+                        or '"exec_command_output_delta"' in lower
+                        or '"turn_diff"' in lower
+                    ):
+                        continue
+                    print(combined, end="" if combined.endswith("\n") else "\n", flush=True)
+
+            # Flush any pending buffered content after the stream ends
+            if pending.strip():
+                try:
+                    tail_obj = json.loads(pending)
+                    if isinstance(tail_obj, dict):
+                        handle_obj(tail_obj)
+                    else:
+                        print(pending, flush=True)
+                except Exception:
+                    low_tail = pending.lower()
+                    if (
+                        '"token_count"' not in low_tail
+                        and '"exec_command_output_delta"' not in low_tail
+                        and '"turn_diff"' not in low_tail
+                    ):
+                        print(pending, flush=True)
 
             # Wait for process completion
             process.wait()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "juno-code",
-  "version": "1.0.33",
+  "version": "1.0.35",
   "description": "TypeScript CLI tool for AI subagent orchestration with code automation",
   "keywords": [
     "ai",