nooa-cli 0.0.9__tar.gz → 0.0.11__tar.gz

{nooa_cli-0.0.9 → nooa_cli-0.0.11}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: nooa-cli
-Version: 0.0.9
+Version: 0.0.11
 Summary: CLI for nemo-oo-agents (`nooa` command: eval runner, trace viewer, config)
 Project-URL: Homepage, https://github.com/NVIDIA-NeMo/labs-OO-Agents
 Project-URL: Repository, https://github.com/NVIDIA-NeMo/labs-OO-Agents
@@ -9,6 +9,7 @@ License: Apache-2.0
 Requires-Python: <3.14,>=3.12
 Requires-Dist: click>=8.1.0
 Requires-Dist: nooa
+Requires-Dist: prompt-toolkit>=3.0.52
 Requires-Dist: pyyaml>=6.0
 Provides-Extra: ast
 Requires-Dist: tree-sitter-go>=0.23.0; extra == 'ast'
@@ -40,13 +41,25 @@ uv add "nooa-cli[datascience]"
 
 `nooa-cli` automatically pulls in matching `nemo-oo-agents` (the core framework). The `[datascience]` extra adds libraries the LLM can use in REPL-generated code.
 
+> **Windows:** use [WSL 2](https://learn.microsoft.com/windows/wsl/install). Native Windows is not supported; see the [main README](https://github.com/NVIDIA-NeMo/labs-OO-Agents#installation).
+
 ## Usage
 
 ```bash
 nooa --help
-nooa start-dev            # launch the trace viewer
-nooa eval ...             # eval pipeline runner
-nooa traces ...           # inspect/manage trace files
+nooa start-dev        # launch the trace viewer
+nooa eval ...         # eval pipeline runner
+nooa traces ...       # inspect/manage trace files
+```
+
+Install the separate `nooa-acp` package to add the `nooa acp` plugin command and
+run the NOOA coding agent from an ACP-compatible client:
+
+```bash
+uv add nooa-acp
+export NOOA_MODEL=nvidia_nim/nvidia/nemotron-3-super-120b-a12b
+export NVIDIA_API_KEY=nvapi-...
+uv run nooa-acp
 ```
 
 See the main repo [README](https://github.com/NVIDIA-NeMo/labs-OO-Agents/blob/main/README.md) for the framework documentation.

{nooa_cli-0.0.9 → nooa_cli-0.0.11}/README.md

@@ -13,13 +13,25 @@ uv add "nooa-cli[datascience]"
 
 `nooa-cli` automatically pulls in matching `nemo-oo-agents` (the core framework). The `[datascience]` extra adds libraries the LLM can use in REPL-generated code.
 
+> **Windows:** use [WSL 2](https://learn.microsoft.com/windows/wsl/install). Native Windows is not supported; see the [main README](https://github.com/NVIDIA-NeMo/labs-OO-Agents#installation).
+
 ## Usage
 
 ```bash
 nooa --help
-nooa start-dev            # launch the trace viewer
-nooa eval ...             # eval pipeline runner
-nooa traces ...           # inspect/manage trace files
+nooa start-dev        # launch the trace viewer
+nooa eval ...         # eval pipeline runner
+nooa traces ...       # inspect/manage trace files
+```
+
+Install the separate `nooa-acp` package to add the `nooa acp` plugin command and
+run the NOOA coding agent from an ACP-compatible client:
+
+```bash
+uv add nooa-acp
+export NOOA_MODEL=nvidia_nim/nvidia/nemotron-3-super-120b-a12b
+export NVIDIA_API_KEY=nvapi-...
+uv run nooa-acp
 ```
 
 See the main repo [README](https://github.com/NVIDIA-NeMo/labs-OO-Agents/blob/main/README.md) for the framework documentation.

{nooa_cli-0.0.9 → nooa_cli-0.0.11}/pyproject.toml

@@ -14,6 +14,7 @@ dependencies = [
     "click>=8.1.0",
     # CLI config files
     "pyyaml>=6.0",
+    "prompt-toolkit>=3.0.52",
 ]
 
 [project.urls]

{nooa_cli-0.0.9 → nooa_cli-0.0.11}/src/nooa_cli/AGENTS.md

@@ -127,6 +127,11 @@ same contract as an in-repo command module.
 - The **Performance Rule** below applies with extra force: every registered
   entry point is loaded on *every* `nooa` invocation, including `nooa --help`.
   Keep heavy imports inside the handler.
+- **Importing `nooa_cli` must not import `nooa`** (`test_connect_entrypoint.py`
+  checks this). `main()` checks the native-Windows policy itself
+  (`_refuse_unsupported_platform`, kept equal to `nooa._platform` by
+  `packages/nooa-cli/tests/test_cli_platform_check.py`) and switches redirected output to UTF-8
+  on Windows. New console entry points should go through `main()`.
 
 This mirrors the existing `nooa.skills` and `nooa.bundled_configs` groups.
 
@@ -186,6 +191,6 @@ New commands get tab-completion automatically. To enable it:
 nooa completion install   # auto-detects your shell
 
 # Or manually:
-eval "$(_NEMO_COMPLETE=zsh_source nemo)"   # zsh
-eval "$(_NEMO_COMPLETE=bash_source nemo)"  # bash
+eval "$(_NOOA_COMPLETE=zsh_source nooa)"   # zsh
+eval "$(_NOOA_COMPLETE=bash_source nooa)"  # bash
 ```

{nooa_cli-0.0.9 → nooa_cli-0.0.11}/src/nooa_cli/__init__.py

@@ -19,6 +19,9 @@ Shell completion:
     eval "$(_NOOA_COMPLETE=zsh_source nooa)"     # zsh
 """
 
+import os
+import sys
+
 import click
 
 from .commands import discover_commands
@@ -72,6 +75,56 @@ for _name, _cmd in discover_commands():
 oo.add_command(completion)
 
 
+# Same policy and wording as nooa._platform, checked here without importing
+# nooa so the CLI stays lazy (packages/nooa-cli/tests/test_cli_platform_check.py keeps them equal).
+_SKIP_PLATFORM_CHECK_ENV = "NOOA_SKIP_PLATFORM_CHECK"
+_UNSUPPORTED_PLATFORM_MESSAGE = (
+    "nooa does not support native Windows; use WSL 2 "
+    "(https://learn.microsoft.com/windows/wsl/install). "
+    f"Setting the {_SKIP_PLATFORM_CHECK_ENV} environment variable to 1 skips this check: "
+    "the pure-Python core and `nooa connect` are tested on native Windows; "
+    "other features may work but are unsupported."
+)
+
+
+def _refuse_unsupported_platform() -> None:
+    """Exit with one clean line on native Windows unless the user opted in."""
+    if sys.platform != "win32":
+        return
+    if os.environ.get(_SKIP_PLATFORM_CHECK_ENV, "").strip().lower() in {"1", "true", "yes"}:
+        return
+    raise SystemExit(f"Error: {_UNSUPPORTED_PLATFORM_MESSAGE}")
+
+
+def _is_utf8(stream) -> bool:
+    encoding = getattr(stream, "encoding", None) or ""
+    return encoding.lower().replace("-", "").replace("_", "") == "utf8"
+
+
+def _use_utf8_output() -> None:
+    """Use UTF-8 for redirected output and piped input on native Windows.
+
+    Redirected stdout/stderr and piped stdin use the ANSI code page there (for
+    example cp1252), which cannot encode the CLI's check marks and arrows and
+    would crash the command midway. Consoles already use UTF-8, so this changes
+    nothing there.
+    """
+    if sys.platform != "win32":
+        return
+    for stream in (sys.stdout, sys.stderr):
+        if stream is not None and not _is_utf8(stream) and hasattr(stream, "reconfigure"):
+            stream.reconfigure(encoding="utf-8", errors="replace")
+    stdin = sys.stdin
+    try:
+        piped = stdin is not None and not stdin.isatty()
+    except (OSError, ValueError):
+        piped = False
+    if piped and not _is_utf8(stdin) and hasattr(stdin, "reconfigure"):
+        stdin.reconfigure(encoding="utf-8", errors="replace")
+
+
 def main():
     """Entry point for console_scripts: nooa <subcommand>."""
+    _refuse_unsupported_platform()
+    _use_utf8_output()
     oo()

nooa_cli-0.0.11/src/nooa_cli/coding/__init__.py

@@ -0,0 +1,43 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+"""Shared coding-agent components used by terminal and protocol hosts."""
+
+from importlib import import_module
+
+_EXPORT_MODULES = {
+    "ActivityShellTools": "activity",
+    "FileEdit": "activity",
+    "TerminalCommandFinished": "activity",
+    "TerminalCommandOutput": "activity",
+    "TerminalCommandStarted": "activity",
+    "CodingAgent": "agent",
+    "discover_agent_instruction_files": "instructions",
+    "render_agent_instructions": "instructions",
+    "load_coding_skills_dirs": "settings",
+    "CodingSlashCommand": "slash_commands",
+    "CodingSlashCommandRegistry": "slash_commands",
+}
+
+
+def __getattr__(name: str):
+    """Load host components only when requested, not for leaf utility imports."""
+    if name not in _EXPORT_MODULES:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    value = getattr(import_module(f"{__name__}.{_EXPORT_MODULES[name]}"), name)
+    globals()[name] = value
+    return value
+
+
+__all__ = [
+    "ActivityShellTools",
+    "CodingAgent",
+    "CodingSlashCommand",
+    "CodingSlashCommandRegistry",
+    "FileEdit",
+    "TerminalCommandFinished",
+    "TerminalCommandOutput",
+    "TerminalCommandStarted",
+    "discover_agent_instruction_files",
+    "load_coding_skills_dirs",
+    "render_agent_instructions",
+]

{nooa_cli-0.0.9 → nooa_cli-0.0.11}/src/nooa_cli/coding/activity.py

@@ -4,7 +4,9 @@
 
 from __future__ import annotations
 
+import asyncio
 import logging
+import re
 from collections.abc import AsyncIterator
 from difflib import unified_diff
 from functools import wraps
@@ -27,6 +29,8 @@ logger = logging.getLogger(__name__)
 
 _MAX_EVENT_TEXT_CHARS = 10_000
 _MAX_COMMAND_OUTPUT_CHARS = 30_000
+_MAX_DIFF_INPUT_CHARS = 1_000_000
+_MAX_DIFF_INPUT_LINES = 20_000
 
 
 def _line_count(value: str) -> int:
@@ -35,23 +39,74 @@ def _line_count(value: str) -> int:
     return value.count("\n") + (0 if value.endswith("\n") else 1)
 
 
-def _edit_diff(path: str, old_text: str, new_text: str, start_line: int | None) -> str:
-    lines = list(
-        unified_diff(
-            old_text.splitlines(keepends=True),
-            new_text.splitlines(keepends=True),
-            fromfile=f"a/{path}",
-            tofile=f"b/{path}",
-        )
+def _diff_input_is_too_large(value: str) -> bool:
+    return len(value) > _MAX_DIFF_INPUT_CHARS or _line_count(value) > _MAX_DIFF_INPUT_LINES
+
+
+def _omitted_diff(path: str, reason: str) -> tuple[str, bool]:
+    return (
+        f"--- a/{path}\n+++ b/{path}\n@@ -0,0 +0,0 @@\n Diff omitted: {reason}.\n",
+        False,
     )
-    if start_line is not None:
-        for index, line in enumerate(lines):
-            if line.startswith("@@ "):
-                old_count = max(1, _line_count(old_text))
-                new_count = max(1, _line_count(new_text))
-                lines[index] = f"@@ -{start_line},{old_count} +{start_line},{new_count} @@\n"
-                break
-    return pformat("".join(lines), max_string=_MAX_EVENT_TEXT_CHARS, unquote_strings=True)
+
+
+_HUNK_HEADER = re.compile(r"^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$")
+
+
+def _offset_hunk_header(line: str, offset: int) -> str:
+    """Shift one hunk header into file coordinates, keeping difflib's counts."""
+    match = _HUNK_HEADER.match(line.rstrip("\n"))
+    if match is None:
+        return line
+    old_start, old_count, new_start, new_count, trailer = match.groups()
+    old_part = f"-{int(old_start) + offset}" + (f",{old_count}" if old_count else "")
+    new_part = f"+{int(new_start) + offset}" + (f",{new_count}" if new_count else "")
+    return f"@@ {old_part} {new_part} @@{trailer}\n"
+
+
+def _edit_diff(
+    path: str,
+    old_text: str,
+    new_text: str,
+    start_line: int | None,
+    *,
+    whole_file: bool = False,
+) -> tuple[str, bool]:
+    """Return a bounded, line-oriented unified diff and its completeness.
+
+    ``whole_file`` marks both texts as complete file contents, where a missing
+    final newline is a real file state worth reporting. Fragment diffs stop
+    mid-file, so the EOF marker there was noise.
+    """
+    if _diff_input_is_too_large(old_text) or _diff_input_is_too_large(new_text):
+        return _omitted_diff(path, "file content exceeds the safe diff preview limit")
+
+    output = TruncatingStringIO(limit=_MAX_EVENT_TEXT_CHARS)
+    # A region diff is generated in region coordinates; every hunk shifts by the
+    # same amount to reach file coordinates. Rewriting only the first one, with
+    # the whole region's counts, left later hunks region-relative — able to point
+    # before the first hunk, and unappliable by patch.
+    offset = start_line - 1 if start_line is not None else 0
+    for line in unified_diff(
+        old_text.splitlines(keepends=True),
+        new_text.splitlines(keepends=True),
+        fromfile=f"a/{path}",
+        tofile=f"b/{path}",
+    ):
+        if offset and line.startswith("@@ "):
+            line = _offset_hunk_header(line, offset)
+        if not line.endswith("\n"):
+            # difflib emits the source line verbatim, so unterminated content
+            # would run the next marker onto the same line ("-a+b").
+            if whole_file:
+                line = f"{line}\n\\n"
+            else:
+                # A fragment routinely stops before the file's final
+                # newline; marking that as "no newline at end of file"
+                # reported a file state that does not exist.
+                line = f"{line}\n"
+        output.write(line)
+    return output.getvalue(), not output.was_truncated
 
 
 class FileEdit(EventBase):  # type: ignore[misc]
@@ -82,6 +137,10 @@ class FileEdit(EventBase):  # type: ignore[misc]
         bool,
         Field(description="Whether old_text and new_text contain the complete affected text"),
     ] = True
+    diff_complete: Annotated[
+        bool,
+        Field(description="Whether diff contains the complete unified diff"),
+    ] = True
 
 
 class TerminalCommandStarted(EventBase):  # type: ignore[misc]
@@ -107,7 +166,11 @@ class TerminalCommandStarted(EventBase):  # type: ignore[misc]
 
 
 class TerminalCommandOutput(EventBase):  # type: ignore[misc]
-    """One streaming output chunk from a coding-agent terminal command."""
+    """The output of one coding-agent terminal command.
+
+    Emitted once, when the command finishes: output is buffered and bounded
+    rather than streamed, so hosts receive a single event per command.
+    """
 
     _role: ClassVar[Role] = Role.RUNTIME_EVENT
 
@@ -129,6 +192,10 @@ class TerminalCommandFinished(EventBase):  # type: ignore[misc]
     exit_code: Annotated[int | None, Field(description="Process exit code when available")] = None
     timed_out: Annotated[bool, Field(description="Whether the command timed out")] = False
     error: Annotated[str, Field(description="Failure before an exit code was available")] = ""
+    cancelled: Annotated[
+        bool,
+        Field(description="Whether the command was stopped by cancellation rather than failing"),
+    ] = False
     output_truncated: Annotated[
         bool,
         Field(description="Whether output was omitted from command activity events"),
@@ -178,6 +245,12 @@ class ActivityShellTools(Skill):
     def _resolve_path(self, path: str) -> Path:
         return self._shell._resolve_path(path)
 
+    def _diff_path(self, resolved: Path) -> str:
+        try:
+            return resolved.relative_to(self.cwd).as_posix()
+        except ValueError:
+            return resolved.as_posix().lstrip("/")
+
     def _emit(self, event: EventBase) -> None:
         try:
             self._event_manager.add(event)
@@ -192,7 +265,9 @@ class ActivityShellTools(Skill):
         stdin: Annotated[
             str | None, spec(description="Text piped to stdin (replaces heredocs)")
         ] = None,
-        timeout: Annotated[float, spec(description="Max seconds")] = 30.0,
+        timeout: Annotated[
+            float | None, spec(description="Max seconds; None uses the shell's default_timeout")
+        ] = None,
     ) -> ShellResult:
         command_id = str(uuid4())
         bounded_command = pformat(command, max_string=_MAX_EVENT_TEXT_CHARS, unquote_strings=True)
@@ -215,10 +290,12 @@ class ActivityShellTools(Skill):
         try:
             result = await self._shell.run(command, stdin=stdin, timeout=timeout)
         except BaseException as error:
+            cancelled = isinstance(error, asyncio.CancelledError)
             self._emit(
                 TerminalCommandFinished(
                     command_id=command_id,
-                    error=str(error) or type(error).__name__,
+                    error="" if cancelled else (str(error) or type(error).__name__),
+                    cancelled=cancelled,
                 )
             )
             raise
@@ -251,7 +328,13 @@ class ActivityShellTools(Skill):
     async def run_stream(
         self,
         command: Annotated[str, spec(description="Shell command to execute")],
-        timeout: Annotated[float, spec(description="Max seconds to wait before timeout")] = 30.0,
+        *,
+        stdin: Annotated[
+            str | None, spec(description="Text piped to stdin (replaces heredocs)")
+        ] = None,
+        timeout: Annotated[
+            float | None, spec(description="Max seconds; None uses the shell's default_timeout")
+        ] = None,
     ) -> AsyncIterator[StreamEvent | StreamDone]:
         command_id = str(uuid4())
         bounded_command = pformat(command, max_string=_MAX_EVENT_TEXT_CHARS, unquote_strings=True)
@@ -262,12 +345,18 @@ class ActivityShellTools(Skill):
                 command=bounded_command,
                 working_directory=str(self.cwd),
                 command_truncated=command_truncated,
+                stdin=(
+                    pformat(stdin, max_string=_MAX_EVENT_TEXT_CHARS, unquote_strings=True)
+                    if stdin is not None
+                    else None
+                ),
+                stdin_truncated=stdin is not None and len(stdin) > _MAX_EVENT_TEXT_CHARS,
             )
         )
         finished = False
         stdout_buffer = TruncatingStringIO(limit=_MAX_COMMAND_OUTPUT_CHARS // 2)
         stderr_buffer = TruncatingStringIO(limit=_MAX_COMMAND_OUTPUT_CHARS // 2)
-        stream = self._shell.run_stream(command, timeout=timeout)
+        stream = self._shell.run_stream(command, stdin=stdin, timeout=timeout)
         try:
             async for item in stream:
                 if isinstance(item, StreamDone):
@@ -306,10 +395,12 @@ class ActivityShellTools(Skill):
                             truncated=output_truncated,
                         )
                     )
+                cancelled = isinstance(error, asyncio.CancelledError)
                 self._emit(
                     TerminalCommandFinished(
                         command_id=command_id,
-                        error=str(error) or type(error).__name__,
+                        error="" if cancelled else (str(error) or type(error).__name__),
+                        cancelled=cancelled,
                         output_truncated=output_truncated,
                     )
                 )
@@ -320,7 +411,7 @@ class ActivityShellTools(Skill):
     @wraps(ShellTools.read)
     async def read(
         self,
-        path: Annotated[str, spec(description="File path (relative to cwd)")],
+        path: Annotated[str, spec(description="File path (relative to cwd or absolute)")],
         lines: Annotated[
             tuple[int, int] | None,
             spec(description="(start, end) 1-indexed inclusive, or None for whole file"),
@@ -348,7 +439,9 @@ class ActivityShellTools(Skill):
         if not isinstance(path, str):
             return await self._shell.replace(target, old_or_new, new)
 
-        resolved = self._resolve_path(path)
+        resolved = (
+            Path(target.resolved_path) if isinstance(target, Match) else self._resolve_path(path)
+        )
         if isinstance(target, Match):
             old_text = target.text
             start_line = target.start
@@ -375,6 +468,12 @@ class ActivityShellTools(Skill):
         written_text = result.new_text
         bounded_new = pformat(written_text, max_string=_MAX_EVENT_TEXT_CHARS, unquote_strings=True)
         new_truncated = len(written_text) > _MAX_EVENT_TEXT_CHARS
+        diff, diff_complete = _edit_diff(
+            self._diff_path(resolved),
+            old_text,
+            written_text,
+            start_line,
+        )
         self._emit(
             FileEdit(
                 path=str(resolved),
@@ -383,8 +482,9 @@ class ActivityShellTools(Skill):
                 new_text=bounded_new,
                 start_line=start_line,
                 end_line=end_line,
-                diff=_edit_diff(path, bounded_old, bounded_new, start_line),
+                diff=diff,
                 content_complete=not old_truncated and not new_truncated,
+                diff_complete=diff_complete,
             )
         )
         return result
@@ -392,40 +492,68 @@ class ActivityShellTools(Skill):
     @wraps(ShellTools.write_file)
     async def write_file(
         self,
-        path: Annotated[str, spec(description="File path (relative to cwd)")],
+        path: Annotated[str, spec(description="File path (relative to cwd or absolute)")],
         content: Annotated[str, spec(description="Full file content")],
     ) -> FileWrite:
         resolved = self._resolve_path(path)
         existed = resolved.exists()
-        old_text: str | None = None
-        old_complete = True
+        old_diff_text: str | None = None
+        old_content_complete = not existed
         if existed:
             try:
                 with resolved.open("r") as stream:
-                    old_text = stream.read(_MAX_EVENT_TEXT_CHARS + 1)
-                old_complete = len(old_text) <= _MAX_EVENT_TEXT_CHARS
-                old_text = pformat(old_text, max_string=_MAX_EVENT_TEXT_CHARS, unquote_strings=True)
+                    old_diff_text = stream.read(_MAX_DIFF_INPUT_CHARS + 1)
+                old_content_complete = len(old_diff_text) <= _MAX_EVENT_TEXT_CHARS
             except (OSError, UnicodeError):
                 # Observation must not make an otherwise valid overwrite fail.
-                old_complete = False
+                old_content_complete = False
 
         result = await self._shell.write_file(path, content)
+        bounded_old = (
+            pformat(
+                old_diff_text,
+                max_string=_MAX_EVENT_TEXT_CHARS,
+                unquote_strings=True,
+            )
+            if old_diff_text is not None
+            else None
+        )
         bounded_content = pformat(content, max_string=_MAX_EVENT_TEXT_CHARS, unquote_strings=True)
         content_truncated = len(content) > _MAX_EVENT_TEXT_CHARS
+        if existed and old_diff_text is None:
+            diff, diff_complete = _omitted_diff(
+                self._diff_path(resolved),
+                "previous file content could not be read",
+            )
+        else:
+            diff, diff_complete = _edit_diff(
+                self._diff_path(resolved),
+                old_diff_text or "",
+                content,
+                None,
+                whole_file=True,
+            )
         self._emit(
             FileEdit(
                 path=str(resolved),
                 operation="update" if existed else "create",
-                old_text=old_text,
+                old_text=bounded_old,
                 new_text=bounded_content,
-                start_line=1 if existed and old_complete and old_text is not None else None,
+                # An existing *empty* file has no original line to point at, so
+                # reporting 1..1 names lines that never existed.
+                start_line=(
+                    1
+                    if existed and old_content_complete and _line_count(old_diff_text or "")
+                    else None
+                ),
                 end_line=(
-                    max(1, _line_count(old_text))
-                    if existed and old_complete and old_text is not None
+                    _line_count(old_diff_text or "")
+                    if existed and old_content_complete and _line_count(old_diff_text or "")
                     else None
                 ),
-                diff=_edit_diff(path, old_text or "", bounded_content, 1),
-                content_complete=old_complete and not content_truncated,
+                diff=diff,
+                content_complete=old_content_complete and not content_truncated,
+                diff_complete=diff_complete,
             )
         )
         return result