boomtick-cli 0.2.1__py3-none-any.whl

dev_tools/schema_utils.py

@@ -0,0 +1,125 @@
+# pylint: disable=import-outside-toplevel,missing-docstring,too-many-branches,too-many-locals,too-many-statements
+import click
+
+
+def get_type_name(param):
+    t = param.type
+    if isinstance(t, click.Choice):
+        return "choice"
+
+    t_str = str(t).lower()
+    if hasattr(t, "name"):
+        t_str = t.name.lower()
+
+    if "int" in t_str:
+        return "integer"
+    if "bool" in t_str:
+        return "boolean"
+    return "string"
+
+
+def collect_commands(root_cmd, prefix="", max_depth=10):
+    """
+    Collects leaves of the command tree iteratively using breadth-first traversal.
+    Avoids recursion limits and ensures predictable depth enforcement.
+    """
+    from collections import deque
+
+    subcmds = {}
+    # queue elements: (cmd_obj, current_prefix, depth)
+    queue = deque([(root_cmd, prefix, 0)])
+
+    while queue:
+        cmd, pfx, depth = queue.popleft()
+
+        if depth > max_depth:
+            continue
+
+        if isinstance(cmd, click.Group):
+            # Sort items once to maintain deterministic output
+            try:
+                # Using sorted() once per group is efficient enough for typical CLI trees
+                items = sorted(cmd.commands.items())
+                for sub_name, sub_cmd in items:
+                    new_prefix = f"{pfx} {sub_name}".strip()
+                    queue.append((sub_cmd, new_prefix, depth + 1))
+            except Exception:
+                pass
+        elif isinstance(cmd, click.Command):
+            cmd_name = pfx
+            cmd_help = cmd.help or ""
+
+            args_str = []
+            req_args = []
+            opt_flags = []
+            req_flags = []
+
+            for param in cmd.params:
+                param_type = get_type_name(param)
+                if isinstance(param, click.Argument):
+                    arg_name = param.name.upper()
+                    if param.nargs == -1:
+                        args_str.append(f"<{arg_name}...>")
+                    else:
+                        args_str.append(f"<{arg_name}>")
+                    req_args.append(
+                        {
+                            "name": param.name,
+                            "type": param_type,
+                            "description": getattr(param, "help", "") or "",
+                        }
+                    )
+                elif isinstance(param, click.Option):
+                    flag_name = param.opts[0]
+                    flag_desc = param.help or ""
+                    option_dict = {"flag": flag_name, "type": param_type, "description": flag_desc}
+                    if param.required:
+                        req_flags.append(option_dict)
+                    else:
+                        opt_flags.append(option_dict)
+
+            # Build a cleaner exact_usage string
+            usage = f"td-cli {cmd_name}"
+            if req_flags:
+                usage += " " + " ".join([f"{f['flag']} <{f['flag'].lstrip('-').upper()}>" for f in req_flags])
+
+            # Show a compact view of optional flags
+            boolean_flags = [f for f in opt_flags if f["type"] == "boolean"]
+            other_opt_flags = [f for f in opt_flags if f["type"] != "boolean"]
+
+            if boolean_flags:
+                usage += " " + " ".join([f"[{f['flag']}]" for f in boolean_flags])
+            if other_opt_flags:
+                usage += " " + " ".join([f"[{f['flag']} <{f['flag'].lstrip('-').upper()}>]" for f in other_opt_flags])
+
+            if args_str:
+                usage += " " + " ".join(args_str)
+
+            cmd_info = {"description": cmd_help, "exact_usage": usage}
+            if req_args:
+                cmd_info["required_arguments"] = req_args
+            if req_flags:
+                cmd_info["required_flags"] = req_flags
+            if opt_flags:
+                cmd_info["optional_flags"] = opt_flags
+
+            subcmds[cmd_name] = cmd_info
+
+    return subcmds
+
+
+def get_command_by_path(cli_root, path_str):
+    """
+    Finds a command object by its path (e.g. "gh audit-pr")
+    """
+    if not path_str:
+        return cli_root
+
+    parts = path_str.split()
+    current = cli_root
+    for part in parts:
+        if isinstance(current, click.Group) and part in current.commands:
+            current = current.commands[part]
+        else:
+            return None
+    return current

dev_tools/scope_check.py

@@ -0,0 +1,85 @@
+# pylint: disable=line-too-long,missing-docstring,no-value-for-parameter
+import sys
+from typing import Set
+
+import click
+from dev_tools.config import load_project_config
+from dev_tools.utils import log_info, run_command
+
+
+def get_changed_files():
+    """Returns the list of files changed in the current branch."""
+    config = load_project_config()
+    base = config.base_branch
+    # Use check=False to manually handle fallback
+    res = run_command(["git", "diff", "--name-only", base], check=False, log_on_error=False)
+    if res.returncode == 0:
+        return res.stdout.strip().splitlines()
+
+    res = run_command(["git", "diff", "--name-only", "HEAD"], check=False, log_on_error=False)
+    if res.returncode == 0:
+        return res.stdout.strip().splitlines()
+
+    return []
+
+
+def verify_pr_scope(file_list=None):
+    """Checks if a PR touches too many core layout/component files or mixes content scopes."""
+    if file_list is None:
+        file_list = get_changed_files()
+
+    config = load_project_config()
+    core_dirs = config.core_dirs
+    threshold = config.monolithic_pr_threshold
+
+    core_files = [f for f in file_list if any(f.startswith(d) for d in core_dirs)]
+    if len(core_files) > threshold:
+        return f"PR scope warning: Touching {len(core_files)} core files in {core_dirs}. Consider splitting this monolithic PR to avoid merge conflicts (AGENTS.md §23)."
+
+    # Content Scope Check
+    content_scopes = config.content_scopes
+
+    active_scopes: Set[str] = set()
+    for f in file_list:
+        for scope_name, prefix in content_scopes.items():
+            if f.startswith(prefix):
+                active_scopes.add(scope_name)
+
+    if len(active_scopes) > 1:
+        scope_names = ", ".join(sorted(content_scopes.keys()))
+        return f"Content scope warning: Mixed content domains detected ({', '.join(active_scopes)}). PRs should be split by scope: {scope_names} (AGENTS.md §21)."
+
+    # Mixed Content and Code Check
+    has_content = len(active_scopes) > 0
+    code_files = [f for f in file_list if f.startswith("src/") and not any(f.startswith(d) for d in core_dirs)]
+
+    if has_content and len(code_files) > 2:
+        return "PR scope warning: Mixing significant code changes with content updates. Consider splitting content corrections from feature development."
+
+    return None
+
+
+@click.command()
+@click.argument("files", nargs=-1)
+def main(files):
+    """Checks if a PR touches too many core files or mixes content scopes."""
+    file_list = list(files)
+
+    # If no files provided as arguments, check stdin (piped input)
+    if not file_list and not sys.stdin.isatty():
+        file_list = sys.stdin.read().splitlines()
+
+    # If still no files, auto-detect from git
+    if not file_list:
+        warning = verify_pr_scope()
+    else:
+        warning = verify_pr_scope(file_list)
+
+    if warning:
+        log_info(warning)
+        sys.exit(1)
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

dev_tools/services/__init__.py

@@ -0,0 +1 @@
+# pylint: disable=missing-docstring