@nt-ai-lab/opencode-skillz 0.3.14 → 0.4.1

package/dist/tools/infra/pull-request/create-draft-pull-request.js

@@ -0,0 +1,115 @@
+export const CREATE_PULL_REQUEST_TOOL_NAME = "nt_skillz_create_pr";
+const semanticCommitTitlePattern = /^(feat|fix|refactor|perf|docs|test|build|ci|release|chore)\([^)]+\): .+/;
+class CreatePullRequestError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+function normalizeRequiredText(value, fieldName) {
+    const trimmedValue = value.trim();
+    if (trimmedValue) {
+        return trimmedValue;
+    }
+    throw new CreatePullRequestError(`Expected ${fieldName} to be provided. Got empty text.`);
+}
+function runCommand(repositoryRoot, commandRunner, executable, commandArguments, description) {
+    const commandResult = commandRunner.run(executable, commandArguments, repositoryRoot);
+    if (commandResult.errorMessage) {
+        throw new CreatePullRequestError(`Expected ${description} to run. Got ${commandResult.errorMessage}.`);
+    }
+    if (commandResult.status !== 0) {
+        throw new CreatePullRequestError(`Expected ${description} to succeed. Got ${readCommandFailureMessage(commandResult)}.`);
+    }
+    return commandResult.stdout.trim();
+}
+function readCommandFailureMessage(commandResult) {
+    const stderr = commandResult.stderr.trim();
+    if (stderr) {
+        return stderr;
+    }
+    const stdout = commandResult.stdout.trim();
+    if (stdout) {
+        return stdout;
+    }
+    return `exit status ${commandResult.status}`;
+}
+function validateCleanWorkingTree(repositoryRoot, commandRunner) {
+    const statusOutput = runCommand(repositoryRoot, commandRunner, "git", ["status", "--porcelain"], "working tree status check");
+    if (!statusOutput) {
+        return;
+    }
+    throw new CreatePullRequestError(`Expected working tree to be clean before pull request creation. Got ${statusOutput}.`);
+}
+function validateSemanticCommitTitles(repositoryRoot, commandRunner, base) {
+    const commitTitleOutput = runCommand(repositoryRoot, commandRunner, "git", ["log", "--format=%s", `${base}..HEAD`], "pull request commit title discovery");
+    const commitTitles = commitTitleOutput.split("\n").map((commitTitle) => commitTitle.trim()).filter(Boolean);
+    const invalidCommitTitle = commitTitles.find((commitTitle) => !semanticCommitTitlePattern.test(commitTitle));
+    if (!invalidCommitTitle) {
+        return;
+    }
+    throw new CreatePullRequestError(`Expected semantic commit title format <type>(<scope>): <short summary>. Got ${invalidCommitTitle}.`);
+}
+function readCurrentBranch(repositoryRoot, commandRunner) {
+    const branchName = runCommand(repositoryRoot, commandRunner, "git", ["branch", "--show-current"], "current branch discovery");
+    if (branchName) {
+        return branchName;
+    }
+    throw new CreatePullRequestError("Expected current branch name to be non-empty. Got empty text.");
+}
+function isMissingUpstreamResult(commandResult) {
+    if (commandResult.errorMessage) {
+        return false;
+    }
+    return readCommandFailureMessage(commandResult).includes("no upstream");
+}
+function readUpstreamLookupFailureMessage(commandResult) {
+    if (commandResult.errorMessage) {
+        return commandResult.errorMessage;
+    }
+    return readCommandFailureMessage(commandResult);
+}
+function pushBranchWhenUpstreamIsMissing(repositoryRoot, commandRunner, branchName) {
+    const upstreamResult = commandRunner.run("git", ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"], repositoryRoot);
+    if (upstreamResult.status === 0) {
+        return;
+    }
+    if (!isMissingUpstreamResult(upstreamResult)) {
+        throw new CreatePullRequestError(`Expected upstream lookup to succeed or report missing upstream. Got ${readUpstreamLookupFailureMessage(upstreamResult)}.`);
+    }
+    runCommand(repositoryRoot, commandRunner, "git", ["push", "-u", "origin", branchName], "branch push");
+}
+function createPullRequestBody(request) {
+    return [
+        "## Problem",
+        normalizeRequiredText(request.problem, "problem"),
+        "",
+        "## Solution",
+        normalizeRequiredText(request.solution, "solution"),
+        "",
+        "## Acceptance Criteria",
+        normalizeRequiredText(request.acceptanceCriteria, "acceptanceCriteria"),
+        "",
+        "## Architecture and software design",
+        normalizeRequiredText(request.architectureAndSoftwareDesign, "architectureAndSoftwareDesign"),
+    ].join("\n");
+}
+export function createDraftPullRequest(repositoryRoot, request, commandRunner) {
+    const base = normalizeRequiredText(request.base, "base");
+    const title = normalizeRequiredText(request.title, "title");
+    const body = createPullRequestBody(request);
+    validateCleanWorkingTree(repositoryRoot, commandRunner);
+    validateSemanticCommitTitles(repositoryRoot, commandRunner, base);
+    const branchName = readCurrentBranch(repositoryRoot, commandRunner);
+    pushBranchWhenUpstreamIsMissing(repositoryRoot, commandRunner, branchName);
+    return runCommand(repositoryRoot, commandRunner, "gh", [
+        "pr",
+        "create",
+        "--draft",
+        "--base",
+        base,
+        "--title",
+        title,
+        "--body",
+        body,
+    ], "draft pull request creation");
+}

package/dist/tools/infra/pull-request/feedback.d.ts

@@ -0,0 +1,14 @@
+import type { CommandRunner } from "../source-control/changed-files.js";
+export declare const PULL_REQUEST_FEEDBACK_TOOL_NAME = "nt_skillz_pr_feedback";
+export declare class PullRequestFeedbackError extends Error {
+    constructor(message: string);
+}
+export interface PullRequestFeedbackRequest {
+    repositoryRoot: string;
+    pullRequestNumber: string;
+    pullRequestUrl: string;
+}
+export interface PullRequestFeedbackDependencies {
+    commandRunner?: CommandRunner;
+}
+export declare function readPullRequestFeedback(request: PullRequestFeedbackRequest, dependencies?: PullRequestFeedbackDependencies): string;

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/source-control/changed-files.d.ts

@@ -0,0 +1,20 @@
+export interface CommandRunResult {
+    status: number | null;
+    stdout: string;
+    stderr: string;
+    errorMessage?: string;
+}
+export interface CommandRunner {
+    run(executable: string, commandArguments: string[], workingDirectory: string): CommandRunResult;
+}
+export interface PullRequestChangedFileRequest {
+    repositoryRoot: string;
+    pullRequest?: string;
+    base?: string;
+    head?: string;
+}
+export declare class PullRequestFileResolutionError extends Error {
+    constructor(message: string);
+}
+export declare const childProcessCommandRunner: CommandRunner;
+export declare function resolvePullRequestChangedFiles(request: PullRequestChangedFileRequest, commandRunner?: CommandRunner): string[];

package/dist/tools/infra/source-control/changed-files.js

@@ -0,0 +1,78 @@
+import { spawnSync } from "node:child_process";
+export class PullRequestFileResolutionError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+export const childProcessCommandRunner = {
+    run(executable, commandArguments, workingDirectory) {
+        const commandResult = spawnSync(executable, commandArguments, {
+            cwd: workingDirectory,
+            encoding: "utf8",
+        });
+        if (commandResult.error) {
+            return {
+                status: commandResult.status,
+                stdout: commandResult.stdout,
+                stderr: commandResult.stderr,
+                errorMessage: commandResult.error.message,
+            };
+        }
+        return {
+            status: commandResult.status,
+            stdout: commandResult.stdout,
+            stderr: commandResult.stderr,
+        };
+    },
+};
+function normalizeOptionalText(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmedValue = value.trim();
+    if (!trimmedValue) {
+        return undefined;
+    }
+    return trimmedValue;
+}
+function ensureSuccessfulCommand(commandResult, commandDescription) {
+    if (commandResult.errorMessage) {
+        throw new PullRequestFileResolutionError(`Expected ${commandDescription} to run. Got ${commandResult.errorMessage}.`);
+    }
+    if (commandResult.status === 0) {
+        return;
+    }
+    const failureOutput = commandResult.stderr.trim() || commandResult.stdout.trim();
+    if (failureOutput) {
+        throw new PullRequestFileResolutionError(`Expected ${commandDescription} to succeed. Got ${failureOutput}.`);
+    }
+    throw new PullRequestFileResolutionError(`Expected ${commandDescription} to succeed. Got exit status ${commandResult.status}.`);
+}
+function splitChangedFileOutput(output) {
+    return [...new Set(output.split("\n").map((changedPath) => changedPath.trim()).filter(Boolean))];
+}
+function readGitHubPullRequestFiles(repositoryRoot, pullRequest, commandRunner) {
+    const commandResult = commandRunner.run("gh", ["pr", "diff", pullRequest, "--name-only"], repositoryRoot);
+    ensureSuccessfulCommand(commandResult, "GitHub pull request file discovery");
+    return splitChangedFileOutput(commandResult.stdout);
+}
+function readGitChangedFiles(repositoryRoot, baseReference, headReference, commandRunner) {
+    const commandResult = commandRunner.run("git", ["diff", "--name-only", "--diff-filter=ACMR", `${baseReference}...${headReference}`], repositoryRoot);
+    ensureSuccessfulCommand(commandResult, "git changed-file discovery");
+    return splitChangedFileOutput(commandResult.stdout);
+}
+export function resolvePullRequestChangedFiles(request, commandRunner = childProcessCommandRunner) {
+    const pullRequest = normalizeOptionalText(request.pullRequest);
+    if (pullRequest) {
+        return readGitHubPullRequestFiles(request.repositoryRoot, pullRequest, commandRunner);
+    }
+    const baseReference = normalizeOptionalText(request.base);
+    const headReference = normalizeOptionalText(request.head);
+    if (baseReference && headReference) {
+        return readGitChangedFiles(request.repositoryRoot, baseReference, headReference, commandRunner);
+    }
+    if (baseReference) {
+        return readGitChangedFiles(request.repositoryRoot, baseReference, "HEAD", commandRunner);
+    }
+    throw new PullRequestFileResolutionError("Expected pull request identifier or base reference for pr-review mode.");
+}

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/infra/vitest-coverage/review.d.ts

@@ -0,0 +1,50 @@
+import { type CommandRunner } from "../source-control/changed-files.js";
+export declare const VITEST_COVERAGE_TOOL_NAME = "nt_skillz_vitest_coverage";
+interface CoverageRequest {
+    repositoryRoot?: string;
+    files?: string[];
+    mode?: string;
+    pullRequest?: string;
+    base?: string;
+    head?: string;
+}
+interface CoverageMetric {
+    total: number;
+    covered: number;
+    skipped: number;
+    pct: number;
+}
+interface FileCoverageSummary {
+    lines: CoverageMetric;
+    statements: CoverageMetric;
+    functions: CoverageMetric;
+    branches: CoverageMetric;
+}
+interface CoverageExecutionEnvironment {
+    commandRunner: CommandRunner;
+    temporaryDirectoryCreator: (prefix: string) => string;
+    temporaryDirectoryRemover: (directoryPath: string) => void;
+}
+interface CoveragePassed {
+    status: "passed";
+    filePath: string;
+    summary: FileCoverageSummary;
+}
+interface CoverageFailed {
+    status: "failed";
+    filePath: string;
+    summary: FileCoverageSummary;
+    commandOutput: string;
+}
+interface CoverageErrored {
+    status: "errored";
+    filePath: string;
+    message: string;
+    commandOutput: string;
+}
+type CoverageFileResult = CoveragePassed | CoverageFailed | CoverageErrored;
+export declare function runVitestCoverageReview(request: CoverageRequest, environment?: CoverageExecutionEnvironment): Promise<{
+    markdown: string;
+    results: CoverageFileResult[];
+}>;
+export {};