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

{aria_code-0.92.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.92.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.92.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.92.0 → aria_code-0.94.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aria-code"
-version = "0.92.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.92.0 → aria_code-0.94.0}/src/aria_code/_version.py

@@ -17,4 +17,4 @@ from __future__ import annotations
 
 __all__ = ["__version__"]
 
-__version__ = "0.92.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.92.0 → aria_code-0.94.0}/src/aria_code/apps/cli/local_tool_schemas.py

@@ -204,13 +204,16 @@ def build_local_tool_schemas(
         "type": "function",
         "function": {
             "name": "run_command",
-            "description": "Run a shell command. Use for: git, pip, python, pytest, ls, etc.",
+            "description": "Run a shell command. Use for: git, pip, python, pytest, ls, etc. For a server, watcher or anything that keeps running, set background=true.",
             "parameters": {
                 "type": "object",
                 "properties": {
                     "command": {"type": "string", "description": "Shell command to run"},
                     "cwd": {"type": "string", "description": "Working directory (optional)"},
                     "timeout": {"type": "integer", "description": "Timeout in seconds (max 300, default 120). Use 180+ for data-heavy scripts."},
+                    "background": {"type": "boolean", "description": "Start a long-running command (dev server, watcher, interactive program) and return at once with a process_id; use the process tool to read its output, send input or stop it"},
+                    "wait_seconds": {"type": "number", "description": "With background: how long to wait for first output (default 3, max 30)"},
+                    "until": {"type": "string", "description": "With background: return as soon as this regex appears in the output, e.g. 'Listening on'"},
                     "sandbox": {"type": "boolean", "description": "Set to true to securely execute the command inside an isolated Docker container instead of the host machine. Mandatory for running third-party or untested code."}
                 },
                 "required": ["command"],
@@ -534,4 +537,5 @@ def build_local_tool_schemas(
             }
         }
     },
+        __import__("aria_code.runtime.processes", fromlist=["PROCESS_SCHEMA"]).PROCESS_SCHEMA,
     ]

{aria_code-0.92.0 → aria_code-0.94.0}/src/aria_code/apps/cli/providers/llm/ollama_stream.py

@@ -413,7 +413,7 @@ async def stream_ollama(ollama_url: str, message: str, history: list,
     _CU_TOOL_NAMES = {"browser_navigate", "browser_screenshot",
                       "computer_screenshot", "computer_action"}
     _CODE_TOOL_NAMES = {"read_file", "write_file", "edit_file", "list_files",
-                        "search_code", "run_command", "github",
+                        "search_code", "run_command", "process", "github",
                         "glob", "notebook_read", "notebook_edit"}
     _FINANCE_TOOL_NAMES = {
         "get_market_data", "get_market_history", "calculate_factors",

{aria_code-0.92.0 → aria_code-0.94.0}/src/aria_code/apps/cli/tools/system_tools.py

@@ -198,6 +198,9 @@ def tool_run_command(
                     argv = None
 
         sandbox = params.get("sandbox", False)
+        if params.get("background"):
+            return _start_background(params, command, argv, use_shell, cwd, mode, network,
+                                     docker=bool(sandbox), console=console, has_rich=has_rich)
         if sandbox:
             try:
                 from aria_code.apps.cli.sandbox import run_in_docker_sandbox
@@ -272,6 +275,32 @@ def tool_run_command(
         return {"success": False, "error": str(e)}
 
 
+def _start_background(params, command, argv, use_shell, cwd, mode, network, *, docker,
+                      console, has_rich) -> dict:
+    """Start a long-running command (server, watcher) and return its first output."""
+    if docker:
+        return {"success": False, "error": "background=true is not available with the Docker sandbox."}
+    from aria_code.runtime import processes
+    from aria_code.safety import sandbox as _os_sandbox
+
+    target = argv if (argv and not use_shell) else command
+    confined = _os_sandbox.wrap(target, use_shell=use_shell, mode=mode, network=network, cwd=cwd,
+                                setting=params.get("os_sandbox"))
+    result = processes.start(confined or target, shell=use_shell and not confined, cwd=cwd,
+                             label=command, wait=min(float(params.get("wait_seconds", 3) or 0), 30.0),
+                             until=params.get("until"))
+    if result.get("success"):
+        data = result["data"]
+        state = "running" if data["running"] else f"exited {data['exit_code']}"
+        _cprint(f"  [dim]⎿ background {data['process_id']} · {state}[/dim]",
+                console=console, has_rich=has_rich)
+        if confined and not data["running"]:
+            hint = _os_sandbox.denial_hint(data.get("output", ""), mode=mode, network=network)
+            if hint:
+                data["hint"] = hint
+    return result
+
+
 _PIP_NAMES = {
     "sklearn": "scikit-learn", "cv2": "opencv-python", "bs4": "beautifulsoup4",
     "PIL": "Pillow", "yaml": "PyYAML",

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

@@ -1034,6 +1034,8 @@ from aria_code.apps.cli.tool_executor import *
 # Populated in place — the container is owned by apps/cli/tool_registry.py.
 # Rebinding it here instead would leave every reader over there with an
 # empty registry and no error.
+from aria_code.runtime.processes import tool_process as _tool_process
+
 LOCAL_TOOLS.update({
     # ── Core file tools ──────────────────────────────────────────────────────
     "read_file":      (_tool_read_file,      "Read a file's contents"),
@@ -1047,6 +1049,7 @@ LOCAL_TOOLS.update({
     "search_code":    (_tool_search_code,    "Search for patterns in code (grep)"),
     "search":         (_tool_search_code,    "Search for patterns in code (alias for search_code)"),
     "run_command":    (_tool_run_command,    "Execute a shell command"),
+    "process":        (_tool_process,        "Read, write to or stop a background command"),
     # These four had schemas in local_tool_schemas.py and no handler here,
     # which is the mirror of the earlier defect: a schema with nothing
     # behind it offers the model a tool that cannot run.
@@ -2694,6 +2697,7 @@ _TOOL_ACTION_LABELS: dict = {
     "list_files":                "listing files",
     "search_code":               "searching codebase",
     "run_command":               "executing command",
+    "process":                   "checking background process",
     # Macro / realty
     "get_macro_data":            "loading macro indicators",
     "get_house_price_index":     "loading house price data",
@@ -6464,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")
@@ -6479,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)
@@ -6487,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
@@ -6519,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):
@@ -6530,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)
@@ -6583,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 [])
@@ -6613,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
@@ -6624,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":
@@ -6636,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)."""
@@ -6711,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")
@@ -6737,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) ──────────
@@ -6837,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.92.0 → aria_code-0.94.0}/src/aria_code/packages/aria_tools/registry.py

@@ -20,6 +20,7 @@ _PERMISSION_BY_TOOL = {
     "edit_file": [PermissionLevel.WORKSPACE_WRITE],
     "notebook_edit": [PermissionLevel.WORKSPACE_WRITE],
     "run_command": [PermissionLevel.WORKSPACE_WRITE],
+    "process": [PermissionLevel.WORKSPACE_WRITE],
     "web_fetch": [PermissionLevel.NETWORK],
     "github": [PermissionLevel.NETWORK],
     "get_market_data": [PermissionLevel.NETWORK],
@@ -96,7 +97,7 @@ def _capabilities_for_tool(name: str) -> List[str]:
         return ["workspace.read"]
     if name in ("write_file", "edit_file", "notebook_edit"):
         return ["workspace.write"]
-    if name == "run_command":
+    if name in ("run_command", "process"):
         return ["shell"]
     if name in ("web_fetch", "github"):
         return ["network"]

{aria_code-0.92.0 → aria_code-0.94.0}/src/aria_code/runtime/agent_loop.py

@@ -19,7 +19,7 @@ from .tool_executor import ToolExecutor
 from .budget import BudgetTracker
 
 
-DEFAULT_SERIAL_TOOLS = {"write_file", "edit_file", "multi_edit", "run_command"}
+DEFAULT_SERIAL_TOOLS = {"write_file", "edit_file", "multi_edit", "run_command", "process"}
 
 # Phrases the model uses to signal task completion
 _DONE_PHRASES = frozenset([