aria-code 0.93.0__tar.gz → 0.94.0__tar.gz

{aria_code-0.93.0/src/aria_code.egg-info → aria_code-0.94.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.93.0
+Version: 0.94.0
 Summary: Open-source AI agent for coding, financial analysis and logistics operations: numbers you can check, client data kept apart, actions a person approves
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/artheras/aria-code
@@ -251,6 +251,12 @@ aria-code -p "Inspect this project, fix the failing tests, run them, and summari
 
 Aria may request approval before editing files or running commands, according to the configured permission mode. Review changes and test results before committing them.
 
+In a script or CI job, `--json` prints one JSON result and `--format jsonl` prints one JSON event per line as the turn runs (`turn.started`, `tool.started`, `tool.completed`, `turn.completed`). Only JSON goes to stdout, and a failed turn exits 1. With no one there to approve, pass `--allow-tools edit_file,run_command` for the tools the job may use.
+
+```bash
+aria-code -p "Fix the failing tests and run them" --format jsonl --allow-tools edit_file,run_command > events.jsonl
+```
+
 ## Models and accounts
 
 | Route | What it needs |

{aria_code-0.93.0 → aria_code-0.94.0}/README.md

@@ -95,6 +95,12 @@ aria-code -p "Inspect this project, fix the failing tests, run them, and summari
 
 Aria may request approval before editing files or running commands, according to the configured permission mode. Review changes and test results before committing them.
 
+In a script or CI job, `--json` prints one JSON result and `--format jsonl` prints one JSON event per line as the turn runs (`turn.started`, `tool.started`, `tool.completed`, `turn.completed`). Only JSON goes to stdout, and a failed turn exits 1. With no one there to approve, pass `--allow-tools edit_file,run_command` for the tools the job may use.
+
+```bash
+aria-code -p "Fix the failing tests and run them" --format jsonl --allow-tools edit_file,run_command > events.jsonl
+```
+
 ## Models and accounts
 
 | Route | What it needs |

{aria_code-0.93.0 → aria_code-0.94.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aria-code"
-version = "0.93.0"
+version = "0.94.0"
 description = "Open-source AI agent for coding, financial analysis and logistics operations: numbers you can check, client data kept apart, actions a person approves"
 readme = "README.md"
 license = { text = "Apache-2.0" }

{aria_code-0.93.0 → aria_code-0.94.0}/src/aria_code/_version.py

@@ -17,4 +17,4 @@ from __future__ import annotations
 
 __all__ = ["__version__"]
 
-__version__ = "0.93.0"
+__version__ = "0.94.0"

aria_code-0.94.0/src/aria_code/apps/cli/exec_events.py

@@ -0,0 +1,83 @@
+"""JSON events for `aria-code -p … --format jsonl`, one per line, as the turn runs.
+
+`-p --json` printed one document at the end, so a CI job saw nothing until the
+turn was over and could not tell which tool ran, how long it took or where
+it failed. With jsonl each step is a line on stdout as it happens:
+
+    {"type": "turn.started", "prompt": "...", "model": "...", "ts": ...}
+    {"type": "tool.started", "tool": "run_command", "params": {...}, "ts": ...}
+    {"type": "tool.completed", "tool": "run_command", "success": true, "elapsed_s": 1.2,
+     "error": "", "ts": ...}
+    {"type": "turn.completed", "success": true, "response": "...", "tools_used": [...], ...}
+
+Tool parameters are shortened and secrets masked: a written file's contents
+or a command's token have no place in a CI log.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+from typing import Any, TextIO
+
+from aria_code.apps.cli.runtime_consumer import MEASURED_ELAPSED_KEY, _redact_activity_text
+
+PARAM_CHARS = 300
+
+
+def json_safe(value: Any) -> Any:
+    """``value`` with anything json cannot write turned into text."""
+    return json.loads(json.dumps(value, ensure_ascii=False, default=str))
+
+
+def _param_view(params: dict) -> dict:
+    view = {}
+    for key, value in (params or {}).items():
+        if str(key).startswith("_"):
+            continue                       # execution context the host added
+        if isinstance(value, str):
+            # A file's contents is not a parameter worth a log line; its size is.
+            view[key] = (f"<{len(value)} chars>" if len(value) > 2000
+                         else _redact_activity_text(value, limit=PARAM_CHARS))
+        elif isinstance(value, (int, float, bool)) or value is None:
+            view[key] = value
+        else:
+            view[key] = _redact_activity_text(json.dumps(value, ensure_ascii=False, default=str),
+                                              limit=PARAM_CHARS)
+    return view
+
+
+class ExecEvents:
+    """Writes events to ``out``; does nothing when ``out`` is None."""
+
+    def __init__(self, out: TextIO | None):
+        self.out = out
+
+    def emit(self, event_type: str, **fields: Any) -> None:
+        if self.out is None:
+            return
+        record = {"type": event_type, **json_safe(fields), "ts": round(time.time(), 3)}
+        try:
+            self.out.write(json.dumps(record, ensure_ascii=False) + "\n")
+            self.out.flush()
+        except (OSError, ValueError):
+            self.out = None                # the reader went away; stop writing
+
+    def tool_started(self, tool: str, params: dict) -> None:
+        self.emit("tool.started", tool=tool, params=_param_view(params))
+
+    def tool_completed(self, tool: str, result: dict) -> None:
+        result = result if isinstance(result, dict) else {"success": bool(result)}
+        fields: dict[str, Any] = {"tool": tool, "success": bool(result.get("success", True))}
+        if isinstance(result.get(MEASURED_ELAPSED_KEY), (int, float)):
+            fields["elapsed_s"] = round(float(result[MEASURED_ELAPSED_KEY]), 3)
+        if result.get("error"):
+            fields["error"] = _redact_activity_text(result["error"], limit=PARAM_CHARS)
+        data = result.get("data") if isinstance(result.get("data"), dict) else {}
+        for key in ("exit_code", "path", "process_id", "change_id"):
+            if key in data:
+                fields[key] = data[key]
+        self.emit("tool.completed", **fields)
+
+
+__all__ = ["ExecEvents", "json_safe"]

{aria_code-0.93.0 → aria_code-0.94.0}/src/aria_code/aria_cli.py

@@ -6468,8 +6468,23 @@ class ArtheraTerminal:
         save_config(self.config)
 
     async def run_prompt(self, prompt: str, json_output: bool = False,
-                         fmt: str = "table", output_file: str = None, quiet: bool = False):
-        """Run a single prompt (non-interactive / pipe mode)."""
+                         fmt: str = "table", output_file: str = None, quiet: bool = False,
+                         machine_out=None):
+        """Run a single prompt (non-interactive / pipe mode).
+
+        ``machine_out`` is the real stdout when the output is JSON (sys.stdout
+        then points at stderr). With fmt "jsonl" each step is written there as
+        one JSON event per line as it happens.
+        """
+        from aria_code.apps.cli.exec_events import ExecEvents, json_safe
+        events = ExecEvents(machine_out if fmt == "jsonl" else None)
+        events.emit("turn.started", prompt=prompt, model=self.config.get("model", ""))
+        result = await self._run_prompt_turn(prompt, quiet=quiet, events=events)
+        self._finish_prompt(result, json_output=json_output, fmt=fmt, output_file=output_file,
+                            quiet=quiet, machine_out=machine_out, events=events)
+
+    async def _run_prompt_turn(self, prompt: str, *, quiet: bool, events) -> dict:
+        """The work of run_prompt: a slash command, a deterministic answer, or an agent turn."""
         model = self.config.get("model", "qwen2.5:7b")
         thinking_mode = self.config.get("thinking_mode", "auto")
         auth_token = self.config.get("auth_token")
@@ -6483,7 +6498,7 @@ class ArtheraTerminal:
         if self.commands.is_command(_stripped_prompt):
             self._maybe_show_intent_preflight(_stripped_prompt, quiet=quiet)
             await self.commands.execute(_stripped_prompt)
-            return
+            return {"success": True, "command": _stripped_prompt.split()[0], "response": ""}
 
         _reference_context = ""
         _reference_service = getattr(self, "_reference_service", None)
@@ -6491,7 +6506,7 @@ class ArtheraTerminal:
             _prepared_references = _reference_service.prepare(prompt)
             if _prepared_references.errors:
                 self._print_reference_errors(_prepared_references)
-                return
+                return {"success": False, "response": "", "error": "unresolved @ reference"}
             if _prepared_references.references:
                 self._print_reference_summary(_prepared_references)
                 prompt = _prepared_references.expanded_text
@@ -6523,7 +6538,7 @@ class ArtheraTerminal:
             await self.commands.cmd_broker("guide")
             await self.commands.cmd_broker("services")
             await self.commands.cmd_packages("services")
-            return
+            return {"success": True, "command": "/broker guide", "response": ""}
 
         # ── Broker setup intent: intercept before LLM / deterministic routing ──
         if _is_broker_setup_intent(prompt):
@@ -6534,11 +6549,11 @@ class ArtheraTerminal:
                 _label_p = f"  正在启动{_display_p}配置向导…" if _display_p else "  正在启动券商配置向导…"
                 console.print(f"\n[bold]Aria[/bold]  [dim]{_label_p}[/dim]\n")
             await self.commands._cmd_broker_add(_btype_p)
-            return
+            return {"success": True, "command": "/broker add", "response": ""}
 
         # ── Football prediction intercept → built-in Poisson handler ──────────
         if await self._try_football_nl_intercept(prompt):
-            return
+            return {"success": True, "command": "football", "response": ""}
 
         deterministic = _run_deterministic_chain(
             prompt, model_has_tools=_model_has_tools_p)
@@ -6587,6 +6602,8 @@ class ArtheraTerminal:
                         frozenset() if _auto_approve_session
                         else frozenset(_CONFIRM_TOOLS) - _session_always_allow
                     ),
+                    on_tool_call=events.tool_started,
+                    on_tool_result=events.tool_completed,
                     return_result=True,
                 )
                 _tools_used = list(getattr(_turn.final, "tools", []) or [])
@@ -6617,6 +6634,13 @@ class ArtheraTerminal:
                     except Exception:
                         pass
 
+        return result
+
+    def _finish_prompt(self, result: dict, *, json_output: bool, fmt: str, output_file,
+                       quiet: bool, machine_out, events) -> None:
+        """Print or save run_prompt's result, and exit 1 if it failed."""
+        from aria_code.apps.cli.exec_events import json_safe
+        result = result or {"success": False, "response": "", "error": "no result"}
         # The agent loop executes tools now, so there is nothing left over to
         # run here — only stream_provider_result ever populated
         # tool_calls_pending, and the deterministic chain never does. Keeping
@@ -6628,10 +6652,16 @@ class ArtheraTerminal:
         # and exit 0.
         _acceptance = (result or {}).get("acceptance") or {}
         if _acceptance.get("verified") is False and not quiet:
-            print(f"⚠ 验收未通过: {_acceptance.get('headline', '')}", file=sys.stderr)
-
-        if json_output or fmt == "json":
-            content = json.dumps(result, ensure_ascii=False, indent=2)
+            _zh = str(self.config.get("ui_lang", "en")).lower().startswith("zh")
+            print(f"⚠ {'验收未通过' if _zh else 'Checks failed'}: {_acceptance.get('headline', '')}",
+                  file=sys.stderr)
+
+        events.emit("turn.completed", **json_safe(result))
+        out = machine_out or sys.stdout
+        if fmt == "jsonl":
+            content = None              # the events were the output
+        elif json_output or fmt == "json":
+            content = json.dumps(json_safe(result), ensure_ascii=False, indent=2)
         elif fmt == "csv":
             content = f"role,content\nassistant,\"{result.get('response', '').replace(chr(34), chr(34)+chr(34))}\""
         elif fmt == "md":
@@ -6640,24 +6670,28 @@ class ArtheraTerminal:
             content = result.get("response", "") if result.get("success") else f"Error: {result.get('error', 'Unknown')}"
 
         # Output routing
-        if output_file:
+        if content is None or (fmt == "table" and not json_output and result.get("command") and not content):
+            pass                        # jsonl, or a command that printed its own output
+        elif output_file:
             with open(output_file, "w") as f:
                 f.write(content)
             if not quiet:
                 console.print(f"[green]Saved to {output_file}[/green]" if HAS_RICH
                               else f"Saved: {output_file}")
+        elif not result.get("success") and fmt == "table" and not json_output:
+            print(f"Error: {result.get('error', 'Unknown')}", file=sys.stderr)
+        # In default (table) format: render with Rich Markdown when output is
+        # a terminal.  This gives properly formatted headings, bold, and tables
+        # in interactive use.  When piped/redirected, fall back to plain text
+        # for scripting compatibility.
+        elif HAS_RICH and fmt == "table" and not json_output and sys.stdout.isatty() and result.get("success"):
+            console.print(make_markdown(_strip_latex(content)))
         else:
-            if not result.get("success") and fmt == "table":
-                print(f"Error: {result.get('error', 'Unknown')}", file=sys.stderr)
-                sys.exit(1)
-            # In default (table) format: render with Rich Markdown when output is
-            # a terminal.  This gives properly formatted headings, bold, and tables
-            # in interactive use.  When piped/redirected, fall back to plain text
-            # for scripting compatibility.
-            if HAS_RICH and fmt == "table" and sys.stdout.isatty() and result.get("success"):
-                console.print(make_markdown(_strip_latex(content)))
-            else:
-                print(content)
+            print(content, file=out, flush=True)
+        # A failed turn exits 1 in every format. Only table did; with --json a
+        # script got exit 0 and had to read the body to learn it had failed.
+        if not result.get("success"):
+            sys.exit(1)
 
     async def run_watch(self, command_fn, interval: int, cmd_args: str):
         """Run a command repeatedly with interval (like Unix watch)."""
@@ -6715,8 +6749,9 @@ Examples:
     parser.add_argument("--model", help="AI model: sonata|prelude|sonata-thinking|prelude-thinking or full Ollama ID")
     parser.add_argument("--thinking", action="store_true", help="Enable thinking mode")
     parser.add_argument("--json", action="store_true", help="JSON output (with -p)")
-    parser.add_argument("--format", choices=["table", "json", "csv", "md"], default="table",
-                        help="Output format (default: table)")
+    parser.add_argument("--format", choices=["table", "json", "jsonl", "csv", "md"], default="table",
+                        help="Output format (default: table). With -p, jsonl streams one JSON event "
+                             "per line (turn.started, tool.started, tool.completed, turn.completed)")
     parser.add_argument("--output", "-o", help="Save output to file")
     parser.add_argument("--quiet", "-q", action="store_true", help="Quiet mode (data only, no UI)")
     parser.add_argument("--watch", "-w", type=int, metavar="SECS", help="Refresh interval in seconds")
@@ -6741,6 +6776,15 @@ Examples:
 
     args = parser.parse_args()
 
+    # Machine-readable -p output: stdout carries only JSON. Everything else —
+    # banners, tool steps, warnings, anything a tool prints — goes to stderr.
+    # It all went to stdout, ahead of the JSON, so `aria-code -p … --json | jq`
+    # could not parse what it was given.
+    _machine_out = None
+    if args.prompt and (args.json or args.format in ("json", "jsonl")):
+        _machine_out = sys.stdout
+        sys.stdout = sys.stderr
+
     config = load_config()
 
     # ── Start background update check (non-blocking, daemon thread) ──────────
@@ -6841,11 +6885,11 @@ Examples:
     if args.prompt:
         if watch_interval:
             await terminal.run_watch(
-                lambda _: terminal.run_prompt(args.prompt, json_output=args.json, fmt=fmt, output_file=output_file, quiet=quiet),
+                lambda _: terminal.run_prompt(args.prompt, json_output=args.json, fmt=fmt, output_file=output_file, quiet=quiet, machine_out=_machine_out),
                 watch_interval, ""
             )
         else:
-            await terminal.run_prompt(args.prompt, json_output=args.json, fmt=fmt, output_file=output_file, quiet=quiet)
+            await terminal.run_prompt(args.prompt, json_output=args.json, fmt=fmt, output_file=output_file, quiet=quiet, machine_out=_machine_out)
         return
 
     # Mode 2: Direct command

{aria_code-0.93.0 → aria_code-0.94.0/src/aria_code.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.93.0
+Version: 0.94.0
 Summary: Open-source AI agent for coding, financial analysis and logistics operations: numbers you can check, client data kept apart, actions a person approves
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/artheras/aria-code
@@ -251,6 +251,12 @@ aria-code -p "Inspect this project, fix the failing tests, run them, and summari
 
 Aria may request approval before editing files or running commands, according to the configured permission mode. Review changes and test results before committing them.
 
+In a script or CI job, `--json` prints one JSON result and `--format jsonl` prints one JSON event per line as the turn runs (`turn.started`, `tool.started`, `tool.completed`, `turn.completed`). Only JSON goes to stdout, and a failed turn exits 1. With no one there to approve, pass `--allow-tools edit_file,run_command` for the tools the job may use.
+
+```bash
+aria-code -p "Fix the failing tests and run them" --format jsonl --allow-tools edit_file,run_command > events.jsonl
+```
+
 ## Models and accounts
 
 | Route | What it needs |

{aria_code-0.93.0 → aria_code-0.94.0}/src/aria_code.egg-info/SOURCES.txt

@@ -162,6 +162,7 @@ src/aria_code/apps/cli/constants.py
 src/aria_code/apps/cli/context.py
 src/aria_code/apps/cli/deterministic.py
 src/aria_code/apps/cli/direct.py
+src/aria_code/apps/cli/exec_events.py
 src/aria_code/apps/cli/finance_service_catalog.py
 src/aria_code/apps/cli/football_reports.py
 src/aria_code/apps/cli/github_app_auth.py
@@ -575,6 +576,7 @@ tests/test_enterprise_tool_honesty.py
 tests/test_env_switch_docs.py
 tests/test_evals_harness.py
 tests/test_event_import_roots.py
+tests/test_exec_events.py
 tests/test_extended_tools.py
 tests/test_feishu_swarm_config.py
 tests/test_file_links.py

aria_code-0.94.0/tests/test_exec_events.py

@@ -0,0 +1,92 @@
+"""`aria-code -p` for scripts and CI: JSON only on stdout, events as they happen, exit 1 on failure.
+
+With --json, tool steps and warnings went to stdout ahead of the JSON, so
+`aria-code -p … --json | jq` could not parse it; a failed turn exited 0 unless
+the format was table; and nothing was visible until the turn ended.
+"""
+
+from __future__ import annotations
+
+import io
+import json
+import subprocess
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from aria_code.apps.cli.exec_events import ExecEvents, json_safe
+
+
+def test_events_are_one_json_object_per_line():
+    out = io.StringIO()
+    events = ExecEvents(out)
+    events.emit("turn.started", prompt="hi", model="m")
+    events.tool_started("run_command", {"command": "curl -H 'Authorization: Bearer abc123def456' x",
+                                        "_run_id": "r1"})
+    events.tool_completed("run_command", {"success": False, "error": "boom",
+                                          "data": {"exit_code": 2}, "_elapsed_s": 1.23456})
+    lines = [json.loads(line) for line in out.getvalue().splitlines()]
+    assert [e["type"] for e in lines] == ["turn.started", "tool.started", "tool.completed"]
+    assert "abc123def456" not in lines[1]["params"]["command"]
+    assert "_run_id" not in lines[1]["params"]
+    assert lines[2] | {"ts": 0} == {"type": "tool.completed", "tool": "run_command", "success": False,
+                                     "elapsed_s": 1.235, "error": "boom", "exit_code": 2, "ts": 0}
+
+
+def test_a_file_body_is_reported_by_size():
+    out = io.StringIO()
+    ExecEvents(out).tool_started("write_file", {"path": "a.py", "content": "x" * 5000})
+    assert json.loads(out.getvalue())["params"] == {"path": "a.py", "content": "<5000 chars>"}
+
+
+def test_no_stream_writes_nothing_and_odd_values_still_serialise():
+    ExecEvents(None).emit("turn.started", prompt="x")
+    assert json_safe({"p": Path("/a"), "s": {1}}) == {"p": "/a", "s": "{1}"}
+
+
+class _Terminal:
+    """Just enough of ArtheraTerminal for _finish_prompt."""
+
+    config = {"ui_lang": "en"}
+
+    def __init__(self):
+        from aria_code.aria_cli import ArtheraTerminal
+        self._finish = ArtheraTerminal._finish_prompt.__get__(self)
+
+
+@pytest.mark.parametrize("fmt, json_output", [("table", True), ("json", False), ("jsonl", False)])
+def test_a_failed_turn_exits_1_in_every_machine_format(fmt, json_output, capsys):
+    out = io.StringIO()
+    events = ExecEvents(out if fmt == "jsonl" else None)
+    with pytest.raises(SystemExit) as exited:
+        _Terminal()._finish({"success": False, "response": "", "error": "no model"},
+                            json_output=json_output, fmt=fmt, output_file=None, quiet=True,
+                            machine_out=out, events=events)
+    assert exited.value.code == 1
+    body = out.getvalue()
+    parsed = [json.loads(l) for l in body.splitlines()] if fmt == "jsonl" else [json.loads(body)]
+    assert parsed[-1]["success"] is False and parsed[-1]["error"] == "no model"
+
+
+def test_a_successful_json_turn_writes_only_json(capsys):
+    out = io.StringIO()
+    _Terminal()._finish({"success": True, "response": "done", "tools_used": ["edit_file"]},
+                        json_output=True, fmt="table", output_file=None, quiet=True,
+                        machine_out=out, events=ExecEvents(None))
+    assert json.loads(out.getvalue())["response"] == "done"
+    assert capsys.readouterr().out == ""
+
+
+def test_the_cli_keeps_stdout_for_json(tmp_path):
+    """A slash command end to end: its own output goes to stderr, the events to stdout."""
+    aria = Path(sys.executable).parent / "aria-code"
+    if not aria.exists():
+        pytest.skip("aria-code entry point not installed in this environment")
+    done = subprocess.run([str(aria), "-p", "/help", "--format", "jsonl"], cwd=tmp_path,
+                          capture_output=True, text=True, timeout=120, stdin=subprocess.DEVNULL)
+    events = [json.loads(line) for line in done.stdout.splitlines() if line.strip()]
+    assert [e["type"] for e in events] == ["turn.started", "turn.completed"]
+    assert events[-1]["success"] is True and done.returncode == 0
+    assert done.stderr.strip()          # /help printed, just not on stdout

{aria_code-0.93.0 → aria_code-0.94.0}/tests/test_headless_is_agentic.py

@@ -16,7 +16,9 @@ class HeadlessPathTests(unittest.TestCase):
     def _source(self) -> str:
         import aria_code.aria_cli as cli
 
-        return inspect.getsource(cli.ArtheraTerminal.run_prompt)
+        # run_prompt hands the turn to _run_prompt_turn and the output to _finish_prompt.
+        return "".join(inspect.getsource(getattr(cli.ArtheraTerminal, name))
+                       for name in ("run_prompt", "_run_prompt_turn", "_finish_prompt"))
 
     def test_run_prompt_goes_through_the_shared_runtime(self):
         self.assertIn("run_chat_via_runtime", self._source())
@@ -80,7 +82,9 @@ class EmptyClosingMessageTests(unittest.TestCase):
     def _source(self) -> str:
         import aria_code.aria_cli as cli
 
-        return inspect.getsource(cli.ArtheraTerminal.run_prompt)
+        # run_prompt hands the turn to _run_prompt_turn and the output to _finish_prompt.
+        return "".join(inspect.getsource(getattr(cli.ArtheraTerminal, name))
+                       for name in ("run_prompt", "_run_prompt_turn", "_finish_prompt"))
 
     def test_empty_response_after_tool_use_is_not_an_error(self):
         # Observed for real: the agent edited the file correctly, produced no