zrb 1.0.0a14__tar.gz → 1.0.0a16__tar.gz

{zrb-1.0.0a14 → zrb-1.0.0a16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zrb
-Version: 1.0.0a14
+Version: 1.0.0a16
 Summary: Your Automation Powerhouse
 Home-page: https://github.com/state-alchemists/zrb
 License: AGPL-3.0-or-later

{zrb-1.0.0a14 → zrb-1.0.0a16}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "zrb"
-version = "1.0.0a14"
+version = "1.0.0a16"
 description = "Your Automation Powerhouse"
 authors = ["Go Frendi Gunawan <gofrendiasgard@gmail.com>"]
 license = "AGPL-3.0-or-later"

{zrb-1.0.0a14 → zrb-1.0.0a16}/src/zrb/builtin/git.py

@@ -3,7 +3,7 @@ from zrb.context.any_context import AnyContext
 from zrb.input.bool_input import BoolInput
 from zrb.input.str_input import StrInput
 from zrb.task.make_task import make_task
-from zrb.util.cli.style import stylize_green, stylize_red, stylize_yellow
+from zrb.util.cli.style import stylize_faint, stylize_green, stylize_red, stylize_yellow
 from zrb.util.git import (
     add,
     commit,
@@ -55,9 +55,11 @@ from zrb.util.git import (
     group=git_group,
     alias="diff",
 )
-def get_git_diff(ctx: AnyContext):
-    repo_dir = get_repo_dir()
-    diff = get_diff(repo_dir, ctx.input.source, ctx.input.current)
+async def get_git_diff(ctx: AnyContext):
+    repo_dir = await get_repo_dir(log_method=ctx.print)
+    diff = await get_diff(
+        repo_dir, ctx.input.source, ctx.input.current, log_method=ctx.print
+    )
     result = []
     decorated = []
     if ctx.input.created and diff.created:
@@ -83,16 +85,16 @@ def get_git_diff(ctx: AnyContext):
     group=git_branch_group,
     alias="prune",
 )
-def prune_local_branches(ctx: AnyContext):
-    repo_dir = get_repo_dir()
-    branches = get_branches(repo_dir)
-    current_branch = get_current_branch(repo_dir)
+async def prune_local_branches(ctx: AnyContext):
+    repo_dir = await get_repo_dir(log_method=ctx.print)
+    branches = await get_branches(repo_dir, log_method=ctx.print)
+    current_branch = await get_current_branch(repo_dir, log_method=ctx.print)
     for branch in branches:
         if branch == current_branch or branch == "main" or branch == "master":
             continue
-        ctx.print(stylize_yellow(f"Removing local branch: {branch}"))
+        ctx.print(stylize_faint(f"Removing local branch: {branch}"))
         try:
-            delete_branch(repo_dir, branch)
+            await delete_branch(repo_dir, branch, log_method=ctx.print)
         except Exception as e:
             ctx.log_error(e)
 
@@ -109,12 +111,12 @@ def prune_local_branches(ctx: AnyContext):
     group=git_group,
     alias="commit",
 )
-def git_commit(ctx: AnyContext):
-    repo_dir = get_repo_dir()
-    ctx.print("Add changes to staging")
-    add(repo_dir)
-    ctx.print("Commit changes")
-    commit(repo_dir, ctx.input.message)
+async def git_commit(ctx: AnyContext):
+    repo_dir = await get_repo_dir(log_method=ctx.print)
+    ctx.print(stylize_faint("Add changes to staging"))
+    await add(repo_dir, log_method=ctx.print)
+    ctx.print(stylize_faint("Commit changes"))
+    await commit(repo_dir, ctx.input.message, log_method=ctx.print)
 
 
 @make_task(
@@ -130,12 +132,12 @@ def git_commit(ctx: AnyContext):
     group=git_group,
     alias="pull",
 )
-def git_pull(ctx: AnyContext):
-    repo_dir = get_repo_dir()
+async def git_pull(ctx: AnyContext):
+    repo_dir = await get_repo_dir(log_method=ctx.print)
     remote = ctx.input.remote
-    current_branch = get_current_branch(repo_dir)
-    ctx.print(f"Pulling from {remote}/{current_branch}")
-    pull(repo_dir, remote, current_branch)
+    current_branch = await get_current_branch(repo_dir, log_method=ctx.print)
+    ctx.print(stylize_faint(f"Pulling from {remote}/{current_branch}"))
+    await pull(repo_dir, remote, current_branch, log_method=ctx.print)
 
 
 @make_task(
@@ -151,9 +153,9 @@ def git_pull(ctx: AnyContext):
     group=git_group,
     alias="push",
 )
-def git_push(ctx: AnyContext):
-    repo_dir = get_repo_dir()
+async def git_push(ctx: AnyContext):
+    repo_dir = await get_repo_dir(log_method=ctx.print)
     remote = ctx.input.remote
-    current_branch = get_current_branch(repo_dir)
-    ctx.print(f"Pushing to {remote}/{current_branch}")
-    push(repo_dir, remote, current_branch)
+    current_branch = await get_current_branch(repo_dir, log_method=ctx.print)
+    ctx.print(stylize_faint(f"Pushing to {remote}/{current_branch}"))
+    await push(repo_dir, remote, current_branch, log_method=ctx.print)

{zrb-1.0.0a14 → zrb-1.0.0a16}/src/zrb/builtin/git_subtree.py

@@ -3,6 +3,7 @@ from zrb.builtin.group import git_subtree_group
 from zrb.context.any_context import AnyContext
 from zrb.input.str_input import StrInput
 from zrb.task.make_task import make_task
+from zrb.util.cli.style import stylize_faint
 from zrb.util.git import get_repo_dir
 from zrb.util.git_subtree import add_subtree, load_config, pull_subtree, push_subtree
 
@@ -32,14 +33,15 @@ from zrb.util.git_subtree import add_subtree, load_config, pull_subtree, push_su
     group=git_subtree_group,
     alias="add",
 )
-def git_add_subtree(ctx: AnyContext):
-    repo_dir = get_repo_dir()
-    add_subtree(
+async def git_add_subtree(ctx: AnyContext):
+    repo_dir = await get_repo_dir(log_method=ctx.print)
+    await add_subtree(
         repo_dir=repo_dir,
         name=ctx.input.name,
         repo_url=ctx.input["repo-url"],
         branch=ctx.input["repo-branch"],
         prefix=ctx.input["repo-prefix"],
+        log_method=ctx.print,
     )
 
 
@@ -50,20 +52,21 @@ def git_add_subtree(ctx: AnyContext):
     group=git_subtree_group,
     alias="pull",
 )
-def git_pull_subtree(ctx: AnyContext):
-    repo_dir = get_repo_dir()
+async def git_pull_subtree(ctx: AnyContext):
+    repo_dir = await get_repo_dir(log_method=ctx.print)
     config = load_config(repo_dir)
     if not config.data:
         raise ValueError("No subtree config found")
     first_err: Exception | None = None
     for name, detail in config.data.items():
         try:
-            ctx.print(f"Pull from subtree {name}")
-            pull_subtree(
+            ctx.print(stylize_faint(f"Pull from subtree {name}"))
+            await pull_subtree(
                 repo_dir=repo_dir,
                 prefix=detail.prefix,
                 repo_url=detail.repo_url,
                 branch=detail.branch,
+                log_method=ctx.print,
             )
         except Exception as e:
             if first_err is None:
@@ -80,20 +83,21 @@ def git_pull_subtree(ctx: AnyContext):
     group=git_subtree_group,
     alias="push",
 )
-def git_push_subtree(ctx: AnyContext):
-    repo_dir = get_repo_dir()
+async def git_push_subtree(ctx: AnyContext):
+    repo_dir = await get_repo_dir(log_method=ctx.print)
     config = load_config(repo_dir)
     if not config.data:
         raise ValueError("No subtree config found")
     first_err: Exception | None = None
     for name, detail in config.data.items():
         try:
-            ctx.print(f"Push to subtree {name}")
-            push_subtree(
+            ctx.print(stylize_faint(f"Push to subtree {name}"))
+            await push_subtree(
                 repo_dir=repo_dir,
                 prefix=detail.prefix,
                 repo_url=detail.repo_url,
                 branch=detail.branch,
+                log_method=ctx.print,
             )
         except Exception as e:
             if first_err is None:

{zrb-1.0.0a14 → zrb-1.0.0a16}/src/zrb/task/cmd_task.py

@@ -1,6 +1,4 @@
-import asyncio
 import os
-import sys
 
 from zrb.attr.type import BoolAttr, IntAttr, StrAttr
 from zrb.cmd.cmd_result import CmdResult
@@ -12,7 +10,7 @@ from zrb.input.any_input import AnyInput
 from zrb.task.any_task import AnyTask
 from zrb.task.base_task import BaseTask
 from zrb.util.attr import get_int_attr, get_str_attr
-from zrb.util.cmd.command import check_unrecommended_commands
+from zrb.util.cmd.command import check_unrecommended_commands, run_command
 from zrb.util.cmd.remote import get_remote_cmd_script
 
 
@@ -119,43 +117,25 @@ class CmdTask(BaseTask):
         ctx.log_debug(f"Working directory: {cwd}")
         env_map = self.__get_env_map(ctx)
         ctx.log_debug(f"Environment map: {env_map}")
-        cmd_process = None
         if self._get_should_warn_unrecommended_commands():
             self._check_unrecommended_commands(ctx, shell, cmd_script)
-        try:
-            ctx.log_info("Running script")
-            cmd_process = await asyncio.create_subprocess_exec(
-                shell,
-                shell_flag,
-                cmd_script,
-                cwd=cwd,
-                stdin=sys.stdin if sys.stdin.isatty() else None,
-                stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.PIPE,
-                env=env_map,
-                bufsize=0,
-            )
-            stdout_task = asyncio.create_task(
-                self.__read_stream(cmd_process.stdout, ctx.print, self._max_output_line)
-            )
-            stderr_task = asyncio.create_task(
-                self.__read_stream(cmd_process.stderr, ctx.print, self._max_error_line)
+        ctx.log_info("Running script")
+        cmd_result, return_code = await run_command(
+            cmd=[shell, shell_flag, cmd_script],
+            cwd=cwd,
+            env_map=env_map,
+            log_method=ctx.print,
+            max_output_line=self._max_output_line,
+            max_error_line=self._max_error_line,
+        )
+        # Check for errors
+        if return_code != 0:
+            ctx.log_error(f"Exit status: {return_code}")
+            raise Exception(
+                f"Process {self._name} exited ({return_code}): {cmd_result.stderr}"
             )
-            # Wait for process to complete and gather stdout/stderr
-            return_code = await cmd_process.wait()
-            stdout = await stdout_task
-            stderr = await stderr_task
-            # Check for errors
-            if return_code != 0:
-                ctx.log_error(f"Exit status: {return_code}")
-                raise Exception(
-                    f"Process {self._name} exited ({return_code}): {stderr}"
-                )
-            ctx.log_info(f"Exit status: {return_code}")
-            return CmdResult(stdout, stderr)
-        finally:
-            if cmd_process is not None and cmd_process.returncode is None:
-                cmd_process.terminate()
+        ctx.log_info(f"Exit status: {return_code}")
+        return cmd_result
 
     def _get_should_warn_unrecommended_commands(self):
         if self._should_warn_unrecommended_command is None:
@@ -178,19 +158,6 @@ class CmdTask(BaseTask):
         envs["PYTHONBUFFERED"] = "1"
         return envs
 
-    async def __read_stream(self, stream, log_method, max_lines):
-        lines = []
-        while True:
-            line = await stream.readline()
-            if not line:
-                break
-            line = line.decode("utf-8").rstrip()
-            lines.append(line)
-            if len(lines) > max_lines:
-                lines.pop(0)  # Keep only the last max_lines
-            log_method(line)
-        return "\n".join(lines)
-
     def _get_shell(self, ctx: AnyContext) -> str:
         return get_str_attr(
             ctx, self._shell, DEFAULT_SHELL, auto_render=self._render_shell

zrb-1.0.0a16/src/zrb/util/cmd/command.py

@@ -0,0 +1,93 @@
+import asyncio
+import os
+import re
+import sys
+from collections.abc import Callable
+
+from zrb.cmd.cmd_result import CmdResult
+
+
+def check_unrecommended_commands(cmd_script: str) -> dict[str, str]:
+    banned_commands = {
+        "<(": "Process substitution isn't POSIX compliant and causes trouble",
+        "column": "Command isn't included in Ubuntu packages and is not POSIX compliant",
+        "echo": "echo isn't consistent across OS; use printf instead",
+        "eval": "Avoid eval as it can accidentally execute arbitrary strings",
+        "realpath": "Not available by default on OSX",
+        "source": "Not POSIX compliant; use '.' instead",
+        " test": "Use '[' instead for consistency",
+        "which": "Command in not POSIX compliant, use command -v",
+    }
+    banned_commands_regex = {
+        r"grep.* -y": "grep -y does not work on Alpine; use grep -i",
+        r"grep.* -P": "grep -P is not valid on OSX",
+        r"grep[^|]+--\w{2,}": "grep long commands do not work on Alpine",
+        r'readlink.+-.*f.+["$]': "readlink -f behaves differently on OSX",
+        r"sort.*-V": "sort -V is not supported everywhere",
+        r"sort.*--sort-versions": "sort --sort-version is not supported everywhere",
+        r"\bls ": "Avoid using ls; use shell globs or find instead",
+    }
+    violations = {}
+    # Check banned commands
+    for cmd, reason in banned_commands.items():
+        if cmd in cmd_script:
+            violations[cmd] = reason
+    # Check banned regex patterns
+    for pattern, reason in banned_commands_regex.items():
+        if re.search(pattern, cmd_script):
+            violations[pattern] = reason
+    return violations
+
+
+async def run_command(
+    cmd: list[str],
+    cwd: str | None = None,
+    env_map: dict[str, str] | None = None,
+    log_method: Callable[..., None] = print,
+    max_output_line: int = 1000,
+    max_error_line: int = 1000,
+) -> tuple[CmdResult, int]:
+
+    async def __read_stream(
+        stream, log_method: Callable[..., None], max_lines: int
+    ) -> str:
+        lines = []
+        while True:
+            line = await stream.readline()
+            if not line:
+                break
+            line = line.decode("utf-8").rstrip()
+            lines.append(line)
+            if len(lines) > max_lines:
+                lines.pop(0)  # Keep only the last max_lines
+            log_method(line)
+        return "\n".join(lines)
+
+    try:
+        if cwd is None:
+            cwd = os.getcwd()
+        if env_map is None:
+            env_map = os.environ
+        cmd_process = await asyncio.create_subprocess_exec(
+            *cmd,
+            cwd=cwd,
+            stdin=sys.stdin if sys.stdin.isatty() else None,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            env=env_map,
+            bufsize=0,
+        )
+        stdout_task = asyncio.create_task(
+            __read_stream(cmd_process.stdout, log_method, max_output_line)
+        )
+        stderr_task = asyncio.create_task(
+            __read_stream(cmd_process.stderr, log_method, max_error_line)
+        )
+        # Wait for process to complete and gather stdout/stderr
+        return_code = await cmd_process.wait()
+        stdout = await stdout_task
+        stderr = await stderr_task
+        return CmdResult(stdout, stderr), return_code
+    finally:
+        if cmd_process is not None and cmd_process.returncode is None:
+            cmd_process.terminate()

zrb-1.0.0a16/src/zrb/util/git.py

@@ -0,0 +1,156 @@
+import os
+from collections.abc import Callable
+from typing import Any
+
+from pydantic import BaseModel
+
+from zrb.util.cmd.command import run_command
+
+
+class DiffResult(BaseModel):
+    created: list[str]
+    removed: list[str]
+    updated: list[str]
+
+
+async def get_diff(
+    repo_dir: str,
+    source_commit: str,
+    current_commit: str,
+    log_method: Callable[..., Any] = print,
+) -> DiffResult:
+    cmd_result, exit_code = await run_command(
+        cmd=["git", "diff", source_commit, current_commit],
+        cwd=repo_dir,
+        log_method=log_method,
+    )
+    if exit_code != 0:
+        raise Exception(f"Non zero exit code: {exit_code}")
+    lines = cmd_result.output.strip().split("\n")
+    diff: dict[str, dict[str, bool]] = {}
+    for line in lines:
+        if not line.startswith("---") and not line.startswith("+++"):
+            continue
+        if line[4:6] != "a/" and line[4:6] != "b/":
+            continue
+        # line should contains something like `--- a/some-file.txt`
+        file = line[6:]
+        if file not in diff:
+            diff[file] = {"plus": False, "minus": False}
+        if line.startswith("---"):
+            diff[file]["minus"] = True
+        if line.startswith("+++"):
+            diff[file]["plus"] = True
+    return DiffResult(
+        created=[
+            file for file, state in diff.items() if state["plus"] and not state["minus"]
+        ],
+        removed=[
+            file for file, state in diff.items() if not state["plus"] and state["minus"]
+        ],
+        updated=[
+            file for file, state in diff.items() if state["plus"] and state["minus"]
+        ],
+    )
+
+
+async def get_repo_dir(log_method: Callable[..., Any] = print) -> str:
+    cmd_result, exit_code = await run_command(
+        cmd=["git", "rev-parse", "--show-toplevel"],
+        log_method=log_method,
+    )
+    if exit_code != 0:
+        raise Exception(f"Non zero exit code: {exit_code}")
+    return os.path.abspath(cmd_result.output.strip())
+
+
+async def get_current_branch(
+    repo_dir: str, log_method: Callable[..., Any] = print
+) -> str:
+    cmd_result, exit_code = await run_command(
+        cmd=["git", "rev-parse", "--abbrev-ref", "HEAD"],
+        cwd=repo_dir,
+        log_method=log_method,
+    )
+    if exit_code != 0:
+        raise Exception(f"Non zero exit code: {exit_code}")
+    return cmd_result.output.strip()
+
+
+async def get_branches(
+    repo_dir: str, log_method: Callable[..., Any] = print
+) -> list[str]:
+    cmd_result, exit_code = await run_command(
+        cmd=["git", "rev-parse", "--abbrev-ref", "HEAD"],
+        cwd=repo_dir,
+        log_method=log_method,
+    )
+    if exit_code != 0:
+        raise Exception(f"Non zero exit code: {exit_code}")
+    return [
+        branch.lstrip("*").strip() for branch in cmd_result.output.strip().split("\n")
+    ]
+
+
+async def delete_branch(
+    repo_dir: str, branch_name: str, log_method: Callable[..., Any] = print
+) -> str:
+    cmd_result, exit_code = await run_command(
+        cmd=["git", "branch", "-D", branch_name],
+        cwd=repo_dir,
+        log_method=log_method,
+    )
+    if exit_code != 0:
+        raise Exception(f"Non zero exit code: {exit_code}")
+    return cmd_result.output.strip()
+
+
+async def add(repo_dir: str, log_method: Callable[..., Any] = print):
+    _, exit_code = await run_command(
+        cmd=["git", "add", ".", "-A"],
+        cwd=repo_dir,
+        log_method=log_method,
+    )
+    if exit_code != 0:
+        raise Exception(f"Non zero exit code: {exit_code}")
+
+
+async def commit(
+    repo_dir: str, message: str, log_method: Callable[..., Any] = print
+) -> str:
+    cmd_result, exit_code = await run_command(
+        cmd=["git", "commit", "-m", message],
+        cwd=repo_dir,
+        log_method=log_method,
+    )
+    if exit_code != 0:
+        ignored_error_message = "nothing to commit, working tree clean"
+        if (
+            ignored_error_message not in cmd_result.error
+            and ignored_error_message not in cmd_result.output
+        ):
+            raise Exception(f"Non zero exit code: {exit_code}")
+
+
+async def pull(
+    repo_dir: str, remote: str, branch: str, log_method: Callable[..., Any] = print
+) -> str:
+    _, exit_code = await run_command(
+        cmd=["git", "pull", remote, branch],
+        cwd=repo_dir,
+        log_method=log_method,
+    )
+    if exit_code != 0:
+        raise Exception(f"Non zero exit code: {exit_code}")
+
+
+async def push(
+    repo_dir: str, remote: str, branch: str, log_method: Callable[..., Any] = print
+) -> str:
+    _, exit_code = await run_command(
+        cmd=["git", "push", "-u", remote, branch],
+        cwd=repo_dir,
+        log_method=log_method,
+    )
+    if exit_code != 0:
+        raise Exception(f"Non zero exit code: {exit_code}")

zrb-1.0.0a16/src/zrb/util/git_subtree.py

@@ -0,0 +1,113 @@
+import os
+from collections.abc import Callable
+from typing import Any
+
+from pydantic import BaseModel
+
+from zrb.util.cmd.command import run_command
+
+
+class SingleSubTreeConfig(BaseModel):
+    repo_url: str
+    branch: str
+    prefix: str
+
+
+class SubTreeConfig(BaseModel):
+    data: dict[str, SingleSubTreeConfig]
+
+
+def load_config(repo_dir: str) -> SubTreeConfig:
+    file_path = os.path.join(repo_dir, "subtrees.json")
+    if not os.path.exists(file_path):
+        return SubTreeConfig(data={})
+    with open(file_path, "r") as f:
+        return SubTreeConfig.model_validate_json(f.read())
+
+
+def save_config(repo_dir: str, config: SubTreeConfig):
+    file_path = os.path.join(repo_dir, "subtrees.json")
+    with open(file_path, "w") as f:
+        f.write(config.model_dump_json(indent=2))
+
+
+async def add_subtree(
+    repo_dir: str,
+    name: str,
+    repo_url: str,
+    branch: str,
+    prefix: str,
+    log_method: Callable[..., Any] = print,
+):
+    config = load_config()
+    if os.path.isdir(prefix):
+        raise ValueError(f"Directory exists: {prefix}")
+    if name in config.data:
+        raise ValueError(f"Subtree config already exists: {name}")
+    _, exit_code = await run_command(
+        cmd=[
+            "git",
+            "subtree",
+            "add",
+            "--prefix",
+            prefix,
+            repo_url,
+            branch,
+        ],
+        cwd=repo_dir,
+        log_method=log_method,
+    )
+    if exit_code != 0:
+        raise Exception(f"Non zero exit code: {exit_code}")
+    config.data[name] = SingleSubTreeConfig(
+        repo_url=repo_url, branch=branch, prefix=prefix
+    )
+    save_config(repo_dir, config)
+
+
+async def pull_subtree(
+    repo_dir: str,
+    prefix: str,
+    repo_url: str,
+    branch: str,
+    log_method: Callable[..., Any] = print,
+):
+    _, exit_code = await run_command(
+        cmd=[
+            "git",
+            "subtree",
+            "pull",
+            "--prefix",
+            prefix,
+            repo_url,
+            branch,
+        ],
+        cwd=repo_dir,
+        log_method=log_method,
+    )
+    if exit_code != 0:
+        raise Exception(f"Non zero exit code: {exit_code}")
+
+
+async def push_subtree(
+    repo_dir: str,
+    prefix: str,
+    repo_url: str,
+    branch: str,
+    log_method: Callable[..., Any] = print,
+):
+    _, exit_code = await run_command(
+        cmd=[
+            "git",
+            "subtree",
+            "push",
+            "--prefix",
+            prefix,
+            repo_url,
+            branch,
+        ],
+        cwd=repo_dir,
+        log_method=log_method,
+    )
+    if exit_code != 0:
+        raise Exception(f"Non zero exit code: {exit_code}")

zrb-1.0.0a14/src/zrb/util/cmd/command.py

@@ -1,33 +0,0 @@
-import re
-
-
-def check_unrecommended_commands(cmd_script: str) -> dict[str, str]:
-    banned_commands = {
-        "<(": "Process substitution isn't POSIX compliant and causes trouble",
-        "column": "Command isn't included in Ubuntu packages and is not POSIX compliant",
-        "echo": "echo isn't consistent across OS; use printf instead",
-        "eval": "Avoid eval as it can accidentally execute arbitrary strings",
-        "realpath": "Not available by default on OSX",
-        "source": "Not POSIX compliant; use '.' instead",
-        " test": "Use '[' instead for consistency",
-        "which": "Command in not POSIX compliant, use command -v",
-    }
-    banned_commands_regex = {
-        r"grep.* -y": "grep -y does not work on Alpine; use grep -i",
-        r"grep.* -P": "grep -P is not valid on OSX",
-        r"grep[^|]+--\w{2,}": "grep long commands do not work on Alpine",
-        r'readlink.+-.*f.+["$]': "readlink -f behaves differently on OSX",
-        r"sort.*-V": "sort -V is not supported everywhere",
-        r"sort.*--sort-versions": "sort --sort-version is not supported everywhere",
-        r"\bls ": "Avoid using ls; use shell globs or find instead",
-    }
-    violations = {}
-    # Check banned commands
-    for cmd, reason in banned_commands.items():
-        if cmd in cmd_script:
-            violations[cmd] = reason
-    # Check banned regex patterns
-    for pattern, reason in banned_commands_regex.items():
-        if re.search(pattern, cmd_script):
-            violations[pattern] = reason
-    return violations