gd-tools-cli 0.1.4__tar.gz → 0.2.0__tar.gz

{gd_tools_cli-0.1.4 → gd_tools_cli-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gd-tools-cli
-Version: 0.1.4
+Version: 0.2.0
 Summary: A modern development workflow CLI for GDScript projects in Godot 4.5+
 Author-email: mansyar <m.ansyarafi@gmail.com>
 License: MIT
@@ -31,6 +31,7 @@ Requires-Dist: tomli; python_version < "3.11"
 Requires-Dist: tomli_w
 Requires-Dist: pydantic>=2.0
 Requires-Dist: requests
+Requires-Dist: packaging
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
@@ -108,9 +109,9 @@ gd-tools test --coverage --min 80
 |---------|-------------|
 | `gd-tools init` | Bootstrap a Godot project -- install GUT, deploy coverage addon, generate configs. |
 | `gd-tools doctor` | Diagnose the development environment -- Godot, GUT, coverage addon, tooling. |
-| `gd-tools test` | Run GUT tests with optional coverage, thresholds, JUnit XML output. |
-| `gd-tools lint` | Lint GDScript files using gdlint with text or JSON output. |
-| `gd-tools format` | Format GDScript files using gdformat with check and diff modes. |
+| `gd-tools test` | Run GUT tests with optional coverage, thresholds, JUnit XML output. Accepts optional path arguments to override configured test directories. |
+| `gd-tools lint` | Lint GDScript files using gdlint with text or JSON output. Accepts one or more file or directory paths. |
+| `gd-tools format` | Format GDScript files using gdformat with check and diff modes. Accepts one or more file or directory paths. |
 | `gd-tools coverage` | Coverage subcommands -- `report`, `merge`, `show`. |
 
 See the [User Guide](./docs/USER_GUIDE.md) for full command reference,

{gd_tools_cli-0.1.4 → gd_tools_cli-0.2.0}/README.md

@@ -68,9 +68,9 @@ gd-tools test --coverage --min 80
 |---------|-------------|
 | `gd-tools init` | Bootstrap a Godot project -- install GUT, deploy coverage addon, generate configs. |
 | `gd-tools doctor` | Diagnose the development environment -- Godot, GUT, coverage addon, tooling. |
-| `gd-tools test` | Run GUT tests with optional coverage, thresholds, JUnit XML output. |
-| `gd-tools lint` | Lint GDScript files using gdlint with text or JSON output. |
-| `gd-tools format` | Format GDScript files using gdformat with check and diff modes. |
+| `gd-tools test` | Run GUT tests with optional coverage, thresholds, JUnit XML output. Accepts optional path arguments to override configured test directories. |
+| `gd-tools lint` | Lint GDScript files using gdlint with text or JSON output. Accepts one or more file or directory paths. |
+| `gd-tools format` | Format GDScript files using gdformat with check and diff modes. Accepts one or more file or directory paths. |
 | `gd-tools coverage` | Coverage subcommands -- `report`, `merge`, `show`. |
 
 See the [User Guide](./docs/USER_GUIDE.md) for full command reference,

{gd_tools_cli-0.1.4 → gd_tools_cli-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gd-tools-cli"
-version = "0.1.4"
+version = "0.2.0"
 description = "A modern development workflow CLI for GDScript projects in Godot 4.5+"
 readme = "README.md"
 license = {text = "MIT"}
@@ -36,6 +36,7 @@ dependencies = [
     "tomli_w",
     "pydantic >= 2.0",
     "requests",
+    "packaging",
 ]
 
 [project.urls]
@@ -98,7 +99,7 @@ target-version = ["py310"]
 
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "0.1.4"
+version = "0.2.0"
 version_files = ["pyproject.toml:version"]
 changelog_file = "CHANGELOG.md"
 tag_format = "v$version"

{gd_tools_cli-0.1.4 → gd_tools_cli-0.2.0}/src/gd_tools/addons/gd-tools-coverage/pre_run_hook.gd

@@ -59,16 +59,22 @@ func _instrument_file(file_entry: Dictionary) -> bool:
 		)
 		return false
 
-	var source: String = script.source_code
-	var instrumented: String = _inject_trackers(source, file_id, lines)
+	var original_source: String = script.source_code
+	var instrumented: String = _inject_trackers(original_source, file_id, lines)
 	script.source_code = instrumented
 	var err: int = script.reload()
+	if err == ERR_ALREADY_IN_USE:
+		print("[gd-tools] [Warning] Skipping instrumented script with active instances: " + path)
+		script.source_code = original_source
+		return false
 	if err != OK:
 		_log_error(
 			"Failed to reload instrumented script.",
 			"reload() failed for: " + path,
 			"Check tracker injection logic for syntax errors."
 		)
+		script.source_code = original_source
+		script.reload()
 		return false
 
 	return true

{gd_tools_cli-0.1.4 → gd_tools_cli-0.2.0}/src/gd_tools/cli.py

@@ -27,6 +27,7 @@ from .format_runner import run_format
 from .init import run_init
 from .lint_runner import format_lint_json, format_lint_text, run_lint
 from .test_runner import run_tests
+from .update_check import check_for_update
 
 
 def _configure_windows_utf8() -> None:
@@ -63,6 +64,10 @@ class GdToolsGroup(click.Group):
     def invoke(self, ctx) -> Any:
         """Invoke the group, catching NotImplementedError as exit code 2.
 
+        Performs an update check before dispatching to the subcommand.
+        If a newer version is available, a notification is printed to
+        stderr. The check fails silently and never blocks execution.
+
         Args:
             ctx: The Click context for this invocation.
 
@@ -73,6 +78,14 @@ class GdToolsGroup(click.Group):
             SystemExit: With code 2 if a command raises
                 NotImplementedError.
         """
+        latest = check_for_update()
+        if latest is not None:
+            click.echo(
+                f"A new version of gd-tools is available: {latest} "
+                f"(you have {__version__}).\n"
+                f"Run `pip install --upgrade gd-tools-cli` to update.",
+                err=True,
+            )
         try:
             return super().invoke(ctx)
         except NotImplementedError:
@@ -123,6 +136,7 @@ def doctor():
 
 
 @cli.command()
+@click.argument("paths", nargs=-1)
 @click.option("--coverage", is_flag=True, help="Generate coverage report.")
 @click.option("--min", type=int, help="Minimum coverage threshold.")
 @click.option("--suite", help="Specify which test suite to run.")
@@ -138,7 +152,7 @@ def doctor():
     type=int,
     help="Timeout in seconds for the test run.",
 )
-def test(coverage, min, suite, test, junit_xml, no_exit_code, timeout):
+def test(paths, coverage, min, suite, test, junit_xml, no_exit_code, timeout):
     """Run GDScript tests using GUT."""
     try:
         config = load_config()
@@ -164,6 +178,7 @@ def test(coverage, min, suite, test, junit_xml, no_exit_code, timeout):
                 no_exit_code=no_exit_code,
                 min_percent=min,
                 timeout=timeout,
+                paths=list(paths) if paths else None,
             )
         else:
             run_tests(
@@ -175,6 +190,7 @@ def test(coverage, min, suite, test, junit_xml, no_exit_code, timeout):
                 junit_xml=junit_xml,
                 no_exit_code=no_exit_code,
                 timeout=timeout,
+                paths=list(paths) if paths else None,
             )
     except TestFailureError as e:
         click.echo(f"Error: {e}", err=True)
@@ -190,7 +206,7 @@ def test(coverage, min, suite, test, junit_xml, no_exit_code, timeout):
 
 
 @cli.command()
-@click.argument("path", required=False, default=".")
+@click.argument("paths", nargs=-1)
 @click.option(
     "--report-format",
     type=click.Choice(["text", "json"]),
@@ -202,7 +218,7 @@ def test(coverage, min, suite, test, junit_xml, no_exit_code, timeout):
     is_flag=True,
     help="Attempt to fix lint issues (no-op for gdlint).",
 )
-def lint(path, report_format, fix):
+def lint(paths, report_format, fix):
     """Lint GDScript files."""
     if fix:
         click.echo(
@@ -216,7 +232,7 @@ def lint(path, report_format, fix):
         ctx = click.get_current_context()
         ctx.exit(2)
 
-    result = run_lint(config, path, report_format)
+    result = run_lint(config, list(paths), report_format)
 
     if report_format == "json":
         output = format_lint_json(result)
@@ -232,10 +248,10 @@ def lint(path, report_format, fix):
 
 
 @cli.command()
-@click.argument("path", required=False, default=".")
+@click.argument("paths", nargs=-1)
 @click.option("--check", is_flag=True, help="Check only, don't modify files.")
 @click.option("--diff", is_flag=True, help="Show diff of changes.")
-def format(path, check, diff):
+def format(paths, check, diff):
     """Format GDScript files."""
     if check and diff:
         click.echo("Error: --check and --diff are mutually exclusive", err=True)
@@ -249,7 +265,7 @@ def format(path, check, diff):
         ctx = click.get_current_context()
         ctx.exit(2)
 
-    result = run_format(config, path, check=check, diff=diff)
+    result = run_format(config, list(paths), check=check, diff=diff)
 
     ctx = click.get_current_context()
     if result.files_checked == 0:

{gd_tools_cli-0.1.4 → gd_tools_cli-0.2.0}/src/gd_tools/coverage/orchestrator.py

@@ -36,6 +36,7 @@ def run_coverage_test(
     no_exit_code: bool = False,
     min_percent: int | None = None,
     timeout: int | None = None,
+    paths: list[str] | None = None,
 ) -> TestResult:
     """Run tests with coverage instrumentation and generate reports.
 
@@ -94,6 +95,7 @@ def run_coverage_test(
             junit_xml=junit_xml,
             no_exit_code=no_exit_code,
             timeout=timeout,
+            paths=paths,
         )
     except TestFailureError as exc:
         test_error = exc

{gd_tools_cli-0.1.4 → gd_tools_cli-0.2.0}/src/gd_tools/coverage/plan_generator.py

@@ -306,6 +306,53 @@ class CoverageVisitor(Visitor):
 # --- Plan Generation (FR-4, FR-6) ---
 
 
+def resolve_autoload_paths(project_root: str) -> list[str]:
+    """Read ``project.godot`` and resolve autoload script paths.
+
+    Parses the ``[autoload]`` section of ``project.godot`` and returns
+    a list of script paths relative to ``project_root`` (using forward
+    slashes, matching Godot's ``res://`` convention).
+
+    Args:
+        project_root: Root directory of the Godot project.
+
+    Returns:
+        List of relative paths for autoload scripts. Returns an empty
+        list if ``project.godot`` doesn't exist or has no ``[autoload]``
+        section.
+    """
+    project_file = Path(project_root) / "project.godot"
+    if not project_file.exists():
+        return []
+
+    lines = project_file.read_text(encoding="utf-8").splitlines()
+
+    in_autoload = False
+    paths: list[str] = []
+    for line in lines:
+        stripped = line.strip()
+        if stripped.startswith("[") and stripped.endswith("]"):
+            in_autoload = stripped == "[autoload]"
+            continue
+        if not in_autoload:
+            continue
+        if not stripped or stripped.startswith(";") or stripped.startswith("#"):
+            continue
+        if "=" not in stripped:
+            continue
+        # Parse key="value"
+        _, _, value = stripped.partition("=")
+        value = value.strip().strip('"').strip("'")
+        if value.startswith("*"):
+            value = value[1:]
+        if value.startswith("res://"):
+            value = value[len("res://") :]
+        if value:
+            paths.append(value.replace("\\", "/"))
+
+    return paths
+
+
 def generate_plan(
     project_root: str,
     exclude_dirs: list[str] | None = None,
@@ -345,6 +392,18 @@ def generate_plan(
         if not any(td in PurePath(f).parts for td in test_dirs)
     ]
 
+    # Filter out autoload scripts — they have active instances and
+    # cannot be safely instrumented (FR-2)
+    autoload_paths = resolve_autoload_paths(project_root)
+    if autoload_paths:
+        autoload_set = {ap.replace("\\", "/") for ap in autoload_paths}
+        gd_files = [
+            f
+            for f in gd_files
+            if str(Path(f).relative_to(project_root)).replace("\\", "/")
+            not in autoload_set
+        ]
+
     file_plans: list[FilePlan] = []
     console = Console()
     for file_id, gd_file in enumerate(gd_files):

gd_tools_cli-0.2.0/src/gd_tools/file_discovery.py

@@ -0,0 +1,69 @@
+"""Shared file discovery module for gd-tools.
+
+Discovers ``.gd`` files under a given path, applying exclude
+patterns from the configuration. Used by both the lint runner
+and the format runner.
+"""
+
+import os
+
+from gd_tools.config import DEFAULT_EXCLUDES
+
+
+def discover_gd_files(
+    path: str, excludes: list[str] | None = None
+) -> list[str]:
+    """Discover ``.gd`` files in ``path``, skipping excluded directories.
+
+    Exclude entries are interpreted with hybrid matching:
+
+    - **Bare names** (no path separator, e.g. ``addons``, ``.godot``)
+      match any directory *basename* at any depth (backward compatible
+      with :data:`DEFAULT_EXCLUDES`).
+    - **Path prefixes** (containing ``/`` or ``\\``, e.g.
+      ``scripts/autoload``) match as a path prefix relative to the
+      search root — any file whose relative path starts with the
+      prefix is excluded.
+
+    Args:
+        path: Root directory to search.
+        excludes: Exclude entries (bare names or path prefixes).
+            Defaults to :data:`DEFAULT_EXCLUDES` from ``config.py``.
+
+    Returns:
+        List of file paths (as strings) to ``.gd`` files.
+    """
+    if excludes is None:
+        excludes = DEFAULT_EXCLUDES
+
+    bare_excludes: set[str] = set()
+    path_excludes: list[str] = []
+    for entry in excludes:
+        if "/" in entry or "\\" in entry:
+            # Normalize separators to the OS-native form
+            path_excludes.append(
+                entry.replace("\\", os.sep).replace("/", os.sep)
+            )
+        else:
+            bare_excludes.add(entry)
+
+    gd_files: list[str] = []
+    for root, dirs, files in os.walk(path):
+        # Prune basename-excluded dirs in-place so os.walk doesn't descend
+        dirs[:] = [d for d in dirs if d not in bare_excludes]
+        for file in files:
+            if file.lower().endswith(".gd"):
+                file_path = os.path.join(root, file)
+                if path_excludes:
+                    rel_path = os.path.relpath(file_path, path)
+                    normalized = rel_path.replace("\\", os.sep).replace(
+                        "/", os.sep
+                    )
+                    if any(
+                        normalized == prefix
+                        or normalized.startswith(prefix + os.sep)
+                        for prefix in path_excludes
+                    ):
+                        continue
+                gd_files.append(file_path)
+    return gd_files

{gd_tools_cli-0.1.4 → gd_tools_cli-0.2.0}/src/gd_tools/format_runner.py

@@ -46,15 +46,16 @@ class FormatResult:
 
 def run_format(
     config: GdToolsConfig,
-    path: str = ".",
+    paths: list[str] | None = None,
     check: bool = False,
     diff: bool = False,
 ) -> FormatResult:
-    """Format ``.gd`` files in ``path`` using the gdtoolkit formatter.
+    """Format ``.gd`` files in ``paths`` using the gdtoolkit formatter.
 
     Args:
         config: Project configuration with format excludes.
-        path: Root directory to search for .gd files.
+        paths: Root directories to search for .gd files. Defaults to
+            ``["."]``.
         check: If True, report files needing format without modifying.
         diff: If True, show unified diffs without modifying.
 
@@ -64,6 +65,9 @@ def run_format(
     Raises:
         FormatError: If both check and diff are True (mutually exclusive).
     """
+    if not paths:
+        paths = ["."]
+
     if check and diff:
         raise FormatError(
             "--check and --diff are mutually exclusive",
@@ -71,7 +75,10 @@ def run_format(
         )
 
     excludes = config.format.exclude
-    gd_files = discover_gd_files(path, excludes)
+    gd_files: list[str] = []
+    for p in paths:
+        gd_files.extend(discover_gd_files(p, excludes))
+    gd_files = list(dict.fromkeys(gd_files))
 
     if not gd_files:
         return FormatResult()

{gd_tools_cli-0.1.4 → gd_tools_cli-0.2.0}/src/gd_tools/lint_runner.py

@@ -57,9 +57,11 @@ class LintResult:
 
 
 def run_lint(
-    config: GdToolsConfig, path: str = ".", report_format: str = "text"
+    config: GdToolsConfig,
+    paths: list[str] | None = None,
+    report_format: str = "text",
 ) -> LintResult:
-    """Run gdlint on ``path``, respecting config excludes.
+    """Run gdlint on ``paths``, respecting config excludes.
 
     Discovers ``.gd`` files via :func:`discover_gd_files`, reads each
     file, and invokes ``gdtoolkit.linter.lint_code`` to check for
@@ -68,7 +70,7 @@ def run_lint(
 
     Args:
         config: Project configuration with lint excludes.
-        path: Root directory to lint.
+        paths: Root directories to lint. Defaults to ``["."]``.
         report_format: Output format hint (unused here; formatting
             is handled by :func:`format_lint_text` /
             :func:`format_lint_json`).
@@ -76,8 +78,14 @@ def run_lint(
     Returns:
         :class:`LintResult` with file count and issue lists.
     """
+    if not paths:
+        paths = ["."]
+
     excludes = config.lint.exclude
-    gd_files = discover_gd_files(path, excludes)
+    gd_files: list[str] = []
+    for p in paths:
+        gd_files.extend(discover_gd_files(p, excludes))
+    gd_files = list(dict.fromkeys(gd_files))
 
     errors: list[LintIssue] = []
     warnings: list[LintIssue] = []

{gd_tools_cli-0.1.4 → gd_tools_cli-0.2.0}/src/gd_tools/test_runner.py

@@ -84,6 +84,7 @@ def build_gut_args(
     test_name: str | None = None,
     junit_xml: str | None = None,
     coverage: bool = False,
+    paths: list[str] | None = None,
 ) -> list[str]:
     """Build GUT CLI arguments from test configuration.
 
@@ -101,6 +102,8 @@ def build_gut_args(
             ``<project_root>/.gd-tools/results.xml``.
         coverage: Whether coverage hooks should be included. When True,
             adds ``-gpre_run_script`` and ``-gpost_run_script`` args.
+        paths: Optional test directories that override
+            ``config.test_dirs`` for this invocation.
 
     Returns:
         List of CLI arguments for Godot/GUT.
@@ -113,8 +116,10 @@ def build_gut_args(
     ]
 
     # Test directories (comma-separated per GUT 9.x CLI spec).
-    if config.test_dirs:
-        dirs = ",".join(f"res://{d}/" for d in config.test_dirs)
+    # Use paths override if provided, otherwise fall back to config.
+    test_dirs = paths if paths else config.test_dirs
+    if test_dirs:
+        dirs = ",".join(f"res://{d}/" for d in test_dirs)
         args.append(f"-gdir={dirs}")
 
     # Prefix/suffix for test file discovery.
@@ -320,6 +325,7 @@ def run_tests(
     junit_xml: str | None = None,
     no_exit_code: bool = False,
     timeout: int | None = 300,
+    paths: list[str] | None = None,
 ) -> TestResult:
     """Run GUT tests via the Godot CLI.
 
@@ -393,6 +399,7 @@ def run_tests(
         test_name=test_name,
         junit_xml=junit_xml,
         coverage=coverage,
+        paths=paths,
     )
 
     # Set up environment variables for coverage.

gd_tools_cli-0.2.0/src/gd_tools/update_check.py

@@ -0,0 +1,117 @@
+"""PyPI update notification module.
+
+Checks PyPI for a newer version of ``gd-tools-cli`` and caches the
+result locally (24h TTL) to avoid network calls on every invocation.
+Fails silently on any error and can be disabled via the
+``GD_TOOLS_NO_UPDATE_CHECK`` environment variable.
+"""
+
+import json
+import os
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Optional
+
+import requests
+from packaging.version import parse as parse_version
+
+from gd_tools import __version__
+
+PYPI_URL = "https://pypi.org/pypi/gd-tools-cli/json"
+REQUEST_TIMEOUT = 3
+CACHE_TTL_HOURS = 24
+CACHE_DIR = Path.home() / ".gd-tools"
+CACHE_FILENAME = "update-check.json"
+
+
+def check_for_update() -> Optional[str]:
+    """Check PyPI for a newer version of gd-tools-cli.
+
+    Returns the latest version string if an update is available,
+    or ``None`` otherwise.  The check is cached for 24 hours and
+    fails silently on any error.
+
+    Returns:
+        The latest version string from PyPI if an update is
+        available, or ``None``.
+    """
+    # FR4.1: Environment variable disables check entirely.
+    if os.environ.get("GD_TOOLS_NO_UPDATE_CHECK") == "1":
+        return None
+
+    # FR1.5: Skip dev install (editable install without metadata).
+    if __version__ == "0.0.0":
+        return None
+
+    # Check cache first; fall back to a fresh PyPI request.
+    latest_version = _read_cached_version()
+    if latest_version is None:
+        latest_version = _fetch_latest_version()
+        if latest_version is not None:
+            _write_cache(latest_version)
+
+    if latest_version is None:
+        return None
+
+    # FR1.4: Compare versions using packaging.version.parse().
+    try:
+        is_newer = parse_version(latest_version) > parse_version(__version__)
+    except (TypeError, ValueError):
+        return None
+    if is_newer:
+        return latest_version
+    return None
+
+
+def _read_cached_version() -> Optional[str]:
+    """Read the cached latest version if the cache is fresh (< 24h).
+
+    Returns ``None`` on cache miss, stale cache, or corrupt cache
+    file (FR3.3 — corrupt cache is treated as a cache miss).
+    """
+    cache_file = CACHE_DIR / CACHE_FILENAME
+    if not cache_file.exists():
+        return None
+    try:
+        data = json.loads(cache_file.read_text(encoding="utf-8"))
+        last_check = datetime.fromisoformat(data["last_check"])
+        if last_check.tzinfo is None:
+            last_check = last_check.replace(tzinfo=timezone.utc)
+        age = datetime.now(timezone.utc) - last_check
+        if age < timedelta(hours=CACHE_TTL_HOURS):
+            return data["latest_version"]
+        return None
+    except (ValueError, KeyError, OSError, TypeError):
+        return None
+
+
+def _fetch_latest_version() -> Optional[str]:
+    """Fetch the latest version from the PyPI JSON API.
+
+    Returns ``None`` on any network or parsing error (FR3.1, FR3.2).
+    """
+    try:
+        response = requests.get(PYPI_URL, timeout=REQUEST_TIMEOUT)
+        data = response.json()
+        return data["info"]["version"]
+    except (requests.RequestException, ValueError, KeyError):
+        return None
+
+
+def _write_cache(version: str) -> None:
+    """Write the cache file with the current timestamp and version.
+
+    Creates the cache directory if it does not exist (FR2.5).
+    Silently ignores write errors — the main functionality is
+    unaffected if the cache cannot be persisted.
+    """
+    try:
+        CACHE_DIR.mkdir(parents=True, exist_ok=True)
+        cache_file = CACHE_DIR / CACHE_FILENAME
+        entry = {
+            "last_check": datetime.now(timezone.utc).isoformat(),
+            "latest_version": version,
+        }
+        cache_file.write_text(json.dumps(entry), encoding="utf-8")
+    except OSError:
+        pass

{gd_tools_cli-0.1.4 → gd_tools_cli-0.2.0}/src/gd_tools_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gd-tools-cli
-Version: 0.1.4
+Version: 0.2.0
 Summary: A modern development workflow CLI for GDScript projects in Godot 4.5+
 Author-email: mansyar <m.ansyarafi@gmail.com>
 License: MIT
@@ -31,6 +31,7 @@ Requires-Dist: tomli; python_version < "3.11"
 Requires-Dist: tomli_w
 Requires-Dist: pydantic>=2.0
 Requires-Dist: requests
+Requires-Dist: packaging
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
@@ -108,9 +109,9 @@ gd-tools test --coverage --min 80
 |---------|-------------|
 | `gd-tools init` | Bootstrap a Godot project -- install GUT, deploy coverage addon, generate configs. |
 | `gd-tools doctor` | Diagnose the development environment -- Godot, GUT, coverage addon, tooling. |
-| `gd-tools test` | Run GUT tests with optional coverage, thresholds, JUnit XML output. |
-| `gd-tools lint` | Lint GDScript files using gdlint with text or JSON output. |
-| `gd-tools format` | Format GDScript files using gdformat with check and diff modes. |
+| `gd-tools test` | Run GUT tests with optional coverage, thresholds, JUnit XML output. Accepts optional path arguments to override configured test directories. |
+| `gd-tools lint` | Lint GDScript files using gdlint with text or JSON output. Accepts one or more file or directory paths. |
+| `gd-tools format` | Format GDScript files using gdformat with check and diff modes. Accepts one or more file or directory paths. |
 | `gd-tools coverage` | Coverage subcommands -- `report`, `merge`, `show`. |
 
 See the [User Guide](./docs/USER_GUIDE.md) for full command reference,

{gd_tools_cli-0.1.4 → gd_tools_cli-0.2.0}/src/gd_tools_cli.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ src/gd_tools/godot.py
 src/gd_tools/init.py
 src/gd_tools/lint_runner.py
 src/gd_tools/test_runner.py
+src/gd_tools/update_check.py
 src/gd_tools/addons/__init__.py
 src/gd_tools/addons/gd-tools-coverage/coverage.gd
 src/gd_tools/addons/gd-tools-coverage/post_run_hook.gd

{gd_tools_cli-0.1.4 → gd_tools_cli-0.2.0}/src/gd_tools_cli.egg-info/requires.txt

@@ -7,6 +7,7 @@ pyyaml
 tomli_w
 pydantic>=2.0
 requests
+packaging
 
 [:python_version < "3.11"]
 tomli

gd_tools_cli-0.1.4/src/gd_tools/file_discovery.py

@@ -1,41 +0,0 @@
-"""Shared file discovery module for gd-tools.
-
-Discovers ``.gd`` files under a given path, applying exclude
-patterns from the configuration. Used by both the lint runner
-and the format runner.
-"""
-
-import os
-
-from gd_tools.config import DEFAULT_EXCLUDES
-
-
-def discover_gd_files(
-    path: str, excludes: list[str] | None = None
-) -> list[str]:
-    """Discover ``.gd`` files in ``path``, skipping excluded directories.
-
-    Recursively walks ``path`` and collects all files with a ``.gd``
-    extension (case-insensitive).  Directories whose names appear in
-    ``excludes`` are pruned from the walk so their contents are never
-    visited.
-
-    Args:
-        path: Root directory to search.
-        excludes: Directory names to skip.  Defaults to
-            :data:`DEFAULT_EXCLUDES` from ``config.py``.
-
-    Returns:
-        List of file paths (as strings) to ``.gd`` files.
-    """
-    if excludes is None:
-        excludes = DEFAULT_EXCLUDES
-
-    gd_files: list[str] = []
-    for root, dirs, files in os.walk(path):
-        # Prune excluded dirs in-place so os.walk doesn't descend into them
-        dirs[:] = [d for d in dirs if d not in excludes]
-        for file in files:
-            if file.lower().endswith(".gd"):
-                gd_files.append(os.path.join(root, file))
-    return gd_files