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

package/dist/plugin-registry/index.js

@@ -1,16 +1,43 @@
+import process from "node:process";
 import { createDontStopHooks } from "../commands/dont-stop/index.js";
+import { createGitWorkflowGate, } from "../git-workflow-gates.js";
+import { createPullRequestTool, } from "../tools/create-pr-tool.js";
 import { LINT_TOOL_NAME, lintTool, } from "../tools/lint.js";
-import { VITEST_COVERAGE_TOOL_NAME, vitestCoverageTool, } from "../tools/vitest-coverage.js";
+import { PULL_REQUEST_FEEDBACK_TOOL_NAME, pullRequestFeedbackTool, } from "../tools/pull-request-feedback-tool.js";
+import { VITEST_COVERAGE_TOOL_NAME, vitestCoverageTool, } from "../tools/vitest-coverage-tool.js";
 import { registerAgents } from "./agents.js";
 import { registerCommands } from "./commands.js";
+import { childProcessCommandRunner } from "../tools/infra/source-control/changed-files.js";
+function readLintedFilePaths(request) {
+    if (!Array.isArray(request.files)) {
+        return [];
+    }
+    return request.files.filter((filePath) => typeof filePath === "string");
+}
+function createGateAwareLintTool(gate) {
+    return {
+        ...lintTool,
+        async execute(request, context) {
+            const result = await lintTool.execute(request, context);
+            gate.recordLintedFiles(readLintedFilePaths(request));
+            return result;
+        },
+    };
+}
 export function createPluginRegistry(input, pluginRoot) {
     const dontStopHooks = createDontStopHooks(input.client);
+    const gitWorkflowGate = createGitWorkflowGate(input.worktree ?? process.cwd(), childProcessCommandRunner);
     return {
         ...dontStopHooks,
         tool: {
-            [LINT_TOOL_NAME]: lintTool,
+            nt_skillz_create_pr: createPullRequestTool,
+            [LINT_TOOL_NAME]: createGateAwareLintTool(gitWorkflowGate),
+            [PULL_REQUEST_FEEDBACK_TOOL_NAME]: pullRequestFeedbackTool,
             [VITEST_COVERAGE_TOOL_NAME]: vitestCoverageTool,
         },
+        "tool.execute.before": async (hookInput, hookOutput) => {
+            gitWorkflowGate.beforeToolExecution(hookInput, hookOutput);
+        },
         config: async (config) => {
             config.command ??= {};
             config.agent ??= {};

package/dist/tools/create-pr-tool.d.ts

@@ -0,0 +1,4 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+import type { CommandRunner } from "../git-workflow-gates.js";
+export declare function createPullRequestToolWithRunner(commandRunner: CommandRunner): ToolDefinition;
+export declare const createPullRequestTool: ToolDefinition;

package/dist/tools/create-pr-tool.js

@@ -0,0 +1,22 @@
+import { tool } from "@opencode-ai/plugin";
+import { createDraftPullRequest } from "./infra/pull-request/create-draft-pull-request.js";
+import { childProcessCommandRunner } from "./infra/source-control/changed-files.js";
+export function createPullRequestToolWithRunner(commandRunner) {
+    return tool({
+        description: "Create a validated draft pull request with required OpenCode workflow gates.",
+        args: {
+            base: tool.schema.string().describe("Base branch for the pull request."),
+            title: tool.schema.string().describe("Pull request title."),
+            problem: tool.schema.string().describe("Problem section content."),
+            solution: tool.schema.string().describe("Solution section content."),
+            acceptanceCriteria: tool.schema.string().describe("Acceptance Criteria section content."),
+            architectureAndSoftwareDesign: tool.schema.string().describe("Architecture and software design section content."),
+        },
+        async execute(request, context) {
+            return {
+                output: createDraftPullRequest(context.worktree, request, commandRunner),
+            };
+        },
+    });
+}
+export const createPullRequestTool = createPullRequestToolWithRunner(childProcessCommandRunner);

package/dist/tools/infra/lint/guidance.d.ts

@@ -0,0 +1,8 @@
+interface LintMessageWithRule {
+    ruleId: string | null;
+}
+interface LintResultWithMessages {
+    messages: readonly LintMessageWithRule[];
+}
+export declare function createLintFailureGuidance(lintResults: readonly LintResultWithMessages[]): string;
+export {};

package/dist/tools/infra/lint/guidance.js

@@ -0,0 +1,98 @@
+const genericLintFailureGuidance = [
+    "Lint remediation guidance:",
+    "- Do not sacrifice code quality or test coverage to satisfy lint rules.",
+    "- These rules are not objectives; they are signs that code needs to be split, simplified, or clarified.",
+    "- Fix the underlying design or test issue instead of deleting assertions, disabling rules, or reducing coverage.",
+];
+const targetedLintGuidance = [
+    {
+        ruleIds: ["vitest/max-expects"],
+        guidance: [
+            "Do not delete required assertions or weaken expected values to reduce assertion count.",
+            "If several assertions describe one observable result, prefer one whole-result assertion such as `toEqual`, `toStrictEqual`, `toMatchObject`, or a domain-specific matcher.",
+            "If the test verifies multiple behaviours, split it into separate tests with outcome-focused names.",
+            "Do not combine unrelated checks into one object assertion just to satisfy this rule.",
+        ],
+    },
+    {
+        ruleIds: ["max-lines", "sonarjs/max-lines", "sonarjs/max-lines-per-function"],
+        guidance: [
+            "Do not delete required behavior, tests, setup, edge cases, or assertions to reduce line count.",
+            "Split by cohesive responsibility instead: production behavior, test fixture construction, assertions, adapters, or domain concepts.",
+            "For long spec files, extract fixture builders or split scenarios by behavior.",
+            "For long source files, extract named concepts that can be tested independently.",
+            "Do not move unrelated code into vague files such as utils, helpers, common, shared, or lib.",
+        ],
+    },
+    {
+        ruleIds: [
+            "complexity",
+            "max-depth",
+            "sonarjs/cognitive-complexity",
+            "sonarjs/cyclomatic-complexity",
+            "sonarjs/nested-control-flow",
+        ],
+        guidance: [
+            "Do not remove branches, states, error handling, or edge cases to reduce complexity.",
+            "Reduce complexity by making decisions easier to read without changing behavior.",
+            "Use guard clauses, early returns, named predicates, or discriminated unions where they clarify the code.",
+            "If complexity comes from multiple states, model those states directly instead of stacking conditionals.",
+            "Keep all existing behavior, tests, and edge cases intact.",
+        ],
+    },
+    {
+        ruleIds: [
+            "@typescript-eslint/no-explicit-any",
+            "@typescript-eslint/no-unsafe-assignment",
+            "@typescript-eslint/no-unsafe-call",
+            "@typescript-eslint/no-unsafe-member-access",
+            "@typescript-eslint/no-unsafe-return",
+            "@typescript-eslint/consistent-type-assertions",
+            "@typescript-eslint/no-non-null-assertion",
+            "sonarjs/no-return-type-any",
+        ],
+        guidance: [
+            "Do not replace `any` with `unknown as X`, non-null assertions, type assertions, or broader unsafe types.",
+            "Add precise types at the boundary where the value enters the system.",
+            "For external input, parse with Zod or an existing runtime validator.",
+            "For impossible states, change the type model instead of silencing the error.",
+            "Keep behavior unchanged and preserve existing validation.",
+        ],
+    },
+    {
+        ruleIds: [
+            "@eslint-community/eslint-comments/no-use",
+            "no-inline-comments",
+            "sonarjs/no-commented-code",
+            "sonarjs/no-sonar-comments",
+            "@typescript-eslint/ban-ts-comment",
+        ],
+        guidance: [
+            "Do not add code comments. They make the code noisy and are a workaround for poor code. Make code intention revealing so that comments are not necessary.",
+            "Do not add lint or TypeScript suppressions. The rules are non-negotiable. If the solution cannot be implemented while following the codebase rules, stop and ask for help.",
+        ],
+    },
+];
+function isPresentRuleId(ruleId) {
+    return typeof ruleId === "string" && ruleId.length > 0;
+}
+function readTriggeredRuleIds(lintResults) {
+    return new Set(lintResults.flatMap((lintResult) => {
+        return lintResult.messages.map((message) => message.ruleId).filter(isPresentRuleId);
+    }));
+}
+export function createLintFailureGuidance(lintResults) {
+    const triggeredRuleIds = readTriggeredRuleIds(lintResults);
+    const specificGuidance = targetedLintGuidance
+        .filter((targetedGuidance) => targetedGuidance.ruleIds.some((ruleId) => triggeredRuleIds.has(ruleId)))
+        .flatMap((targetedGuidance) => targetedGuidance.guidance);
+    if (specificGuidance.length === 0) {
+        return genericLintFailureGuidance.join("\n");
+    }
+    return [
+        ...genericLintFailureGuidance,
+        "",
+        "Rule-specific guidance:",
+        ...specificGuidance.map((guidance) => `- ${guidance}`),
+    ].join("\n");
+}

package/dist/tools/{lint-review.d.ts → infra/lint/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 interface LintReviewRequest {
     repositoryRoot?: string;
     pullRequest?: string;

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

@@ -1,6 +1,6 @@
 import path from "node:path";
 import process from "node:process";
-import { resolvePullRequestChangedFiles, } from "./pull-request-files.js";
+import { resolvePullRequestChangedFiles, } from "../source-control/changed-files.js";
 function normalizeTypeScriptFiles(filePaths) {
     return filePaths.filter((filePath) => filePath.endsWith(".ts") || filePath.endsWith(".tsx"));
 }

package/dist/tools/infra/pull-request/create-draft-pull-request.d.ts

@@ -0,0 +1,11 @@
+import type { CommandRunner } from "../../../git-workflow-gates.js";
+export declare const CREATE_PULL_REQUEST_TOOL_NAME = "nt_skillz_create_pr";
+export interface CreatePullRequestRequest {
+    base: string;
+    title: string;
+    problem: string;
+    solution: string;
+    acceptanceCriteria: string;
+    architectureAndSoftwareDesign: string;
+}
+export declare function createDraftPullRequest(repositoryRoot: string, request: CreatePullRequestRequest, commandRunner: CommandRunner): string;

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/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 {};