@caupulican/pi-adaptative 0.81.37 → 0.81.39

package/dist/bundled-resources/runtimes/pi-shell-engine/commands/__init__.py

@@ -0,0 +1,43 @@
+"""Aggregates every pure builtin into REGISTRY: dict[str, BuiltinFn].
+
+Imports the three WP-D chunks by module name (text, fs, strings, search). WP-D3 authors this
+file per the frozen module/function naming in windows-shell-workpackages-2026-07-19.md §3
+WP-D; it does not create/stub text.py or fs.py — those land from the sibling WP-D1/WP-D2
+chunks in the same wave.
+"""
+
+from __future__ import annotations
+
+from context import BuiltinFn
+
+from . import fs, search, strings, text
+
+REGISTRY: dict[str, BuiltinFn] = {
+    "echo": strings.cmd_echo,
+    "printf": strings.cmd_printf,
+    "basename": strings.cmd_basename,
+    "dirname": strings.cmd_dirname,
+    "which": strings.cmd_which,
+    "true": strings.cmd_true,
+    "false": strings.cmd_false,
+    "pwd": strings.cmd_pwd,
+    "test": strings.cmd_test,
+    "[": strings.cmd_test,
+    "grep": search.cmd_grep,
+    "sed": search.cmd_sed,
+    "cat": text.cat,
+    "head": text.head,
+    "tail": text.tail,
+    "wc": text.wc,
+    "sort": text.sort,
+    "uniq": text.uniq,
+    "cut": text.cut,
+    "tr": text.tr,
+    "ls": fs.ls,
+    "find": fs.find,
+    "rm": fs.rm,
+    "cp": fs.cp,
+    "mv": fs.mv,
+    "mkdir": fs.mkdir,
+    "touch": fs.touch,
+}

package/dist/bundled-resources/runtimes/pi-shell-engine/commands/fs.py

@@ -0,0 +1,270 @@
+"""Filesystem builtins: ls, find, rm, cp, mv, mkdir, touch.
+
+Owned by WP-D2. Pure stdlib; imports only context/errors/nodes (never exec/state/proc).
+See windows-shell-workpackages-2026-07-19.md §2.2 (matrix) and §3 (WP-D spec).
+
+Every path operand resolves against `ctx.cwd` (never `os.chdir`, never touches
+process-global state). A builtin never mutates `ctx.state` (it has none - only cwd/env
+strings on `BuiltinContext`).
+"""
+
+from __future__ import annotations
+
+import fnmatch
+import os
+import shutil
+from typing import TYPE_CHECKING
+
+from errors import UnsupportedConstruct
+
+if TYPE_CHECKING:
+    from context import BuiltinContext
+
+
+def _resolve(cwd: str, path: str) -> str:
+    """Resolve `path` against `cwd` without ever touching process cwd."""
+    if os.path.isabs(path):
+        return os.path.normpath(path)
+    return os.path.normpath(os.path.join(cwd, path))
+
+
+def _to_posix(path: str) -> str:
+    return path.replace("\\", "/")
+
+
+def _split_flags(argv: list[str], allowed: set[str], name: str) -> tuple[set[str], list[str]]:
+    """Parse `-x`/`-xy` short flags plus `--` end-of-options; positional args pass through.
+
+    Raises UnsupportedConstruct("unsupported-flag", ...) for any flag char outside `allowed`.
+    """
+    flags: set[str] = set()
+    positional: list[str] = []
+    end_opts = False
+    for arg in argv:
+        if not end_opts and arg == "--":
+            end_opts = True
+            continue
+        if not end_opts and len(arg) > 1 and arg[0] == "-":
+            for ch in arg[1:]:
+                if ch not in allowed:
+                    raise UnsupportedConstruct("unsupported-flag", f"{name}: unsupported flag -{ch}")
+                flags.add(ch)
+            continue
+        positional.append(arg)
+    return flags, positional
+
+
+def ls(ctx: "BuiltinContext") -> int:
+    flags, positional = _split_flags(ctx.argv[1:], {"a", "A", "1", "r"}, "ls")
+    if len(positional) > 1:
+        if any(os.path.isdir(_resolve(ctx.cwd, p)) for p in positional):
+            raise UnsupportedConstruct("unsupported-flag", "ls: only one directory operand is supported")
+        ordered = sorted(positional)
+        lines = []
+        exit_code = 0
+        for operand in ordered:
+            abs_operand = _resolve(ctx.cwd, operand)
+            if os.path.isfile(abs_operand):
+                lines.append(operand)
+            else:
+                lines.append(f"ls: {operand}: No such file or directory")
+                exit_code = 1
+        ctx.stdout.write("".join(line + "\n" for line in lines).encode())
+        return exit_code
+    target = positional[0] if positional else "."
+    abs_target = _resolve(ctx.cwd, target)
+    if not os.path.exists(abs_target):
+        ctx.stdout.write(f"ls: cannot access '{target}': No such file or directory\n".encode())
+        return 1
+    if not os.path.isdir(abs_target):
+        ctx.stdout.write(f"ls: cannot access '{target}': Not a directory\n".encode())
+        return 1
+    show_all = "a" in flags
+    almost_all = "A" in flags
+    entries: list[str] = []
+    if show_all:
+        entries.append(".")
+        entries.append("..")
+    for name in os.listdir(abs_target):
+        if name.startswith(".") and not (show_all or almost_all):
+            continue
+        entries.append(name)
+    entries.sort()
+    if "r" in flags:
+        entries.reverse()
+    lines = []
+    for name in entries:
+        full = os.path.join(abs_target, name)
+        suffix = "/" if os.path.isdir(full) else ""
+        lines.append(name + suffix)
+    ctx.stdout.write("".join(line + "\n" for line in lines).encode())
+    return 0
+
+
+def find(ctx: "BuiltinContext") -> int:
+    argv = ctx.argv[1:]
+    path: str | None = None
+    type_filter: str | None = None
+    name_pattern: str | None = None
+    i = 0
+    while i < len(argv):
+        arg = argv[i]
+        if arg == "-type":
+            i += 1
+            if i >= len(argv) or argv[i] not in ("f", "d"):
+                raise UnsupportedConstruct("unsupported-flag", "find: -type requires f or d")
+            type_filter = argv[i]
+        elif arg == "-name":
+            i += 1
+            if i >= len(argv):
+                raise UnsupportedConstruct("unsupported-flag", "find: -name requires a pattern")
+            name_pattern = argv[i]
+        elif arg.startswith("-") and arg != "-":
+            raise UnsupportedConstruct("unsupported-flag", f"find: unsupported flag {arg}")
+        else:
+            if path is not None:
+                raise UnsupportedConstruct("unsupported-flag", "find: only one path operand is supported")
+            path = arg
+        i += 1
+    if path is None:
+        path = "."
+    abs_root = _resolve(ctx.cwd, path)
+    if not os.path.exists(abs_root):
+        ctx.stdout.write(f"find: '{path}': No such file or directory\n".encode())
+        return 1
+    all_paths = [abs_root]
+    for dirpath, dirnames, filenames in os.walk(abs_root):
+        for d in dirnames:
+            all_paths.append(os.path.join(dirpath, d))
+        for f in filenames:
+            all_paths.append(os.path.join(dirpath, f))
+    results: list[str] = []
+    for p in all_paths:
+        if type_filter == "f" and not os.path.isfile(p):
+            continue
+        if type_filter == "d" and not os.path.isdir(p):
+            continue
+        if name_pattern is not None and not fnmatch.fnmatch(os.path.basename(p), name_pattern):
+            continue
+        rel = os.path.relpath(p, abs_root)
+        display = path if rel == "." else os.path.join(path, rel)
+        results.append(_to_posix(display))
+    results.sort()
+    ctx.stdout.write("".join(r + "\n" for r in results).encode())
+    return 0
+
+
+def rm(ctx: "BuiltinContext") -> int:
+    flags, paths = _split_flags(ctx.argv[1:], {"f", "r", "R"}, "rm")
+    if not paths:
+        ctx.stdout.write(b"rm: missing operand\n")
+        return 1
+    recursive = "r" in flags or "R" in flags
+    force = "f" in flags
+    exit_code = 0
+    for p in paths:
+        abs_p = _resolve(ctx.cwd, p)
+        if not os.path.lexists(abs_p):
+            if not force:
+                ctx.stdout.write(f"rm: cannot remove '{p}': No such file or directory\n".encode())
+                exit_code = 1
+            continue
+        if os.path.isdir(abs_p) and not os.path.islink(abs_p):
+            if not recursive:
+                ctx.stdout.write(f"rm: cannot remove '{p}': Is a directory\n".encode())
+                exit_code = 1
+                continue
+            shutil.rmtree(abs_p)
+        else:
+            os.remove(abs_p)
+    return exit_code
+
+
+def cp(ctx: "BuiltinContext") -> int:
+    flags, positional = _split_flags(ctx.argv[1:], {"r", "R"}, "cp")
+    if len(positional) != 2:
+        ctx.stdout.write(b"cp: missing file operand\n")
+        return 1
+    recursive = "r" in flags or "R" in flags
+    src, dst = positional
+    abs_src = _resolve(ctx.cwd, src)
+    abs_dst = _resolve(ctx.cwd, dst)
+    if not os.path.exists(abs_src):
+        ctx.stdout.write(f"cp: cannot stat '{src}': No such file or directory\n".encode())
+        return 1
+    if os.path.isdir(abs_src):
+        if not recursive:
+            ctx.stdout.write(f"cp: -r not specified; omitting directory '{src}' (use -r)\n".encode())
+            return 1
+        dest = abs_dst
+        if os.path.isdir(abs_dst):
+            dest = os.path.join(abs_dst, os.path.basename(os.path.normpath(abs_src)))
+        shutil.copytree(abs_src, dest, dirs_exist_ok=True)
+    else:
+        dest = abs_dst
+        if os.path.isdir(abs_dst):
+            dest = os.path.join(abs_dst, os.path.basename(abs_src))
+        shutil.copy2(abs_src, dest)
+    return 0
+
+
+def mv(ctx: "BuiltinContext") -> int:
+    _flags, positional = _split_flags(ctx.argv[1:], set(), "mv")
+    if len(positional) != 2:
+        ctx.stdout.write(b"mv: missing file operand\n")
+        return 1
+    src, dst = positional
+    abs_src = _resolve(ctx.cwd, src)
+    abs_dst = _resolve(ctx.cwd, dst)
+    if not os.path.exists(abs_src):
+        ctx.stdout.write(f"mv: cannot stat '{src}': No such file or directory\n".encode())
+        return 1
+    dest = abs_dst
+    if os.path.isdir(abs_dst):
+        dest = os.path.join(abs_dst, os.path.basename(os.path.normpath(abs_src)))
+    shutil.move(abs_src, dest)
+    return 0
+
+
+def mkdir(ctx: "BuiltinContext") -> int:
+    flags, dirs = _split_flags(ctx.argv[1:], {"p"}, "mkdir")
+    if not dirs:
+        ctx.stdout.write(b"mkdir: missing operand\n")
+        return 1
+    parents = "p" in flags
+    exit_code = 0
+    for d in dirs:
+        abs_d = _resolve(ctx.cwd, d)
+        if parents:
+            os.makedirs(abs_d, exist_ok=True)
+            continue
+        if os.path.exists(abs_d):
+            ctx.stdout.write(f"mkdir: cannot create directory '{d}': File exists\n".encode())
+            exit_code = 1
+            continue
+        try:
+            os.mkdir(abs_d)
+        except FileNotFoundError:
+            ctx.stdout.write(f"mkdir: cannot create directory '{d}': No such file or directory\n".encode())
+            exit_code = 1
+    return exit_code
+
+
+def touch(ctx: "BuiltinContext") -> int:
+    _flags, files = _split_flags(ctx.argv[1:], set(), "touch")
+    if not files:
+        ctx.stdout.write(b"touch: missing file operand\n")
+        return 1
+    exit_code = 0
+    for f in files:
+        abs_f = _resolve(ctx.cwd, f)
+        if os.path.exists(abs_f):
+            os.utime(abs_f, None)
+            continue
+        parent = os.path.dirname(abs_f)
+        if parent and not os.path.isdir(parent):
+            ctx.stdout.write(f"touch: cannot touch '{f}': No such file or directory\n".encode())
+            exit_code = 1
+            continue
+        open(abs_f, "ab").close()
+    return exit_code

package/dist/bundled-resources/runtimes/pi-shell-engine/commands/search.py

@@ -0,0 +1,252 @@
+"""Search/transform builtins: grep, sed.
+
+Pure builtins per windows-shell-workpackages-2026-07-19.md §2.2. Regex dialect is Python
+`re` (documented divergence from POSIX BRE/ERE).
+"""
+
+from __future__ import annotations
+
+import os
+import re
+
+from context import BuiltinContext
+from errors import UnsupportedConstruct
+
+_GREP_FLAGS = set("ivnclwFE")
+
+
+def _resolve(cwd: str, path: str) -> str:
+    """Resolve `path` against `cwd` (see commands/fs.py's `_resolve`: main.py never os.chdir()s
+    to the request cwd, so every relative FILE operand must resolve against ctx.cwd here too)."""
+    if os.path.isabs(path):
+        return os.path.normpath(path)
+    return os.path.normpath(os.path.join(cwd, path))
+
+
+def cmd_grep(ctx: BuiltinContext) -> int:
+    args = ctx.argv[1:]
+    flags: set[str] = set()
+    idx = 0
+    while idx < len(args):
+        arg = args[idx]
+        if arg == "--":
+            idx += 1
+            break
+        if arg.startswith("-") and arg != "-" and len(arg) > 1:
+            for c in arg[1:]:
+                if c not in _GREP_FLAGS:
+                    raise UnsupportedConstruct("unsupported-flag", f"grep: unsupported flag '-{c}'")
+                flags.add(c)
+            idx += 1
+            continue
+        break
+    remaining = args[idx:]
+    if not remaining:
+        raise UnsupportedConstruct("unsupported-flag", "grep: PATTERN operand required")
+    pattern = remaining[0]
+    files = remaining[1:]
+
+    ignore_case = "i" in flags
+    invert = "v" in flags
+    show_lineno = "n" in flags
+    count_only = "c" in flags
+    files_only = "l" in flags
+    whole_word = "w" in flags
+    fixed = "F" in flags
+
+    if fixed:
+        needle = pattern
+    else:
+        pat = pattern
+        if whole_word:
+            pat = r"\b" + pat + r"\b"
+        re_flags = re.IGNORECASE if ignore_case else 0
+        try:
+            compiled = re.compile(pat, re_flags)
+        except re.error as exc:
+            raise UnsupportedConstruct("malformed-syntax", f"grep: invalid pattern: {exc}") from exc
+
+    def matches(line: str) -> bool:
+        if fixed:
+            hay = line.lower() if ignore_case else line
+            n = needle.lower() if ignore_case else needle
+            if whole_word:
+                return re.search(r"(?<!\w)" + re.escape(n) + r"(?!\w)", hay) is not None
+            return n in hay
+        return compiled.search(line) is not None
+
+    def read_lines(data: bytes) -> list[str]:
+        text = data.decode("utf-8", errors="replace")
+        if text == "":
+            return []
+        lines = text.split("\n")
+        if lines and lines[-1] == "":
+            lines.pop()
+        return lines
+
+    multi_file = len(files) > 1
+    any_match = False
+    any_error = False
+    out_lines: list[str] = []
+
+    def process(name: str, lines: list[str]) -> None:
+        nonlocal any_match
+        matched = [ln for ln in lines if matches(ln) != invert]
+        if matched:
+            any_match = True
+        if count_only:
+            prefix = f"{name}:" if multi_file else ""
+            out_lines.append(f"{prefix}{len(matched)}")
+            return
+        if files_only:
+            if matched:
+                out_lines.append(name)
+            return
+        for i, ln in enumerate(lines):
+            if matches(ln) == invert:
+                continue
+            prefix = ""
+            if multi_file:
+                prefix += f"{name}:"
+            if show_lineno:
+                prefix += f"{i + 1}:"
+            out_lines.append(f"{prefix}{ln}")
+
+    if not files:
+        data = ctx.stdin.read()
+        process("(standard input)", read_lines(data))
+    else:
+        for name in files:
+            try:
+                with open(_resolve(ctx.cwd, name), "rb") as fh:
+                    data = fh.read()
+            except OSError as exc:
+                out_lines_msg = f"grep: {name}: {exc.strerror or exc}"
+                ctx.stdout.write((out_lines_msg + "\n").encode("utf-8"))
+                any_error = True
+                continue
+            process(name, read_lines(data))
+
+    if out_lines:
+        ctx.stdout.write(("\n".join(out_lines) + "\n").encode("utf-8"))
+
+    if any_error:
+        return 2
+    return 0 if any_match else 1
+
+
+def _parse_sed_replacement(repl: str) -> str:
+    """Translate sed REPL (\\1..\\9, &, \\&) into Python re replacement syntax."""
+    out: list[str] = []
+    i = 0
+    n = len(repl)
+    while i < n:
+        ch = repl[i]
+        if ch == "\\" and i + 1 < n:
+            nxt = repl[i + 1]
+            if nxt.isdigit():
+                out.append("\\g<" + nxt + ">")
+                i += 2
+                continue
+            if nxt == "&":
+                out.append("&")
+                i += 2
+                continue
+            if nxt == "\\":
+                out.append("\\\\")
+                i += 2
+                continue
+            out.append(nxt)
+            i += 2
+            continue
+        if ch == "&":
+            out.append("\\g<0>")
+            i += 1
+            continue
+        if ch == "\\":
+            out.append("\\\\")
+            i += 1
+            continue
+        out.append(ch)
+        i += 1
+    return "".join(out)
+
+
+def _parse_sed_script(script: str) -> tuple[str, str, bool, bool]:
+    if len(script) < 2 or script[0] != "s":
+        raise UnsupportedConstruct("unsupported-flag", "sed: only s/// scripts are supported")
+    delim = script[1]
+    if not delim or delim.isalnum() or delim == "\\":
+        raise UnsupportedConstruct("malformed-syntax", "sed: invalid delimiter")
+    parts: list[str] = []
+    current: list[str] = []
+    i = 2
+    n = len(script)
+    while i < n:
+        ch = script[i]
+        if ch == "\\" and i + 1 < n and script[i + 1] == delim:
+            current.append(delim)
+            i += 2
+            continue
+        if ch == delim:
+            parts.append("".join(current))
+            current = []
+            i += 1
+            if len(parts) == 2:
+                break
+            continue
+        current.append(ch)
+        i += 1
+    if len(parts) != 2:
+        raise UnsupportedConstruct("malformed-syntax", "sed: unterminated s/// script")
+    remainder = script[i:]
+    global_flag = "g" in remainder
+    icase_flag = "i" in remainder
+    for c in remainder:
+        if c not in "gi":
+            raise UnsupportedConstruct("unsupported-flag", f"sed: unsupported flag '{c}'")
+    pattern, repl = parts
+    return pattern, repl, global_flag, icase_flag
+
+
+def cmd_sed(ctx: BuiltinContext) -> int:
+    args = ctx.argv[1:]
+    if not args:
+        raise UnsupportedConstruct("unsupported-flag", "sed: SCRIPT operand required")
+    for a in args:
+        if a.startswith("-") and a != "-":
+            raise UnsupportedConstruct("unsupported-flag", f"sed: unsupported flag {a!r}")
+    script = args[0]
+    files = args[1:]
+    pattern, repl, global_flag, icase_flag = _parse_sed_script(script)
+    re_flags = re.IGNORECASE if icase_flag else 0
+    try:
+        compiled = re.compile(pattern, re_flags)
+    except re.error as exc:
+        raise UnsupportedConstruct("malformed-syntax", f"sed: invalid pattern: {exc}") from exc
+    py_repl = _parse_sed_replacement(repl)
+    count = 0 if global_flag else 1
+
+    def transform(data: bytes) -> bytes:
+        text = data.decode("utf-8", errors="replace")
+        if text == "":
+            return b""
+        had_trailing_newline = text.endswith("\n")
+        body = text[:-1] if had_trailing_newline else text
+        lines = body.split("\n") if body or had_trailing_newline else [""]
+        if body == "" and not had_trailing_newline:
+            lines = [""]
+        result_lines = [compiled.sub(py_repl, ln, count=count) for ln in lines]
+        out = "\n".join(result_lines)
+        if had_trailing_newline:
+            out += "\n"
+        return out.encode("utf-8")
+
+    if not files:
+        ctx.stdout.write(transform(ctx.stdin.read()))
+        return 0
+    for name in files:
+        with open(_resolve(ctx.cwd, name), "rb") as fh:
+            data = fh.read()
+        ctx.stdout.write(transform(data))
+    return 0