acli: sync 0.6.7 — skills, search_files, platform line, Windows decoding

Vendors agenticCLI 4876f43 plus the 0.6.7 bump. All seven files are
byte-identical to the upstream sources modulo the dashscope. import prefix.

render_skill no longer runs str.format() over a skill body. A body is Markdown
full of literal braces from the JSON and Python it documents, so
text-generation.md — which shows messages=[{"role": "user", ...}] and declares
no arguments at all — raised KeyError('"role"'), and the old `except KeyError`
reported that as "missing args" for a skill that takes none. 6 of the 13
bundled skills were unusable through use_skill while /skill and the catalog
kept advertising them. Substitution is now a plain replace of the declared
arguments only; use_skill and the scheduler branch on `is None` rather than
falsiness, so the missing-args hint can no longer render empty.

search_files matches the pattern against paths relative to the search root as
well as the basename, and skips dot-directories only unless the pattern names
one, so .acli/skills/*.md is reachable without walking every .git in the tree.
Its description now says that * crosses separators, which it does under fnmatch
and did not under the old basename-only match, and the no-match message states
what was actually searched instead of implying the file is absent.

EnvironmentSection states the platform and how run_command executes, through a
new shell_label() that lives next to _spawn so the prompt cannot drift from
what the tool really runs. Nothing used to say which shell this is: on Windows
the model wrote `2>/dev/null || find /` and spent a turn on a PowerShell
ParserError.

Child-process output decoding tries UTF-8 strictly first, then the Windows OEM
code page from GetOEMCP() and the stdio/locale encodings. A piped child writes
in its console's code page, which need not equal sys.stdout.encoding, and cp936
accepts nearly any byte sequence so it would silently mangle UTF-8 rather than
fail. A UnicodeDecodeError in the last four bytes is the byte-budget truncation
splitting a character, not evidence of another encoding, so it is repaired
instead of re-decoding the whole buffer under a DBCS page.

Adds tests/unit/test_acli_skill_render.py: the 13 bundled skill files ship only
in this wheel, so they are the real corpus that broke and the one piece of
coverage with dashscope-only value. Verified by restoring the pre-fix
render_skill — exactly those 6 skills fail, 19 tests — then restoring the fix.
The upstream coverage for the other three fixes stays in agenticCLI, which is
where those test modules live.

dashscope unit: 1011 passed, 7 skipped. pre-commit --all-files green, mypy
included. dashscope/acli/examples/ is untouched by the sync.

Author: zhansheng.lzs

dashscope/acli/__init__.py

@@ -3,7 +3,7 @@
 
 import uuid
 
-__version__ = "0.6.6"
+__version__ = "0.6.7"
 
 # Per-process identifier sent as x-dashscope-sdk-session-id so the
 # backend can group multi-turn requests from one CLI run.

dashscope/acli/prompt_pipeline.py

@@ -200,7 +200,17 @@ class EnvironmentSection:
     name = "environment"
 
     def render(self, ctx: PromptContext) -> str:
-        env_info: list[str] = []
+        import platform
+
+        from dashscope.acli.tools.shell import shell_label
+
+        # The platform is stated because run_command's syntax depends on it and
+        # a wrong guess costs a whole turn: on Windows the model wrote
+        # `2>/dev/null || find /` and got back a PowerShell ParserError.
+        env_info: list[str] = [
+            f"Current OS: {platform.system()} {platform.machine()}",
+            f"run_command executes via: {shell_label()}",
+        ]
         if ctx.user_name:
             env_info.append(f"Current user: {ctx.user_name}")
         if ctx.provider_name or ctx.model_name:
@@ -210,8 +220,6 @@ def render(self, ctx: PromptContext) -> str:
                 "mentioned in history or summaries may be outdated — "
                 "always defer to this line for model questions)",
             )
-        if not env_info:
-            return ""
         env_info.append(
             "Rule: when mentioning this CLI's commands, only cite real "
             "commands that definitely exist; when unsure, point the user "

dashscope/acli/scheduler.py

@@ -591,7 +591,9 @@ async def _execute_job(self, job: CronJob) -> None:
                     continue
 
             rendered = render_skill(skill, inv.args)
-            if not rendered:
+            # `is None`, not falsy: None is the missing-arguments signal, so
+            # arg_hint is never empty here.
+            if rendered is None:
                 arg_hint = " ".join(f"<{a}>" for a in skill.arguments)
                 results.append(
                     f"missing args: /skill {inv.name} {arg_hint}",

dashscope/acli/skills/base.py

@@ -200,13 +200,18 @@ def render_skill(skill: Skill, args: list[str]) -> str | None:
     don't match."""
     if len(args) < len(skill.arguments):
         return None
-    kwargs = {}
+    template = skill.prompt_template
+    # A skill body is Markdown, not a format string: it is full of literal
+    # braces from the JSON and Python it documents. Running str.format() over
+    # the whole body raised KeyError on `{"role": ...}`, which the old
+    # `except KeyError` turned into a bogus "missing args" report for every
+    # no-argument skill that showed a payload, and let the IndexError from
+    # `{}` escape entirely. Substitute only the declared arguments and leave
+    # every other brace exactly as the author wrote it.
     for i, arg_name in enumerate(skill.arguments):
         if i == len(skill.arguments) - 1:
-            kwargs[arg_name] = " ".join(args[i:])
+            value = " ".join(args[i:])
         else:
-            kwargs[arg_name] = args[i]
-    try:
-        return skill.prompt_template.format(**kwargs)
-    except KeyError:
-        return None
+            value = args[i]
+        template = template.replace("{" + arg_name + "}", value)
+    return template

dashscope/acli/tools/filesystem.py

@@ -262,11 +262,22 @@ def delete_directory(path: str) -> str:
     return f"Deleted directory: {path}"
 
 
+def _pattern_names_hidden_dir(pattern: str) -> bool:
+    """True when the caller explicitly asked about a dot-directory."""
+    return any(
+        seg.startswith(".")
+        for seg in pattern.replace(os.sep, "/").split("/")
+        if seg
+    )
+
+
 @tool(
     name="search_files",
     description=(
-        "Search files by name pattern. "
-        "Supports wildcards like *.py, test_*."
+        "Search files by name or path pattern, relative to `path` "
+        "(default: the working directory). Supports wildcards like *.py, "
+        "test_*, src/*.ts and .github/workflows/*.yml. `*` crosses directory "
+        "separators, so *.md finds every Markdown file at any depth."
     ),
     permission=PermissionLevel.AUTO,
 )
@@ -279,31 +290,43 @@ def search_files(pattern: str, path: str | None = None) -> str:
     if not os.path.isdir(search_root):
         return f"Error: search path not found - {search_root}"
 
+    needle = pattern.replace(os.sep, "/")
+    want_hidden = _pattern_names_hidden_dir(pattern)
     matches = []
     root_depth = search_root.rstrip(os.sep).count(os.sep)
     for root, dirs, files in os.walk(search_root):
         # Enforce depth limit
         current_depth = root.rstrip(os.sep).count(os.sep) - root_depth
         if current_depth >= _MAX_SEARCH_DEPTH:
             dirs[:] = []
-        # Skip hidden and sensitive directories
+        # Sensitive directories are always skipped. Other dot-directories are
+        # skipped unless the pattern asks for one, so `.acli/skills/*.md` is
+        # searchable without walking every `.git` in the tree.
         dirs[:] = [
             d
             for d in dirs
-            if not d.startswith(".") and d not in SENSITIVE_NAMES
+            if d not in SENSITIVE_NAMES
+            and (want_hidden or not d.startswith("."))
         ]
         for name in files:
-            if fnmatch.fnmatch(name, pattern):
-                if name in SENSITIVE_NAMES:
-                    continue
+            if name in SENSITIVE_NAMES:
+                continue
+            rel = os.path.relpath(os.path.join(root, name), search_root)
+            if fnmatch.fnmatch(rel.replace(os.sep, "/"), needle) or (
+                fnmatch.fnmatch(name, needle)
+            ):
                 matches.append(os.path.join(root, name))
                 if len(matches) >= 100:
                     break
         if len(matches) >= 100:
             break
 
     if not matches:
-        return f"No files match '{pattern}'"
+        return (
+            f"No files match '{pattern}' under {search_root}. The pattern is "
+            "matched against paths relative to that root, and dot-directories "
+            "are skipped unless the pattern names one."
+        )
     result = f"Found {len(matches)} matching files:\n"
     result += "\n".join(f"  {m}" for m in matches)
     return result

dashscope/acli/tools/shell.py

@@ -42,21 +42,58 @@ def default_timeout() -> int:
     return value if value > 0 else DEFAULT_TIMEOUT
 
 
-def _resolve_output_encoding() -> str:
-    """Encoding for decoding subprocess output.
+def _resolve_output_encodings() -> tuple[str, ...]:
+    """Encodings to try when decoding subprocess output, best guess first.
 
     Resolved at import, not per call: the TUI replaces ``sys.stdout`` with
     textual's capture object, which has no ``.encoding``, so reading it later
     raises AttributeError and fails every command.
+
+    A captured child writes in its own console's code page, which on Windows is
+    the OEM page and need not match Python's stdout encoding. Decoding a zh-CN
+    PowerShell error as UTF-8 handed the model mojibake instead of the one
+    message that explained its failure. UTF-8 stays first and is tried
+    strictly: it fails loudly on OEM bytes, whereas a DBCS page like cp936
+    accepts almost anything and would silently mangle UTF-8 output.
     """
-    if not IS_WINDOWS:
-        return "utf-8"
-    return (
-        getattr(sys.stdout, "encoding", None)
-        or getattr(sys.__stdout__, "encoding", None)
-        or locale.getpreferredencoding(False)
-        or "utf-8"
-    )
+    candidates = ["utf-8"]
+    if IS_WINDOWS:
+        import ctypes
+
+        kernel32 = getattr(ctypes, "windll", None)
+        oem = kernel32.kernel32.GetOEMCP() if kernel32 is not None else 0
+        if oem:
+            candidates.append(f"cp{oem}")
+        for extra in (
+            getattr(sys.stdout, "encoding", None),
+            getattr(sys.__stdout__, "encoding", None),
+            locale.getpreferredencoding(False),
+        ):
+            if extra:
+                candidates.append(extra)
+    unique: list[str] = []
+    for name in candidates:
+        if name.lower() not in {u.lower() for u in unique}:
+            unique.append(name)
+    return tuple(unique)
+
+
+def _decode_output(data: bytes) -> str:
+    """Decode child output, falling back across console code pages."""
+    for encoding in (OUTPUT_ENCODING,) + OUTPUT_ENCODINGS:
+        try:
+            return data.decode(encoding)
+        except LookupError:
+            continue
+        except UnicodeDecodeError as exc:
+            # Truncation is byte-based, so it can split a trailing multi-byte
+            # character. That is not evidence the whole buffer is in another
+            # encoding — repair the tail instead of re-decoding everything.
+            if exc.start >= len(data) - 4:
+                return data.decode(encoding, errors="replace")
+            continue
+    # Last resort only reachable if every candidate name is unusable.
+    return data.decode("utf-8", errors="replace")
 
 
 def _resolve_win_shell() -> tuple[str, ...]:
@@ -69,9 +106,41 @@ def _resolve_win_shell() -> tuple[str, ...]:
     return (exe, "-NoProfile", "-NonInteractive", "-Command")
 
 
-OUTPUT_ENCODING = _resolve_output_encoding()
+OUTPUT_ENCODINGS = _resolve_output_encodings()
+# The primary candidate keeps its own name because callers and tests pin a
+# single encoding; _decode_output honours it before trying the fallbacks.
+OUTPUT_ENCODING = OUTPUT_ENCODINGS[0]
 WIN_SHELL = _resolve_win_shell()
 
+
+def shell_label() -> str:
+    """How ``run_command`` executes a command, for the system prompt.
+
+    Lives next to ``_spawn`` so the prompt cannot drift from what the tool
+    really runs. Nothing used to say which shell this is: a model that assumes
+    POSIX spends a turn on ``ls -la ... 2>/dev/null || find /`` before a
+    PowerShell ParserError tells it otherwise.
+    """
+    if not IS_WINDOWS:
+        return (
+            "POSIX sh via `/bin/sh -c` — not the user's interactive shell, "
+            "so no aliases, rc files or zsh/bash-only syntax"
+        )
+    exe = os.path.basename(WIN_SHELL[0])
+    if exe.lower().startswith("pwsh"):
+        chaining = "`&&`/`||` work (PowerShell 7+)"
+    else:
+        chaining = (
+            "`&&`/`||` are not statement separators (Windows PowerShell "
+            "5.1) — use `;` or separate calls"
+        )
+    return (
+        f"PowerShell on Windows ({exe}). Write PowerShell, not POSIX: no "
+        f"`2>/dev/null`, no `ls -la`/`find`/`grep`; {chaining}. Use "
+        "`$env:USERPROFILE`, `Get-ChildItem`, `Select-String`."
+    )
+
+
 BLOCKED_PATTERNS = [
     # POSIX
     "mkfs",
@@ -712,10 +781,9 @@ async def run_command(command: str, timeout: int | None = None) -> str:
 
     output = ""
     if stdout:
-        output += stdout.decode(OUTPUT_ENCODING, errors="replace")
+        output += _decode_output(stdout)
     if stderr:
-        err = stderr.decode(OUTPUT_ENCODING, errors="replace")
-        output += "\n[stderr]\n" + err
+        output += "\n[stderr]\n" + _decode_output(stderr)
 
     if len(output) > MAX_OUTPUT_LENGTH:
         output = (

dashscope/acli/tools/skills.py

@@ -67,7 +67,10 @@ async def use_skill(name: str, args: list[str] | None = None) -> str:
                     f"{skill.mcp_service}; ask the user to connect first."
                 )
         rendered = render_skill(skill, [str(a) for a in (args or [])])
-        if not rendered:
+        # `is None`, not falsy: render_skill only returns None when arguments
+        # are missing, so the hint below always lists at least one name. An
+        # empty body is a valid (if useless) skill, not a missing argument.
+        if rendered is None:
             hint = " ".join(f"<{a}>" for a in skill.arguments)
             return f"Error: missing args. '{name}' requires: {hint}"
         agent = get_agent()

dashscope/version.py

@@ -1,4 +1,4 @@
 # -*- coding: utf-8 -*-
 # Copyright (c) Alibaba, Inc. and its affiliates.
 
-__version__ = "1.27.6"
+__version__ = "1.27.7"