@nt-ai-lab/opencode-skillz 0.3.15 → 0.4.2

package/dist/tools/infra/pull-request/feedback.js

@@ -0,0 +1,280 @@
+import fs from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+import { childProcessCommandRunner } from "../source-control/changed-files.js";
+export const PULL_REQUEST_FEEDBACK_TOOL_NAME = "nt_skillz_pr_feedback";
+const pullRequestViewSchema = z.object({
+    baseRefName: z.string(),
+    headRefName: z.string(),
+    id: z.string().min(1),
+    number: z.number().int(),
+    url: z.string().min(1),
+});
+const reviewThreadSchema = z.object({
+    id: z.string().min(1),
+    isOutdated: z.boolean(),
+    isResolved: z.boolean(),
+    line: z.number().int().nullable(),
+    path: z.string().min(1),
+    comments: z.object({
+        pageInfo: z.object({
+            hasNextPage: z.boolean(),
+        }),
+        nodes: z.array(z.object({
+            author: z.object({
+                login: z.string().min(1),
+            }),
+            body: z.string(),
+            createdAt: z.string().min(1),
+            diffHunk: z.string(),
+            url: z.string().min(1),
+        })),
+    }),
+});
+const reviewThreadsResponseSchema = z.object({
+    node: z.object({
+        reviewThreads: z.object({
+            pageInfo: z.object({
+                endCursor: z.string().nullable(),
+                hasNextPage: z.boolean(),
+            }),
+            nodes: z.array(reviewThreadSchema),
+        }),
+    }),
+});
+export class PullRequestFeedbackError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+function normalizeRequiredText(value, fieldName) {
+    const normalizedValue = value.trim();
+    if (normalizedValue) {
+        return normalizedValue;
+    }
+    throw new PullRequestFeedbackError(`Expected ${fieldName} to be non-empty. Got blank text.`);
+}
+function ensureSuccessfulCommand(commandResult, commandDescription) {
+    if (commandResult.errorMessage) {
+        throw new PullRequestFeedbackError(`Expected ${commandDescription} to run. Got ${commandResult.errorMessage}.`);
+    }
+    if (commandResult.status === 0) {
+        return;
+    }
+    const failureOutput = commandResult.stderr.trim() || commandResult.stdout.trim();
+    if (failureOutput) {
+        throw new PullRequestFeedbackError(`Expected ${commandDescription} to succeed. Got ${failureOutput}.`);
+    }
+    throw new PullRequestFeedbackError(`Expected ${commandDescription} to succeed. Got exit status ${commandResult.status}.`);
+}
+function parseJsonWithSchema(jsonText, schema, commandDescription) {
+    const parsedJson = parseJson(jsonText, commandDescription);
+    const parsedResult = schema.safeParse(parsedJson);
+    if (parsedResult.success) {
+        return parsedResult.data;
+    }
+    throw new PullRequestFeedbackError(`Expected ${commandDescription} to return valid JSON. Got ${parsedResult.error.message}.`);
+}
+function parseJson(jsonText, commandDescription) {
+    try {
+        return JSON.parse(jsonText);
+    }
+    catch {
+        throw new PullRequestFeedbackError(`Expected ${commandDescription} to return JSON. Got malformed JSON.`);
+    }
+}
+function readPullRequestView(repositoryRoot, pullRequestNumber, commandRunner) {
+    const commandResult = commandRunner.run("gh", [
+        "pr",
+        "view",
+        pullRequestNumber,
+        "--json",
+        "id,number,url,headRefName,baseRefName",
+        "--jq",
+        ".",
+    ], repositoryRoot);
+    ensureSuccessfulCommand(commandResult, "GitHub pull request lookup");
+    return parseJsonWithSchema(commandResult.stdout, pullRequestViewSchema, "GitHub pull request lookup");
+}
+function createReviewThreadsQuery() {
+    return [
+        "query($pullRequestId: ID!, $threadCursor: String) {",
+        "  node(id: $pullRequestId) {",
+        "    ... on PullRequest {",
+        "      reviewThreads(first: 100, after: $threadCursor) {",
+        "        pageInfo { endCursor hasNextPage }",
+        "        nodes {",
+        "          id",
+        "          isOutdated",
+        "          isResolved",
+        "          line",
+        "          path",
+        "          comments(first: 100) {",
+        "            pageInfo { hasNextPage }",
+        "            nodes {",
+        "              author { login }",
+        "              body",
+        "              createdAt",
+        "              diffHunk",
+        "              url",
+        "            }",
+        "          }",
+        "        }",
+        "      }",
+        "    }",
+        "  }",
+        "}",
+    ].join("\n");
+}
+function readReviewThreadPage(repositoryRoot, pullRequestId, threadCursor, commandRunner) {
+    const commandArguments = [
+        "api",
+        "graphql",
+        "-f",
+        `pullRequestId=${pullRequestId}`,
+        "-f",
+        `query=${createReviewThreadsQuery()}`,
+    ];
+    if (threadCursor) {
+        commandArguments.splice(4, 0, "-f", `threadCursor=${threadCursor}`);
+    }
+    const commandResult = commandRunner.run("gh", commandArguments, repositoryRoot);
+    ensureSuccessfulCommand(commandResult, "GitHub pull request review thread lookup");
+    return parseJsonWithSchema(commandResult.stdout, reviewThreadsResponseSchema, "GitHub pull request review thread lookup");
+}
+function readAllReviewThreads(repositoryRoot, pullRequestId, commandRunner, threadCursor = null, previousReviewThreads = []) {
+    const response = readReviewThreadPage(repositoryRoot, pullRequestId, threadCursor, commandRunner);
+    const reviewThreadPage = response.node.reviewThreads;
+    const reviewThreads = [...previousReviewThreads, ...reviewThreadPage.nodes];
+    if (reviewThreadPage.pageInfo.hasNextPage) {
+        if (reviewThreadPage.pageInfo.endCursor === null) {
+            throw new PullRequestFeedbackError("Expected GitHub review thread page cursor. Got null.");
+        }
+        return readAllReviewThreads(repositoryRoot, pullRequestId, commandRunner, reviewThreadPage.pageInfo.endCursor, reviewThreads);
+    }
+    return reviewThreads;
+}
+function ensurePullRequestMatchesRequest(pullRequestView, pullRequestNumber, pullRequestUrl) {
+    if (String(pullRequestView.number) !== pullRequestNumber) {
+        throw new PullRequestFeedbackError(`Expected GitHub PR number ${pullRequestNumber}. Got ${pullRequestView.number}.`);
+    }
+    if (pullRequestView.url !== pullRequestUrl) {
+        throw new PullRequestFeedbackError(`Expected GitHub PR URL ${pullRequestUrl}. Got ${pullRequestView.url}.`);
+    }
+}
+function ensureCompleteThreadComments(reviewThreads) {
+    const incompleteThread = reviewThreads.find((reviewThread) => reviewThread.comments.pageInfo.hasNextPage);
+    if (!incompleteThread) {
+        return;
+    }
+    throw new PullRequestFeedbackError(`Expected review thread ${incompleteThread.id} to have at most 100 comments. Got more than 100 comments.`);
+}
+function languageForPath(filePath) {
+    const extension = path.extname(filePath);
+    if (extension === ".ts" || extension === ".tsx")
+        return "ts";
+    if (extension === ".js" || extension === ".jsx")
+        return "js";
+    if (extension === ".json")
+        return "json";
+    if (extension === ".md")
+        return "md";
+    if (extension === ".yml" || extension === ".yaml")
+        return "yaml";
+    return "text";
+}
+function quoteMarkdown(value) {
+    return value.split("\n").map((line) => `> ${line}`).join("\n");
+}
+function formatDiffHunk(diffHunk) {
+    if (diffHunk.trim()) {
+        return ["```diff", diffHunk, "```"].join("\n");
+    }
+    return "No diff hunk returned by GitHub.";
+}
+function resolveReviewThreadFilePath(repositoryRoot, filePath) {
+    const absoluteRepositoryRoot = path.resolve(repositoryRoot);
+    const absoluteFilePath = path.resolve(absoluteRepositoryRoot, filePath);
+    const relativeFilePath = path.relative(absoluteRepositoryRoot, absoluteFilePath);
+    if (!relativeFilePath.startsWith("..") && !path.isAbsolute(relativeFilePath)) {
+        return absoluteFilePath;
+    }
+    throw new PullRequestFeedbackError(`Expected review thread path to stay inside repository root. Got ${filePath}.`);
+}
+function readCodeExcerpt(repositoryRoot, filePath, lineNumber) {
+    const absoluteFilePath = resolveReviewThreadFilePath(repositoryRoot, filePath);
+    if (!fs.existsSync(absoluteFilePath)) {
+        return `Current local file not found: ${filePath}`;
+    }
+    if (lineNumber === null) {
+        return "No current line number returned by GitHub.";
+    }
+    const fileLines = fs.readFileSync(absoluteFilePath, "utf8").split("\n");
+    const startLine = Math.max(1, lineNumber - 5);
+    const endLine = Math.min(fileLines.length, lineNumber + 5);
+    const excerptLines = fileLines.slice(startLine - 1, endLine);
+    const numberedLines = excerptLines.map((line, index) => `${startLine + index}: ${line}`);
+    return [`\`\`\`${languageForPath(filePath)}`, ...numberedLines, "```"].join("\n");
+}
+function formatComments(reviewThread) {
+    return reviewThread.comments.nodes.map((comment, index) => [
+        `#### Comment ${index + 1}`,
+        `- Comment URL: ${comment.url}`,
+        `- Author: ${comment.author.login}`,
+        `- Created: ${comment.createdAt}`,
+        "- Full comment:",
+        quoteMarkdown(comment.body),
+    ].join("\n")).join("\n\n");
+}
+function readLatestDiffHunk(reviewThread) {
+    const latestComment = reviewThread.comments.nodes.at(-1);
+    if (latestComment) {
+        return latestComment.diffHunk;
+    }
+    throw new PullRequestFeedbackError(`Expected review thread ${reviewThread.id} to contain at least one comment. Got 0.`);
+}
+function formatReviewLine(lineNumber) {
+    if (lineNumber === null) {
+        return "outdated";
+    }
+    return String(lineNumber);
+}
+function formatReviewThread(repositoryRoot, reviewThread) {
+    return [
+        `## Thread ${reviewThread.id}`,
+        "",
+        "### Reviewer feedback",
+        formatComments(reviewThread),
+        "",
+        "### Review context",
+        `- File: ${reviewThread.path}`,
+        `- Line: ${formatReviewLine(reviewThread.line)}`,
+        `- Outdated: ${reviewThread.isOutdated ? "yes" : "no"}`,
+        "- Diff hunk:",
+        formatDiffHunk(readLatestDiffHunk(reviewThread)),
+        "",
+        "### Current local code",
+        readCodeExcerpt(repositoryRoot, reviewThread.path, reviewThread.line),
+    ].join("\n");
+}
+export function readPullRequestFeedback(request, dependencies = {}) {
+    const pullRequestNumber = normalizeRequiredText(request.pullRequestNumber, "pull request number");
+    const pullRequestUrl = normalizeRequiredText(request.pullRequestUrl, "pull request URL");
+    const commandRunner = dependencies.commandRunner ?? childProcessCommandRunner;
+    const pullRequestView = readPullRequestView(request.repositoryRoot, pullRequestNumber, commandRunner);
+    ensurePullRequestMatchesRequest(pullRequestView, pullRequestNumber, pullRequestUrl);
+    const reviewThreads = readAllReviewThreads(request.repositoryRoot, pullRequestView.id, commandRunner);
+    ensureCompleteThreadComments(reviewThreads);
+    const unresolvedReviewThreads = reviewThreads.filter((reviewThread) => !reviewThread.isResolved);
+    return [
+        "# Pull Request Feedback",
+        "",
+        `- PR number: ${pullRequestView.number}`,
+        `- PR URL: ${pullRequestView.url}`,
+        `- Head branch: ${pullRequestView.headRefName}`,
+        `- Base branch: ${pullRequestView.baseRefName}`,
+        `- Unresolved review threads: ${unresolvedReviewThreads.length}`,
+        "",
+        ...unresolvedReviewThreads.map((reviewThread) => formatReviewThread(request.repositoryRoot, reviewThread)),
+    ].join("\n");
+}

package/dist/tools/infra/vitest-coverage/command.d.ts

@@ -0,0 +1,16 @@
+export interface CoverageCommandSpec {
+    executable: string;
+    commandArguments: string[];
+    workingDirectory: string;
+    coverageSummaryRoot: string;
+    coverageSummaryFilePath: string;
+}
+interface CoverageCommandRequest {
+    repositoryRoot: string;
+    filePath: string;
+    packageRoot: string;
+    packageRelativeFilePath: string;
+    reportsDirectory: string;
+}
+export declare function createVitestCoverageCommandSpec(request: CoverageCommandRequest): CoverageCommandSpec;
+export {};

package/dist/tools/infra/vitest-coverage/command.js

@@ -0,0 +1,85 @@
+import fs from "node:fs";
+import path from "node:path";
+class VitestCoverageCommandResolutionError extends Error {
+}
+function formatMissingVitestCommandMessage(checkedBinaryPaths, checkedLockFilePaths) {
+    return [
+        "Expected Vitest binary in one of:",
+        ...checkedBinaryPaths.map((binaryPath) => `- ${binaryPath}`),
+        "or workspace package manager lockfile in one of:",
+        ...checkedLockFilePaths.map((lockFilePath) => `- ${lockFilePath}`),
+    ].join("\n");
+}
+function collectVitestBinaryPathsFromDirectory(repositoryRoot, currentDirectory, checkedBinaryPaths) {
+    const binaryPath = path.join(currentDirectory, "node_modules", ".bin", "vitest");
+    const nextCheckedBinaryPaths = [...checkedBinaryPaths, binaryPath];
+    if (currentDirectory === repositoryRoot) {
+        return nextCheckedBinaryPaths;
+    }
+    const parentDirectory = path.dirname(currentDirectory);
+    return collectVitestBinaryPathsFromDirectory(repositoryRoot, parentDirectory, nextCheckedBinaryPaths);
+}
+function resolveVitestBinaryPath(checkedBinaryPaths) {
+    return checkedBinaryPaths.find((binaryPath) => fs.existsSync(binaryPath));
+}
+function createVitestArguments(coverageFilePath, reportsDirectory) {
+    return [
+        "--run",
+        "--coverage.enabled",
+        `--coverage.include=${coverageFilePath}`,
+        "--coverage.reporter=json-summary",
+        "--coverage.reporter=text",
+        `--coverage.reportsDirectory=${reportsDirectory}`,
+    ];
+}
+function createDirectVitestCommandSpec(vitestBinaryPath, request) {
+    return {
+        executable: vitestBinaryPath,
+        commandArguments: createVitestArguments(request.packageRelativeFilePath, request.reportsDirectory),
+        workingDirectory: request.packageRoot,
+        coverageSummaryRoot: request.packageRoot,
+        coverageSummaryFilePath: request.packageRelativeFilePath,
+    };
+}
+function getCheckedLockFilePaths(repositoryRoot) {
+    return [
+        path.join(repositoryRoot, "yarn.lock"),
+        path.join(repositoryRoot, "pnpm-lock.yaml"),
+        path.join(repositoryRoot, "package-lock.json"),
+        path.join(repositoryRoot, "npm-shrinkwrap.json"),
+    ];
+}
+function createWorkspaceCommandSpec(executable, commandArguments, request) {
+    return {
+        executable,
+        commandArguments,
+        workingDirectory: request.repositoryRoot,
+        coverageSummaryRoot: request.repositoryRoot,
+        coverageSummaryFilePath: request.filePath,
+    };
+}
+function createWorkspaceVitestCommandSpec(request) {
+    const vitestArguments = createVitestArguments(request.filePath, request.reportsDirectory);
+    if (fs.existsSync(path.join(request.repositoryRoot, "yarn.lock"))) {
+        return createWorkspaceCommandSpec("yarn", ["vitest", ...vitestArguments], request);
+    }
+    if (fs.existsSync(path.join(request.repositoryRoot, "pnpm-lock.yaml"))) {
+        return createWorkspaceCommandSpec("pnpm", ["exec", "vitest", ...vitestArguments], request);
+    }
+    if (fs.existsSync(path.join(request.repositoryRoot, "package-lock.json")) || fs.existsSync(path.join(request.repositoryRoot, "npm-shrinkwrap.json"))) {
+        return createWorkspaceCommandSpec("npm", ["exec", "--", "vitest", ...vitestArguments], request);
+    }
+    return undefined;
+}
+export function createVitestCoverageCommandSpec(request) {
+    const checkedBinaryPaths = collectVitestBinaryPathsFromDirectory(path.resolve(request.repositoryRoot), path.resolve(request.packageRoot), []);
+    const vitestBinaryPath = resolveVitestBinaryPath(checkedBinaryPaths);
+    if (vitestBinaryPath !== undefined) {
+        return createDirectVitestCommandSpec(vitestBinaryPath, request);
+    }
+    const workspaceVitestCommandSpec = createWorkspaceVitestCommandSpec(request);
+    if (workspaceVitestCommandSpec !== undefined) {
+        return workspaceVitestCommandSpec;
+    }
+    throw new VitestCoverageCommandResolutionError(formatMissingVitestCommandMessage(checkedBinaryPaths, getCheckedLockFilePaths(request.repositoryRoot)));
+}

package/dist/tools/{vitest-coverage.d.ts → infra/vitest-coverage/review.d.ts}

@@ -1,4 +1,4 @@
-import { type CommandRunner } from "./pull-request-files.js";
+import { type CommandRunner } from "../source-control/changed-files.js";
 export declare const VITEST_COVERAGE_TOOL_NAME = "nt_skillz_vitest_coverage";
 interface CoverageRequest {
     repositoryRoot?: string;
@@ -47,21 +47,4 @@ export declare function runVitestCoverageReview(request: CoverageRequest, enviro
     markdown: string;
     results: CoverageFileResult[];
 }>;
-export declare const vitestCoverageTool: {
-    description: string;
-    args: {
-        mode: import("zod").ZodOptional<import("zod").ZodString>;
-        pullRequest: import("zod").ZodOptional<import("zod").ZodString>;
-        base: import("zod").ZodOptional<import("zod").ZodString>;
-        head: import("zod").ZodOptional<import("zod").ZodString>;
-        files: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-    };
-    execute(args: {
-        mode?: string | undefined;
-        pullRequest?: string | undefined;
-        base?: string | undefined;
-        head?: string | undefined;
-        files?: string[] | undefined;
-    }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
-};
 export {};

package/dist/tools/{vitest-coverage.js → infra/vitest-coverage/review.js}

@@ -2,8 +2,8 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import process from "node:process";
-import { tool } from "@opencode-ai/plugin";
-import { childProcessCommandRunner, resolvePullRequestChangedFiles, } from "./pull-request-files.js";
+import { childProcessCommandRunner, resolvePullRequestChangedFiles, } from "../source-control/changed-files.js";
+import { createVitestCoverageCommandSpec, } from "./command.js";
 export const VITEST_COVERAGE_TOOL_NAME = "nt_skillz_vitest_coverage";
 class CoverageUsageError extends Error {
 }
@@ -87,24 +87,8 @@ function findPackageRootFromDirectory(repositoryRoot, directoryPath) {
     }
     return findPackageRootFromDirectory(repositoryRoot, parentDirectoryPath);
 }
-function resolveVitestBinary(packageRoot) {
-    const binaryPath = path.join(packageRoot, "node_modules", ".bin", "vitest");
-    if (fs.existsSync(binaryPath)) {
-        return binaryPath;
-    }
-    throw new CoverageUsageError(`Expected Vitest binary at ${binaryPath}.`);
-}
-function runCoverageCommand(packageRoot, packageRelativeFilePath, reportsDirectory, environment) {
-    const commandResult = environment.commandRunner.run(resolveVitestBinary(packageRoot), [
-        "related",
-        packageRelativeFilePath,
-        "--run",
-        "--coverage.enabled",
-        `--coverage.include=${packageRelativeFilePath}`,
-        "--coverage.reporter=json-summary",
-        "--coverage.reporter=text",
-        `--coverage.reportsDirectory=${reportsDirectory}`,
-    ], packageRoot);
+function runCoverageCommand(commandSpec, environment) {
+    const commandResult = environment.commandRunner.run(commandSpec.executable, commandSpec.commandArguments, commandSpec.workingDirectory);
     const output = [commandResult.stdout, commandResult.stderr].filter(Boolean).join("\n").trim();
     return {
         status: commandResult.status,
@@ -179,10 +163,17 @@ function formatCoverageErrorMessage(error) {
     }
     return `Expected coverage error message. Got ${String(error)}.`;
 }
-function executeCoverageWithReports(filePath, packageRoot, packageRelativeFilePath, environment) {
+function executeCoverageWithReports(repositoryRoot, filePath, packageRoot, packageRelativeFilePath, environment) {
     const reportsDirectory = environment.temporaryDirectoryCreator(path.join(os.tmpdir(), "nt-skillz-coverage-"));
     try {
-        const commandResult = runCoverageCommand(packageRoot, packageRelativeFilePath, reportsDirectory, environment);
+        const commandSpec = createVitestCoverageCommandSpec({
+            repositoryRoot,
+            filePath,
+            packageRoot,
+            packageRelativeFilePath,
+            reportsDirectory,
+        });
+        const commandResult = runCoverageCommand(commandSpec, environment);
         if (commandResult.errorMessage) {
             return {
                 status: "errored",
@@ -191,7 +182,7 @@ function executeCoverageWithReports(filePath, packageRoot, packageRelativeFilePa
                 commandOutput: commandResult.output,
             };
         }
-        const summary = readCoverageSummary(packageRoot, reportsDirectory, packageRelativeFilePath);
+        const summary = readCoverageSummary(commandSpec.coverageSummaryRoot, reportsDirectory, commandSpec.coverageSummaryFilePath);
         if (commandResult.status === 0 && hasCompleteCoverage(summary)) {
             return {
                 status: "passed",
@@ -224,7 +215,7 @@ function executeFileCoverage(repositoryRoot, filePath, environment) {
         const absoluteFilePath = path.resolve(repositoryRoot, filePath);
         const packageRoot = findPackageRootFromDirectory(repositoryRoot, path.dirname(absoluteFilePath));
         const packageRelativeFilePath = path.relative(packageRoot, absoluteFilePath);
-        return executeCoverageWithReports(filePath, packageRoot, packageRelativeFilePath, environment);
+        return executeCoverageWithReports(repositoryRoot, filePath, packageRoot, packageRelativeFilePath, environment);
     }
     catch (error) {
         const message = formatCoverageErrorMessage(error);
@@ -305,31 +296,3 @@ export async function runVitestCoverageReview(request, environment = {
         results,
     };
 }
-export const vitestCoverageTool = tool({
-    description: "Run Vitest coverage for changed TypeScript source files.",
-    args: {
-        mode: tool.schema.string().optional().describe("Use 'pr-review' for pull request coverage."),
-        pullRequest: tool.schema.string().optional().describe("Pull request number or URL for pr-review mode."),
-        base: tool.schema.string().optional().describe("Base git reference for pr-review mode when no pull request is provided."),
-        head: tool.schema.string().optional().describe("Head git reference for pr-review mode when base is provided."),
-        files: tool.schema.array(tool.schema.string()).optional().describe("Repository-relative files for files mode."),
-    },
-    async execute(request, context) {
-        context.metadata({ title: "Vitest coverage review" });
-        const outcome = await runVitestCoverageReview({
-            repositoryRoot: context.worktree,
-            mode: request.mode,
-            pullRequest: request.pullRequest,
-            base: request.base,
-            head: request.head,
-            files: request.files,
-        });
-        return {
-            output: outcome.markdown,
-            metadata: {
-                fileCount: outcome.results.length,
-                failedCount: outcome.results.filter((result) => result.status !== "passed").length,
-            },
-        };
-    },
-});

package/dist/tools/infra/vitest-coverage/test-support.d.ts

@@ -0,0 +1,15 @@
+import type { CommandRunner } from "../source-control/changed-files.js";
+export interface CapturedCoverageRun {
+    executable: string;
+    commandArguments: string[];
+    workingDirectory: string;
+}
+export declare function createRepository(sourceFilePath: string): string;
+export declare function createRepositoryWithoutVitest(sourceFilePath: string): string;
+export declare function createRepositoryWithoutPackage(sourceFilePath: string): string;
+export declare function createCoverageCommandRunner(percent: number, capturedRuns: CapturedCoverageRun[], commandOutput?: string): CommandRunner;
+export declare function createPullRequestCoverageCommandRunner(changedFiles: string[], percent: number): CommandRunner;
+export declare function createCoverageSummaryCommandRunner(summaryJson: string): CommandRunner;
+export declare function createCoverageErrorCommandRunner(): CommandRunner;
+export declare function installFailingVitestBinary(repositoryRoot: string): void;
+export declare function removeDirectory(directoryPath: string): void;