smart-tests-cli 2.13.0__tar.gz → 2.14.0__tar.gz

smart_tests_cli-2.14.0/.claude/skills/merge-v1-to-main/SKILL.md

@@ -0,0 +1,131 @@
+---
+name: merge-v1-to-main
+description: Merge v1 branch changes into main, resolving the conflicts that arise from the v1/main code structure difference
+trigger: When the user says "merge v1 to main", "port v1 to main", "forward port", or similar
+---
+
+## Background
+
+This repository maintains two branches in parallel:
+
+- `v1` — the legacy CLI (`launchable/` Python package, `launchable/jar/exe_deploy.jar`)
+- `main` — the rebranded CLI (`smart_tests/` Python package, `smart_tests/jar/exe_deploy.jar`)
+
+Features are usually developed on `v1` first, then ported to `main` via `git merge v1`.
+
+## Procedure
+
+### 1. Create a feature branch from main
+
+```
+git checkout -b feature/<ticket>-<description>-main origin/main
+```
+
+### 2. Find the merge base
+
+```
+export MERGE_BASE=$(git merge-base origin/v1 origin/main)
+```
+
+### 3. Merge v1
+
+```
+git merge origin/v1
+```
+
+This will typically produce conflicts in several categories. Handle each as described below.
+
+---
+
+## Conflict Resolution Patterns
+
+### `deleted by us: launchable/commands/<file>.py`
+
+v1 touched a file that was renamed/moved in main. Find where it lives in main:
+
+```
+git log --oneline ${MERGE_BASE}..origin/main -- smart_tests/commands/<file>.py
+```
+
+If those changes are already reflected in `smart_tests/`, just remove the leftover:
+
+```
+git rm launchable/commands/<file>.py
+```
+
+If the v1 changes are **not** yet in main, apply them as a patch:
+
+```
+git diff $MERGE_BASE origin/v1 -- launchable/commands/<file>.py > PATCH
+patch -l smart_tests/commands/<file>.py < PATCH
+git rm launchable/commands/<file>.py
+```
+
+### `both modified: tests/commands/test_<cmd>.py`
+
+v1 uses `LAUNCHABLE_TOKEN` / `launchable_token`; main uses `SMART_TESTS_TOKEN` / `smart_tests_token`.
+Both sides often add the same tests under different token names.
+
+Resolution: keep the `SMART_TESTS_TOKEN` versions (main side) and discard the `LAUNCHABLE_TOKEN` duplicates.
+
+If v1 adds a genuinely new test not present in main, port it by renaming the token constant.
+
+### `both modified: smart_tests/jar/exe_deploy.jar`
+
+Java source was modified on both sides. Resolve the Java source conflicts first (see below), then:
+
+```
+bash build-java.sh
+git add smart_tests/jar/exe_deploy.jar
+```
+
+### Java source conflicts (`src/main/java/...`)
+
+v1 and main share the same Java source tree. Common differences:
+
+| Area | v1 style | main style |
+|---|---|---|
+| `GitFile` construction | `objectReader` (single reader) | `readers::get` (ThreadLocal) |
+| `collectFiles` signature | `(RevCommit start, TreeWalk treeWalk, TreeReceiver, Consumer<VirtualFile>)` | `(Collection<ObjectId> advertised, TreeReceiver, FlushableConsumer<VirtualFile>)` |
+| Static imports | `ImmutableList.*`, `Arrays.*` | `ImmutableList.toImmutableList`, `Arrays.stream` (specific) |
+
+Resolution strategy:
+- Keep HEAD (main) structural code (method signatures, `reportAllFiles` block, `readers::get`)
+- Apply the logic change from v1 (the new feature/fix)
+- If v1 uses wildcard static imports, narrow them back to the specific identifiers main uses
+
+---
+
+## After Resolving All Conflicts
+
+```
+bash build-java.sh          # rebuild jar and run tests
+git add <all resolved files>
+git commit                  # complete the merge commit
+git push -u origin <branch>
+```
+
+Then create a PR targeting `main` following the `create-gh-pull-request` skill.
+
+---
+
+## Verifying Correct Resolution
+
+After the merge commit, confirm:
+
+1. No conflict markers remain: `git diff HEAD | grep -E '^[<=>]{7}'` should be empty
+2. Tests pass: `build-java.sh` exits 0
+3. `smart_tests/jar/exe_deploy.jar` is staged (CI will fail otherwise)
+4. No `launchable/` paths leak into the commit unless they are legitimately v1-only files
+
+---
+
+## Big Reset
+
+If you get hopelessly confused:
+
+```
+git commit --all                  # save current state
+git tag rescue-$(date +%s)        # tag it for recovery
+git reset --hard origin/main      # start over from main
+```

{smart_tests_cli-2.13.0/smart_tests_cli.egg-info → smart_tests_cli-2.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smart-tests-cli
-Version: 2.13.0
+Version: 2.14.0
 Summary: Smart Tests CLI
 Author-email: CloudBees <support@cloudbees.com>
 License: Apache Software License v2

{smart_tests_cli-2.13.0 → smart_tests_cli-2.14.0}/smart_tests/commands/gate.py

@@ -1,4 +1,5 @@
 import json
+import os
 import sys
 from http import HTTPStatus
 from typing import Annotated
@@ -12,6 +13,7 @@ from smart_tests.utils.tracking import TrackingClient
 from .. import args4p
 from ..app import Application
 from ..args4p import typer
+from ..testpath import unparse_test_path
 from ..utils.commands import Command
 from ..utils.session import SessionId
 from ..utils.smart_tests_client import SmartTestsClient
@@ -21,8 +23,8 @@ from ..utils.smart_tests_client import SmartTestsClient
 def gate(app_instance: Application,
          session: Annotated[SessionId, SessionId.as_option()],
          is_json_format: Annotated[bool, typer.Option(
-                "--json",
-                help="display JSON format")] = False):
+             "--json",
+             help="display JSON format")] = False):
     tracking_client = TrackingClient(Command.GATE, app=app_instance)
     client = SmartTestsClient(tracking_client=tracking_client, app=app_instance)
     try:
@@ -50,6 +52,14 @@ def gate(app_instance: Application,
         client.print_exception_and_recover(e, "Warning: failed to fetch gate status")
 
 
+def _escape_github_actions_command_value(value: str) -> str:
+    return value.replace('\r', '%0D').replace('\n', '%0A')
+
+
+def _escape_github_actions_log_line(line: str) -> str:
+    return line.replace('::', '%3A%3A', 1) if line.startswith('::') else line
+
+
 def display_as_json(res: Response):
     res_json = res.json()
     click.echo(json.dumps(res_json, indent=2))
@@ -68,3 +78,24 @@ def display_as_table(res: Response):
     ]]
 
     click.echo(tabulate(rows, headers, tablefmt="github"))
+
+    failed_tests = res_json.get('actionableFailedTests', [])
+    is_github_actions = os.getenv('GITHUB_ACTIONS')
+    if failed_tests:
+        click.echo("\nActionable Failure Details:\n")
+        for i, test in enumerate(failed_tests, 1):
+            test_path = unparse_test_path(test.get("testPath", []))
+            stderr = (test.get("stderr") or "").strip()
+            if is_github_actions:
+                safe_test_path = _escape_github_actions_command_value(test_path)
+                click.echo("::group::{}. {}".format(i, safe_test_path))
+                if stderr:
+                    for line in stderr.splitlines():
+                        click.echo(_escape_github_actions_log_line(line))
+                click.echo("::endgroup::")
+            else:
+                click.echo("{}. {}".format(i, test_path))
+                if stderr:
+                    for line in stderr.splitlines():
+                        click.echo("   {}".format(line))
+                click.echo("")

{smart_tests_cli-2.13.0 → smart_tests_cli-2.14.0}/smart_tests/commands/subset.py

@@ -881,7 +881,7 @@ class Subset(TestPathWriter):
 
         if self._requires_test_input():
             if self.input_given:
-                print_error_and_die("ERROR: Given arguments did not match any tests. They appear to be incorrect/non-existent.", tracking_client, Tracking.ErrorEvent.USER_ERROR)  # noqa E501
+                print_error_and_die("ERROR: Given arguments did not match any tests. They appear to be incorrect/non-existent.", self.tracking_client, Tracking.ErrorEvent.USER_ERROR)  # noqa E501
             else:
                 print_error_and_die(
                     "ERROR: Expecting tests to be given, but none provided. See https://help.launchableinc.com/features/predictive-test-selection/requesting-and-running-a-subset-of-tests/ and provide ones, or use the `--get-tests-from-previous-sessions` option",  # noqa E501

{smart_tests_cli-2.13.0 → smart_tests_cli-2.14.0}/smart_tests/test_runners/maven.py

@@ -1,6 +1,7 @@
 import glob
 import os
 import re
+import xml.etree.ElementTree as ET
 from typing import Annotated, Dict, List
 
 import click
@@ -50,6 +51,29 @@ def is_file(f: str) -> bool:
     return False
 
 
+def parse_surefire_reports() -> List[Dict[str, str]]:
+    """Collect the test classes Surefire discovered from its TEST-*.xml reports.
+
+    Intended to be run against reports produced by a JUnit 5 dry run
+    (`mvn test -Djunit.platform.execution.dryRun.enabled=true`): Surefire applies
+    all of its own filtering (excludedGroups, includedGroups, excludes, profiles,
+    ...) before the dry run, so only the tests Maven would actually execute get a
+    report. Each report's root `name` attribute is the fully-qualified class name.
+    """
+    test_paths = []
+    report_pattern = os.path.join('**', 'target', 'surefire-reports', 'TEST-*.xml')
+    report_files = glob.glob(report_pattern, recursive=True)
+
+    for report_file in report_files:
+        try:
+            if classname := ET.parse(report_file).getroot().get('name'):
+                test_paths.append({"type": "class", "name": classname})
+        except ET.ParseError as e:
+            click.secho(f"Warning: Could not parse {report_file}: {e}", fg='yellow', err=True)
+
+    return test_paths
+
+
 @smart_tests.subset
 def subset(
     client: Subset,
@@ -68,6 +92,12 @@ def subset(
         help="Scan testCompile/default-testCompile/createdFiles.lst for *.lst files generated by `mvn compile` and "
              "use them as test inputs."
     )] = False,
+    is_scan_dryrun_results: Annotated[bool, typer.Option(
+        "--scan-dryrun-results",
+        help="Scan surefire reports generated by `mvn test -Djunit.platform.execution.dryRun.enabled=true`. "
+             "Only the tests Maven would actually run (after applying pom.xml excludedGroups/excludes/etc.) are "
+             "sent to the subset. Run the dry run before this command. JUnit 5 only."
+    )] = False,
     exclude_rules: Annotated[List[str], typer.Option(
         "--exclude",
         multiple=True,
@@ -108,6 +138,18 @@ def subset(
     if source_roots is None:
         source_roots = []
 
+    if is_scan_dryrun_results:
+        tests = parse_surefire_reports()
+        if not tests:
+            raise BadCmdLineException(
+                "No surefire reports found under **/target/surefire-reports/. "
+                "Run `mvn test -Djunit.platform.execution.dryRun.enabled=true` before this command.")
+        for test in tests:
+            client.test_paths.append([test])
+        client.same_bin_formatter = lambda s: [{"type": "class", "name": s}]
+        client.run()
+        return
+
     files_to_read = list(test_compile_created_file)
     if is_scan_test_compile_lst:
         if len(test_compile_created_file) > 0:

{smart_tests_cli-2.13.0 → smart_tests_cli-2.14.0/smart_tests_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smart-tests-cli
-Version: 2.13.0
+Version: 2.14.0
 Summary: Smart Tests CLI
 Author-email: CloudBees <support@cloudbees.com>
 License: Apache Software License v2

{smart_tests_cli-2.13.0 → smart_tests_cli-2.14.0}/smart_tests_cli.egg-info/SOURCES.txt

@@ -19,6 +19,7 @@ pyproject.toml
 renovate.json
 setup.py
 uv.lock
+.claude/skills/merge-v1-to-main/SKILL.md
 .github/release.yml
 .github/workflows/bazel-test.yml
 .github/workflows/e2e.yml
@@ -548,8 +549,11 @@ tests/data/maven/subset_by_absolute_time_result.json
 tests/data/maven/subset_by_confidence_result.json
 tests/data/maven/subset_from_file_result.json
 tests/data/maven/subset_result.json
+tests/data/maven/subset_scan_dryrun_results_result.json
 tests/data/maven/subset_scan_test_compile_lst_result.json
 tests/data/maven/subset_with_exclude_rules_result.json
+tests/data/maven/dryrun-test/target/surefire-reports/TEST-com.example.demo.CalculatorTest.xml
+tests/data/maven/dryrun-test/target/surefire-reports/TEST-com.example.demo.UserTest.xml
 tests/data/maven/java/test/src/java/com/example/sample_app_maven/App2Test.java
 tests/data/maven/java/test/src/java/com/example/sample_app_maven/AppTest.java
 tests/data/maven/java/test/src/java/com/launchableinc/rocket_car_maven/e2e/E2ETest.java

{smart_tests_cli-2.13.0 → smart_tests_cli-2.14.0}/smart_tests_cli.egg-info/scm_file_list.json

@@ -2,6 +2,7 @@
   "files": [
     ".bazelrc",
     ".bazelversion",
+    ".claude/skills/merge-v1-to-main/SKILL.md",
     ".dockerignore",
     ".editorconfig",
     ".github/release.yml",
@@ -530,6 +531,8 @@
     "tests/data/karma/subset_result.json",
     "tests/data/maven/createdFile_1.lst",
     "tests/data/maven/createdFile_2.lst",
+    "tests/data/maven/dryrun-test/target/surefire-reports/TEST-com.example.demo.CalculatorTest.xml",
+    "tests/data/maven/dryrun-test/target/surefire-reports/TEST-com.example.demo.UserTest.xml",
     "tests/data/maven/java/test/src/java/com/example/sample_app_maven/App2Test.java",
     "tests/data/maven/java/test/src/java/com/example/sample_app_maven/AppTest.java",
     "tests/data/maven/java/test/src/java/com/launchableinc/rocket_car_maven/e2e/E2ETest.java",
@@ -543,6 +546,7 @@
     "tests/data/maven/subset_by_confidence_result.json",
     "tests/data/maven/subset_from_file_result.json",
     "tests/data/maven/subset_result.json",
+    "tests/data/maven/subset_scan_dryrun_results_result.json",
     "tests/data/maven/subset_scan_test_compile_lst_result.json",
     "tests/data/maven/subset_with_exclude_rules_result.json",
     "tests/data/minitest/TEST-Admin_UserTest.xml",

smart_tests_cli-2.14.0/smart_tests_cli.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "2.14.0",
+  "distance": 0,
+  "node": "g70c81defa1673044af8b117712d28e00ab1aae91",
+  "dirty": false,
+  "branch": "main",
+  "node_date": "2026-09-07"
+}

{smart_tests_cli-2.13.0 → smart_tests_cli-2.14.0}/src/main/java/com/launchableinc/ingest/commits/CommitGraphCollector.java

@@ -23,6 +23,7 @@ import org.eclipse.jgit.diff.DiffEntry;
 import org.eclipse.jgit.errors.ConfigInvalidException;
 import org.eclipse.jgit.errors.InvalidObjectIdException;
 import org.eclipse.jgit.errors.MissingObjectException;
+import org.eclipse.jgit.lib.AnyObjectId;
 import org.eclipse.jgit.lib.ConfigConstants;
 import org.eclipse.jgit.lib.FileMode;
 import org.eclipse.jgit.lib.ObjectId;
@@ -49,6 +50,7 @@ import java.io.InputStreamReader;
 import java.io.OutputStream;
 import java.io.UncheckedIOException;
 import java.net.URL;
+import java.nio.charset.StandardCharsets;
 import java.time.Duration;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -68,6 +70,7 @@ import java.util.zip.GZIPOutputStream;
 
 import static com.google.common.collect.ImmutableList.toImmutableList;
 import static java.util.Arrays.stream;
+import static org.eclipse.jgit.lib.Constants.OBJ_BLOB;
 
 /**
  * Compares what commits the local repository and the remote repository have, then send delta over.
@@ -528,26 +531,44 @@ public class CommitGraphCollector {
         OUTER:
         while (treeWalk.next()) {
           ObjectId head = treeWalk.getObjectId(0);
-          for (int i = 1; i < c; i++) {
-            if (head.equals(treeWalk.getObjectId(i))) {
-              // file at the head is identical to one of the uninteresting commits,
-              // meaning we have already seen this file/directory on the server.
-              // if it is a dir, there's no need to visit this whole subtree, so skip over
-              continue OUTER;
-            }
-          }
 
           if (treeWalk.isSubtree()) {
+            for (int i = 1; i < c; i++) {
+              if (head.equals(treeWalk.getObjectId(i))) {
+                continue OUTER;
+              }
+            }
             treeWalk.enterSubtree();
+            continue;
+          }
+
+          String filePath = treeWalk.getPathString();
+          FileMode mode = treeWalk.getFileMode(0);
+          ObjectId blobId;
+
+          if (mode == FileMode.SYMLINK) {
+            blobId = resolveSymlinkTarget(start.getTree(), filePath, head);
+            if (blobId == null) {
+              continue;
+            }
+          } else if ((mode.getBits() & FileMode.TYPE_MASK) == FileMode.TYPE_FILE) {
+            blobId = head;
           } else {
-            if ((treeWalk.getFileMode(0).getBits() & FileMode.TYPE_MASK) == FileMode.TYPE_FILE) {
-              GitFile f = new GitFile(name, treeWalk.getPathString(), head, readers::get);
-              // to avoid excessive data transfer, skip files that are too big
-              if (f.size() < 1024 * 1024 && f.isText() && !f.path.equals(HEADER_FILE)) {
-                treeReceiver.accept(f);
-              }
+            continue;
+          }
+
+          // Dedup check uses the actual content blob ID so that symlink target changes are
+          // detected even when the symlink path string (and thus its own blob) is unchanged.
+          for (int i = 1; i < c; i++) {
+            if (blobId.equals(treeWalk.getObjectId(i))) {
+              continue OUTER;
             }
           }
+
+          GitFile f = new GitFile(name, filePath, blobId, readers::get);
+          if (f.size() < 1024 * 1024 && f.isText() && !f.path.equals(HEADER_FILE)) {
+            treeReceiver.accept(f);
+          }
         }
 
         // Now let the server select the files it actually wants to see
@@ -562,6 +583,47 @@ public class CommitGraphCollector {
       }
     }
 
+    private ObjectId resolveSymlinkTarget(AnyObjectId treeId, String symlinkPath, ObjectId symlinkBlobId) {
+      try {
+        byte[] raw = objectReader.open(symlinkBlobId, OBJ_BLOB).getCachedBytes(10_000);
+        String targetRelative = new String(raw, StandardCharsets.UTF_8).trim();
+
+        java.nio.file.Path symlinkDir = java.nio.file.Paths.get(symlinkPath).getParent();
+        java.nio.file.Path resolved;
+        if (symlinkDir != null) {
+          resolved = symlinkDir.resolve(targetRelative).normalize();
+        } else {
+          resolved = java.nio.file.Paths.get(targetRelative).normalize();
+        }
+
+        if (resolved.isAbsolute() || resolved.startsWith("..")) {
+          logger.debug("Skipping symlink {} -> {} (points outside repository)", symlinkPath, targetRelative);
+          return null;
+        }
+
+        String resolvedPath = resolved.toString().replace(java.io.File.separatorChar, '/');
+
+        try (TreeWalk tw = TreeWalk.forPath(git, resolvedPath, treeId)) {
+          if (tw == null) {
+            logger.debug("Skipping symlink {} -> {} (target not found in tree)", symlinkPath, resolvedPath);
+            return null;
+          }
+
+          FileMode targetMode = tw.getFileMode(0);
+          if ((targetMode.getBits() & FileMode.TYPE_MASK) == FileMode.TYPE_FILE) {
+            return tw.getObjectId(0);
+          }
+
+          logger.debug("Skipping symlink {} -> {} (target is not a regular file, mode={})",
+              symlinkPath, resolvedPath, targetMode);
+          return null;
+        }
+      } catch (IOException e) {
+        logger.warn("Failed to resolve symlink {}: {}", symlinkPath, e.getMessage());
+        return null;
+      }
+    }
+
     /**
      * Creates a per repository "header" file as a {@link VirtualFile}.
      * Currently, this is just the list of files in the repository.

{smart_tests_cli-2.13.0 → smart_tests_cli-2.14.0}/src/test/java/com/launchableinc/ingest/commits/CommitGraphCollectorTest.java

@@ -29,6 +29,7 @@ import java.io.InputStream;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 
 import static com.google.common.truth.Truth.assertThat;
@@ -226,6 +227,96 @@ public class CommitGraphCollectorTest {
     }
   }
 
+  @Test
+  public void symlinkResolvedAsRegularFile() throws Exception {
+    try (Git repo = Git.init().setDirectory(ws).call()) {
+      Files.writeString(ws.toPath().resolve("real.txt"), "hello");
+      repo.add().addFilepattern("real.txt").call();
+      commit(repo).setMessage("add real file").call();
+
+      Files.createSymbolicLink(ws.toPath().resolve("link.txt"), java.nio.file.Path.of("real.txt"));
+      repo.add().addFilepattern("link.txt").call();
+      commit(repo).setMessage("add symlink").call();
+
+      assertThat(collectFilePaths(repo)).containsAtLeast("real.txt", "link.txt");
+    }
+  }
+
+  @Test
+  public void symlinkAcrossDirectories() throws Exception {
+    try (Git repo = Git.init().setDirectory(ws).call()) {
+      Files.createDirectory(ws.toPath().resolve("sub"));
+
+      // subdir -> parent: sub/link.txt -> ../root.txt
+      Files.writeString(ws.toPath().resolve("root.txt"), "root content");
+      Files.createSymbolicLink(ws.toPath().resolve("sub").resolve("link.txt"), java.nio.file.Path.of("../root.txt"));
+      repo.add().addFilepattern("root.txt").addFilepattern("sub/link.txt").call();
+
+      // parent -> subdir: link2.txt -> sub/deep.txt
+      Files.writeString(ws.toPath().resolve("sub").resolve("deep.txt"), "deep content");
+      Files.createSymbolicLink(ws.toPath().resolve("link2.txt"), java.nio.file.Path.of("sub/deep.txt"));
+      repo.add().addFilepattern("sub/deep.txt").addFilepattern("link2.txt").call();
+
+      commit(repo).setMessage("add cross-directory symlinks").call();
+
+      assertThat(collectFilePaths(repo)).containsAtLeast("root.txt", "sub/link.txt", "sub/deep.txt", "link2.txt");
+    }
+  }
+
+  @Test
+  public void brokenSymlinkSkipped() throws Exception {
+    try (Git repo = Git.init().setDirectory(ws).call()) {
+      Files.writeString(ws.toPath().resolve("target.txt"), "content");
+      Files.createSymbolicLink(ws.toPath().resolve("broken.txt"), java.nio.file.Path.of("target.txt"));
+      repo.add().addFilepattern("target.txt").addFilepattern("broken.txt").call();
+      commit(repo).setMessage("add files").call();
+
+      repo.rm().addFilepattern("target.txt").call();
+      commit(repo).setMessage("remove target").call();
+
+      assertThat(collectFilePaths(repo)).doesNotContain("broken.txt");
+    }
+  }
+
+  @Test
+  public void symlinkOutsideRepoSkipped() throws Exception {
+    try (Git repo = Git.init().setDirectory(ws).call()) {
+      Files.createSymbolicLink(ws.toPath().resolve("escape.txt"), java.nio.file.Path.of("../outside.txt"));
+      repo.add().addFilepattern("escape.txt").call();
+      commit(repo).setMessage("add symlink to outside").call();
+
+      assertThat(collectFilePaths(repo)).doesNotContain("escape.txt");
+    }
+  }
+
+  @Test
+  public void regularFilesUnaffectedBySymlinkChange() throws Exception {
+    try (Git repo = Git.init().setDirectory(ws).call()) {
+      Files.writeString(ws.toPath().resolve("a.txt"), "aaa");
+      Files.writeString(ws.toPath().resolve("b.txt"), "bbb");
+      repo.add().addFilepattern("a.txt").addFilepattern("b.txt").call();
+      commit(repo).setMessage("add regular files").call();
+
+      assertThat(collectFilePaths(repo)).containsExactly("a.txt", "b.txt");
+    }
+  }
+
+  private List<String> collectFilePaths(Git repo) throws IOException {
+    List<VirtualFile> files = new ArrayList<>();
+    CommitGraphCollector cgc = new CommitGraphCollector("test", repo.getRepository());
+    cgc.new ByRepository(repo.getRepository(), "main")
+        .collectFiles(Collections.emptyList(), new PassThroughTreeReceiverImpl(),
+            FlushableConsumer.of(files::add));
+
+    List<String> paths = new ArrayList<>();
+    for (VirtualFile f : files) {
+      if (!f.path().equals(CommitGraphCollector.HEADER_FILE)) {
+        paths.add(f.path());
+      }
+    }
+    return paths;
+  }
+
   private CommitCommand commit(Git r) {
     return r.commit().setAll(true).setSign(false);
   }