@diffci.com/diffci 0.1.0-alpha.3

package/dist-client/src/planner/path-baseline.js

@@ -0,0 +1,131 @@
+import { repositoryLayout, UNKNOWN_REPOSITORY_LAYOUT } from "../repo/layout.js";
+function toPosix(p) {
+    return p.replace(/\\/g, "/");
+}
+function directoryOf(path) {
+    const index = path.lastIndexOf("/");
+    return index <= 0 ? "" : path.slice(0, index);
+}
+/** Every directory that contains at least one test at any depth below it. */
+function directoriesContainingTests(allTestPaths) {
+    const dirs = new Set();
+    for (const test of allTestPaths) {
+        let dir = directoryOf(toPosix(test));
+        for (;;) {
+            dirs.add(dir);
+            if (dir === "")
+                break;
+            dir = directoryOf(dir);
+        }
+    }
+    return dirs;
+}
+function isUnder(path, dir) {
+    return dir === "" || path === dir || path.startsWith(`${dir}/`);
+}
+/** The deepest ancestor directory of `changedPath` that contains any test, or undefined when only the
+ * repository root does - which is not a scoping, it is "run everything". */
+function nearestTestScope(changedPath, testDirs) {
+    let dir = directoryOf(changedPath);
+    while (dir !== "") {
+        if (testDirs.has(dir))
+            return dir;
+        dir = directoryOf(dir);
+    }
+    return undefined;
+}
+/** For a repository whose tests live in their own root mirroring a source root, the directory under
+ * that test root corresponding to the changed file. */
+function mirroredTestScopes(changedPath, profile, testDirs) {
+    if (!profile)
+        return [];
+    const sourceRoots = profile.sourceRoots.filter((r) => r.kind !== "tests").map((r) => toPosix(r.path));
+    const testRoots = profile.sourceRoots.filter((r) => r.kind === "tests").map((r) => toPosix(r.path));
+    if (testRoots.length === 0)
+        return [];
+    const containing = sourceRoots.find((root) => isUnder(changedPath, root));
+    if (containing === undefined)
+        return [];
+    const relativeDir = directoryOf(changedPath.slice(containing.length + 1));
+    const scopes = [];
+    for (const testRoot of testRoots) {
+        // Walk the mirrored directory upward until one that actually holds tests is found, so a change in
+        // `src/a/b/c.ts` still scopes to `tests/a` when the mirror is only that deep.
+        let candidate = relativeDir === "" ? testRoot : `${testRoot}/${relativeDir}`;
+        for (;;) {
+            if (testDirs.has(candidate)) {
+                scopes.push(candidate);
+                break;
+            }
+            if (!isUnder(candidate, testRoot) || candidate === testRoot)
+                break;
+            candidate = directoryOf(candidate);
+        }
+    }
+    return scopes;
+}
+const INFRASTRUCTURE_DIRECTORIES = new Set([
+    "ops", "terraform", "cloudformation", "pulumi", "cdktf", "deploy", "deployments", "kubernetes", "k8s", "helm", "docker",
+]);
+const DATABASE_DIRECTORIES = new Set(["database", "migrations", "prisma", "drizzle", "supabase", "schema"]);
+function firstSegment(path) {
+    const index = path.indexOf("/");
+    return index === -1 ? path : path.slice(0, index);
+}
+export function runPathBaseline(allTestPaths, changedFiles, profile) {
+    const changedPaths = changedFiles.map((f) => toPosix(f.path));
+    const matchedRules = [];
+    const layout = profile ? repositoryLayout(profile) : UNKNOWN_REPOSITORY_LAYOUT;
+    const docsOnly = changedPaths.every((p) => layout.isDocumentationPath(p) || p.startsWith("README"));
+    if (docsOnly) {
+        matchedRules.push("docs-only -> skip tests");
+        return { strategy: "PATH_BASELINE", selectedTests: [], fallbackRequired: false, fallbackReasons: [], matchedRules };
+    }
+    const runEverything = (rule, reason) => {
+        matchedRules.push(rule);
+        return { strategy: "PATH_BASELINE", selectedTests: allTestPaths, fallbackRequired: true, fallbackReasons: [reason], matchedRules };
+    };
+    if (changedPaths.some((p) => p === "package.json" || p === "package-lock.json" || /^(yarn\.lock|pnpm-lock\.yaml|bun\.lockb?)$/.test(p))) {
+        return runEverything("config/dependency -> full fallback", "config/dependency change triggers full fallback");
+    }
+    if (changedPaths.some((p) => p.startsWith(".github/workflows/"))) {
+        return runEverything("workflow change -> full fallback", "workflow change triggers full fallback");
+    }
+    if (changedPaths.some((p) => DATABASE_DIRECTORIES.has(firstSegment(p)))) {
+        return runEverything("database -> full fallback", "database change triggers full fallback");
+    }
+    if (changedPaths.some((p) => INFRASTRUCTURE_DIRECTORIES.has(firstSegment(p)) || p.startsWith("docker") || p.includes("Dockerfile"))) {
+        return runEverything("infrastructure -> full fallback", "infrastructure change triggers full fallback");
+    }
+    const testDirs = directoriesContainingTests(allTestPaths);
+    const scopes = new Set();
+    let unscopable = false;
+    for (const changedPath of changedPaths) {
+        const mirrored = mirroredTestScopes(changedPath, profile, testDirs);
+        if (mirrored.length > 0) {
+            for (const scope of mirrored)
+                scopes.add(scope);
+            continue;
+        }
+        const nearest = nearestTestScope(changedPath, testDirs);
+        if (nearest !== undefined) {
+            scopes.add(nearest);
+            continue;
+        }
+        // A change no directory scoping can localise makes the whole baseline unscoped - a path-rule CI
+        // that cannot place ONE changed file has to run everything, regardless of how well it placed the
+        // rest. Recording it per-file and then ignoring it would flatter the baseline.
+        unscopable = true;
+    }
+    if (unscopable || scopes.size === 0) {
+        return runEverything("no directory scoping applies -> run all tests", "unscopable changed paths");
+    }
+    const sortedScopes = Array.from(scopes).sort();
+    matchedRules.push(`directory scoping -> tests under ${sortedScopes.join(", ")}`);
+    // Sorted, so a selection is comparable across runs rather than inheriting the caller's input order.
+    const selected = allTestPaths.filter((test) => sortedScopes.some((scope) => isUnder(toPosix(test), scope))).sort();
+    if (selected.length === 0) {
+        return runEverything("directory scoping selected nothing -> run all tests", "scoping produced an empty selection");
+    }
+    return { strategy: "PATH_BASELINE", selectedTests: selected, fallbackRequired: false, fallbackReasons: [], matchedRules };
+}

package/dist-client/src/planner/test-command.js

@@ -0,0 +1,124 @@
+import { matchesGlob } from "../repo/test-discovery.js";
+import { END_TO_END_FRAMEWORKS } from "../repo/test-framework.js";
+/** How each runner takes a list of test files, and whether it accepts a config file. */
+const RUNNER_INVOCATION = {
+    vitest: { binary: "vitest", leadingArgs: ["run"], configFlag: "--config" },
+    jest: { binary: "jest", leadingArgs: [], configFlag: "--config" },
+    mocha: { binary: "mocha", leadingArgs: [], configFlag: "--config" },
+    ava: { binary: "ava", leadingArgs: [] },
+    tap: { binary: "tap", leadingArgs: [] },
+    "node:test": { binary: "node", leadingArgs: ["--test"] },
+    jasmine: { binary: "jasmine", leadingArgs: [] },
+    "bun:test": { binary: "bun", leadingArgs: ["test"] },
+    playwright: { binary: "playwright", leadingArgs: ["test"], configFlag: "--config" },
+    cypress: { binary: "cypress", leadingArgs: ["run"], configFlag: "--config-file", pathStyle: "comma-separated-spec-flag" },
+};
+/**
+ * How to reach a locally-installed binary with each package manager. Every one of these resolves to
+ * the same `node_modules/.bin` entry; the package-manager-native form is used because it is what the
+ * repository's own contributors and CI would type, and because pnpm's default layout makes the raw
+ * path non-obvious.
+ */
+function execPrefix(packageManager, binary) {
+    switch (packageManager) {
+        case "pnpm":
+            return { executable: "pnpm", args: ["exec", binary] };
+        case "yarn":
+            return { executable: "yarn", args: ["run", binary] };
+        case "bun":
+            return { executable: "bunx", args: [binary] };
+        case "npm":
+        case "unknown":
+        default:
+            return { executable: "npx", args: ["--no-install", binary] };
+    }
+}
+/** Runners that are the runtime itself rather than an installed dependency, so they are invoked
+ * directly rather than through a package manager's binary resolution. */
+function isDirectlyInvoked(framework) {
+    return framework === "node:test" || framework === "bun:test";
+}
+function frameworkOfConfig(config) {
+    return config.runner;
+}
+function buildCommand(framework, packageManager, configFile, paths) {
+    const invocation = RUNNER_INVOCATION[framework];
+    const configArgs = configFile && invocation.configFlag ? [invocation.configFlag, configFile] : [];
+    const pathArgs = invocation.pathStyle === "comma-separated-spec-flag" ? ["--spec", paths.join(",")] : [...paths];
+    if (isDirectlyInvoked(framework)) {
+        return { executable: invocation.binary, args: [...invocation.leadingArgs, ...configArgs, ...pathArgs] };
+    }
+    const prefix = execPrefix(packageManager, invocation.binary);
+    return { executable: prefix.executable, args: [...prefix.args, ...invocation.leadingArgs, ...configArgs, ...pathArgs] };
+}
+/**
+ * Routes each selected test to the runner configuration that claims it, then emits one command per
+ * group. A repository with `vitest.config.ts` and `vitest.e2e.config.ts` gets two commands, because
+ * running an e2e suite under the unit config is not the same job - the family distinction that
+ * test-discovery.ts already models is carried through to execution rather than flattened.
+ */
+export function planSelectiveTestCommands(profile, selectedPaths) {
+    const paths = [...selectedPaths].sort();
+    if (paths.length === 0)
+        return { commands: [], groups: [], unroutedPaths: [] };
+    const frameworks = profile.testUniverse?.declaredFrameworks ?? [];
+    const configs = profile.testRunnerConfigs ?? [];
+    if (frameworks.length === 0 && configs.length === 0) {
+        return {
+            commands: [],
+            groups: [],
+            unroutedPaths: paths,
+            refusalReason: "Repository declares no recognised test framework; DiffCI cannot construct a command that would run a subset of its tests",
+        };
+    }
+    const remaining = new Set(paths);
+    const groups = [];
+    // A config with explicit include globs is the strongest statement a repository makes about which
+    // command runs which files, so those claims are honoured first.
+    for (const config of configs) {
+        if (config.includes.length === 0)
+            continue;
+        const claimed = paths.filter((p) => remaining.has(p) && config.includes.some((glob) => matchesGlob(p, glob)));
+        if (claimed.length === 0)
+            continue;
+        for (const p of claimed)
+            remaining.delete(p);
+        const framework = frameworkOfConfig(config);
+        groups.push({
+            runnerId: `${framework}:${config.file}`,
+            label: `${framework} (${config.file})`,
+            commandSpec: buildCommand(framework, profile.packageManager, config.file, claimed),
+            paths: claimed,
+        });
+    }
+    // Everything else goes to the repository's primary framework under its default configuration. A
+    // repository with both vitest and playwright has two real frameworks; routing an unclaimed unit
+    // test to the e2e runner would produce a command that runs nothing, so e2e runners are only ever
+    // chosen when the repository declares nothing else.
+    if (remaining.size > 0) {
+        const unitFrameworks = frameworks.filter((f) => !END_TO_END_FRAMEWORKS.has(f));
+        const primary = unitFrameworks[0] ?? frameworks[0] ?? (configs[0] ? frameworkOfConfig(configs[0]) : undefined);
+        if (primary === undefined) {
+            return {
+                commands: groups.map((g) => g.commandSpec),
+                groups,
+                unroutedPaths: Array.from(remaining).sort(),
+                refusalReason: "No framework claims the remaining selected tests",
+            };
+        }
+        const rest = Array.from(remaining).sort();
+        groups.push({
+            runnerId: primary,
+            label: `${primary} (default configuration)`,
+            commandSpec: buildCommand(primary, profile.packageManager, undefined, rest),
+            paths: rest,
+        });
+    }
+    return { commands: groups.map((g) => g.commandSpec), groups, unroutedPaths: [] };
+}
+function shellEscape(arg) {
+    return arg.replace(/([\s'"\\$|&;<>(){}\[\]*?#~`])/g, "\\$1");
+}
+export function commandSpecToString(spec) {
+    return [spec.executable, ...spec.args.map(shellEscape)].join(" ");
+}

package/dist-client/src/planner/types.js

@@ -0,0 +1 @@
+export {};