juno-code 1.0.31 → 1.0.33

package/dist/templates/services/claude.py

@@ -95,6 +95,8 @@ Examples:
   %(prog)s -p "Complex task" -m claude-opus-4-20250514 --tool Read --tool Write
   %(prog)s -p "Multi-tool task" --allowed-tools Bash Edit Read Write
   %(prog)s -p "Restricted task" --disallowed-tools Bash WebSearch
+  %(prog)s --continue -p "Continue previous conversation"
+  %(prog)s --resume abc123 -p "Resume session abc123"
 
 Default Tools (enabled by default when no --allowed-tools specified):
   Task, Bash, Glob, Grep, ExitPlanMode, Read, Edit, Write, NotebookEdit,
@@ -210,6 +212,14 @@ Environment Variables:
             help="Continue the most recent conversation"
         )
 
+        parser.add_argument(
+            "-r", "--resume",
+            type=str,
+            dest="resume_session",
+            metavar="SESSION_ID",
+            help="Resume a conversation by session ID (e.g., claude --resume abc123)"
+        )
+
         parser.add_argument(
             "--agents",
             type=str,
@@ -286,6 +296,10 @@ Environment Variables:
         if args.continue_conversation:
             cmd.append("--continue")
 
+        # Add resume flag if specified
+        if args.resume_session:
+            cmd.extend(["--resume", args.resume_session])
+
         # Add agents configuration if specified
         if args.agents:
             cmd.extend(["--agents", args.agents])

package/dist/templates/services/codex.py

@@ -8,16 +8,25 @@ import argparse
 import os
 import subprocess
 import sys
-from typing import List
+import json
+from datetime import datetime
+from typing import List, Optional
 
 
 class CodexService:
     """Service wrapper for OpenAI Codex CLI"""
 
     # Default configuration
-    DEFAULT_MODEL = "gpt-5-codex"
+    DEFAULT_MODEL = "codex-5.1-max"
     DEFAULT_AUTO_INSTRUCTION = """You are an AI coding assistant. Follow the instructions provided and generate high-quality code."""
 
+    # Model shorthand mappings (colon-prefixed names expand to full model IDs)
+    MODEL_SHORTHANDS = {
+        ":codex": "codex-5.1-codex-max",
+        ":gpt-5": "gpt-5",
+        ":mini": "gpt-5-codex-mini",
+    }
+
     def __init__(self):
         self.model_name = self.DEFAULT_MODEL
         self.auto_instruction = self.DEFAULT_AUTO_INSTRUCTION
@@ -26,6 +35,17 @@ class CodexService:
         self.additional_args: List[str] = []
         self.verbose = False
 
+    def expand_model_shorthand(self, model: str) -> str:
+        """
+        Expand model shorthand names to full model IDs.
+
+        If the model starts with ':', look it up in MODEL_SHORTHANDS.
+        Otherwise, return the model name as-is.
+        """
+        if model.startswith(":"):
+            return self.MODEL_SHORTHANDS.get(model, model)
+        return model
+
     def check_codex_installed(self) -> bool:
         """Check if codex CLI is installed and available"""
         try:
@@ -49,6 +69,13 @@ Examples:
   %(prog)s -p "Write a hello world function"
   %(prog)s -pp prompt.txt --cd /path/to/project
   %(prog)s -p "Add tests" -m gpt-4 -c custom_arg=value
+  %(prog)s -p "Optimize code" -m :codex  # uses codex-5.1-codex-max
+
+Environment Variables:
+  CODEX_MODEL                Model name (supports shorthand, default: codex-5.1-max)
+  CODEX_HIDE_STREAM_TYPES    Comma-separated list of streaming msg types to hide
+                             Default: turn_diff,token_count,exec_command_output_delta
+  JUNO_CODE_HIDE_STREAM_TYPES Same as CODEX_HIDE_STREAM_TYPES (alias)
             """
         )
 
@@ -75,8 +102,8 @@ Examples:
         parser.add_argument(
             "-m", "--model",
             type=str,
-            default=self.DEFAULT_MODEL,
-            help=f"Model name. Default: {self.DEFAULT_MODEL}"
+            default=os.environ.get("CODEX_MODEL", self.DEFAULT_MODEL),
+            help=f"Model name. Supports shorthand (e.g., ':codex', ':gpt-5', ':mini') or full model ID. Default: {self.DEFAULT_MODEL} (env: CODEX_MODEL)"
         )
 
         parser.add_argument(
@@ -163,34 +190,242 @@ Examples:
 
         return cmd
 
+    def _format_msg_pretty(self, obj: dict) -> 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_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)
+
+        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)
+
+            # agent_reasoning → show 'text' human-readable
+            if msg_type == "agent_reasoning":
+                content = msg.get("text", "")
+                header = {"type": msg_type, "datetime": now}
+                if "\n" in content:
+                    return json.dumps(header, ensure_ascii=False) + "\ntext:\n" + content
+                header["text"] = content
+                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", "")
+                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)
+
+            return None
+        except Exception:
+            return None
+
     def run_codex(self, cmd: List[str], verbose: bool = False) -> int:
-        """Execute the codex command and stream output"""
+        """Execute the codex command and stream output with filtering and pretty-printing
+
+        Robustness improvements:
+        - Attempts to parse JSON even if the line has extra prefix/suffix noise
+        - Falls back to string suppression for known noisy types if JSON parsing fails
+        - Never emits token_count or exec_command_output_delta even on malformed lines
+        """
         if verbose:
             print(f"Executing: {' '.join(cmd)}", file=sys.stderr)
             print("-" * 80, file=sys.stderr)
 
+        # Resolve hidden stream types (ENV configurable)
+        default_hidden = {"turn_diff", "token_count", "exec_command_output_delta"}
+        env_hide_1 = os.environ.get("CODEX_HIDE_STREAM_TYPES", "")
+        env_hide_2 = os.environ.get("JUNO_CODE_HIDE_STREAM_TYPES", "")
+        hide_types = set(default_hidden)
+        for env_val in (env_hide_1, env_hide_2):
+            if env_val:
+                parts = [p.strip() for p in env_val.split(",") if p.strip()]
+                hide_types.update(parts)
+
+        # We fully suppress all token_count events (do not emit even at end)
+        last_token_count = None
+
         try:
             # Run the command and stream output
-            # Use line buffering (bufsize=1) to ensure each JSON line is output immediately
             process = subprocess.Popen(
                 cmd,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
                 text=True,
-                bufsize=1,  # Line buffering for immediate output
+                bufsize=1,
                 universal_newlines=True
             )
 
-            # Stream stdout line by line
-            # Codex outputs text format by default (not JSON), so we just pass it through
             if process.stdout:
-                for line in process.stdout:
-                    # Output text as-is with immediate flush for real-time streaming
-                    print(line, end='', flush=True)
-
-            # Wait for process to complete
+                for raw_line in process.stdout:
+                    line = raw_line.rstrip("\n")
+                    if not line:
+                        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)
+                            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:
+                                    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
+                        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)
+
+            # Wait for process completion
             process.wait()
 
+            # Do not emit token_count summary; fully suppressed per user feedback
+
             # Print stderr if there were errors
             if process.stderr and process.returncode != 0:
                 stderr_output = process.stderr.read()
@@ -201,9 +436,11 @@ Examples:
 
         except KeyboardInterrupt:
             print("\nInterrupted by user", file=sys.stderr)
-            if process:
+            try:
                 process.terminate()
                 process.wait()
+            except Exception:
+                pass
             return 130
         except Exception as e:
             print(f"Error executing codex: {e}", file=sys.stderr)
@@ -237,7 +474,8 @@ Examples:
 
         # Set configuration from arguments
         self.project_path = os.path.abspath(args.cd)
-        self.model_name = args.model
+        # Expand model shorthand
+        self.model_name = self.expand_model_shorthand(args.model)
         self.auto_instruction = args.auto_instruction
 
         # Get prompt from file or argument

package/package.json

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