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

package/dist/git-workflow-gates.d.ts

@@ -0,0 +1,21 @@
+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 ToolExecutionInput {
+    tool: string;
+}
+export interface ToolExecutionOutput {
+    args: Record<string, unknown>;
+}
+export interface GitWorkflowGate {
+    beforeToolExecution(input: ToolExecutionInput, output: ToolExecutionOutput): void;
+    recordLintedFiles(filePaths: string[]): void;
+}
+export declare const directPullRequestCreationBlockedMessage: string;
+export declare function createGitWorkflowGate(repositoryRoot: string, commandRunner: CommandRunner): GitWorkflowGate;

package/dist/git-workflow-gates.js

@@ -0,0 +1,103 @@
+export const directPullRequestCreationBlockedMessage = [
+    "Direct gh pr create is banned for this workspace.",
+    "Use nt_skillz_create_pr instead.",
+].join("\n");
+class GitWorkflowGateError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+function readBashCommandText(value) {
+    if (typeof value !== "string") {
+        throw new GitWorkflowGateError(`Expected bash command text. Got ${String(value)}.`);
+    }
+    return value.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 isDirectPullRequestCreation(commandText) {
+    return /(?:^|[;&|()]|\s)gh\s+pr\s+create(?:\s|$|[;&|()])/.test(commandText);
+}
+function isGitCommit(commandText) {
+    return /(?:^|[;&|()]|\s)git\s+commit(?:\s|$|[;&|()])/.test(commandText);
+}
+function normalizeCommandOutput(commandResult, description) {
+    if (commandResult.errorMessage) {
+        throw new GitWorkflowGateError(`Expected ${description} to run. Got ${commandResult.errorMessage}.`);
+    }
+    if (commandResult.status !== 0) {
+        throw new GitWorkflowGateError(`Expected ${description} to succeed. Got ${readCommandFailureMessage(commandResult)}.`);
+    }
+    return commandResult.stdout.trim();
+}
+function isTypeScriptFilePath(filePath) {
+    return filePath.endsWith(".ts") || filePath.endsWith(".tsx");
+}
+function createUnlintedCommitMessage(filePaths) {
+    return [
+        "Commit blocked: TypeScript files changed without nt_skillz_lint validation.",
+        `Run nt_skillz_lint with files: ${JSON.stringify(filePaths)}`,
+        "Then retry the commit.",
+    ].join("\n");
+}
+export function createGitWorkflowGate(repositoryRoot, commandRunner) {
+    const lintedFingerprints = new Map();
+    function runGit(commandArguments, description) {
+        return normalizeCommandOutput(commandRunner.run("git", commandArguments, repositoryRoot), description);
+    }
+    function readWorkingTreeFingerprint(filePath) {
+        return runGit(["hash-object", "--", filePath], `working tree hash for ${filePath}`);
+    }
+    function readStagedFingerprint(filePath) {
+        return runGit(["rev-parse", `:${filePath}`], `staged hash for ${filePath}`);
+    }
+    function readStagedTypeScriptFilePaths() {
+        const output = runGit([
+            "diff",
+            "--name-only",
+            "--cached",
+            "--diff-filter=ACMR",
+            "--",
+            "*.ts",
+            "*.tsx",
+        ], "staged TypeScript file discovery");
+        return output.split("\n").map((filePath) => filePath.trim()).filter(Boolean);
+    }
+    function ensureStagedTypeScriptFilesAreLinted() {
+        const stagedFilePaths = readStagedTypeScriptFilePaths();
+        const unlintedFilePaths = stagedFilePaths.filter((filePath) => lintedFingerprints.get(filePath) !== readStagedFingerprint(filePath));
+        if (unlintedFilePaths.length === 0) {
+            return;
+        }
+        throw new GitWorkflowGateError(createUnlintedCommitMessage(unlintedFilePaths));
+    }
+    return {
+        beforeToolExecution(input, output) {
+            if (input.tool !== "bash") {
+                return;
+            }
+            const commandText = readBashCommandText(output.args.command);
+            if (isDirectPullRequestCreation(commandText)) {
+                throw new GitWorkflowGateError(directPullRequestCreationBlockedMessage);
+            }
+            if (isGitCommit(commandText)) {
+                ensureStagedTypeScriptFilesAreLinted();
+            }
+        },
+        recordLintedFiles(filePaths) {
+            const typeScriptFilePaths = filePaths.filter(isTypeScriptFilePath);
+            for (const filePath of typeScriptFilePaths) {
+                lintedFingerprints.set(filePath, readWorkingTreeFingerprint(filePath));
+            }
+        },
+    };
+}

package/dist/index.d.ts

@@ -1,3 +1,3 @@
 import type { PluginInput } from "./types.js";
-export declare const OpencodeSkillzPlugin: (input: PluginInput) => Promise<import("./types.js").PluginHooks>;
-export default OpencodeSkillzPlugin;
+export declare const opencodeSkillzPlugin: (input: PluginInput) => Promise<import("./types.js").PluginHooks>;
+export default opencodeSkillzPlugin;

package/dist/index.js

@@ -1,7 +1,7 @@
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { createPluginRegistry } from "./plugin-registry/index.js";
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const pluginRoot = path.resolve(__dirname, "..");
-export const OpencodeSkillzPlugin = async (input) => createPluginRegistry(input, pluginRoot);
-export default OpencodeSkillzPlugin;
+const currentDirectory = path.dirname(fileURLToPath(import.meta.url));
+const pluginRoot = path.resolve(currentDirectory, "..");
+export const opencodeSkillzPlugin = async (input) => createPluginRegistry(input, pluginRoot);
+export default opencodeSkillzPlugin;

package/dist/plugin-registry/agents.js

@@ -8,19 +8,48 @@ function parseCsvList(value) {
         .filter(Boolean);
 }
 function materializePreloadedTemplate(template) {
-    return template.replace(/\$ARGUMENTS/g, "all relevant current work in this session");
+    return template.replaceAll("$ARGUMENTS", "all relevant current work in this session");
+}
+function getParentAgentName(rawAgent) {
+    return typeof rawAgent.meta.extends === "string" ? rawAgent.meta.extends.trim() : "";
+}
+function appendAgentPromptParts(promptParts, rawAgents, name) {
+    const rawAgent = rawAgents[name];
+    const parentAgentName = getParentAgentName(rawAgent);
+    if (parentAgentName && rawAgents[parentAgentName]?.body) {
+        promptParts.push(rawAgents[parentAgentName].body);
+    }
+    if (rawAgent.body) {
+        promptParts.push(rawAgent.body);
+    }
+}
+function appendPreloadedCommandPromptParts(promptParts, commandNames, commands) {
+    for (const commandName of commandNames) {
+        const command = commands[commandName];
+        if (!command?.template)
+            continue;
+        promptParts.push(`[Preloaded command /${commandName}]\n${materializePreloadedTemplate(command.template)}`);
+    }
+}
+function setOptionalAgentProperties(agent, meta) {
+    if (typeof meta.description === "string")
+        agent.description = meta.description;
+    if (typeof meta.mode === "string")
+        agent.mode = meta.mode;
+    if (typeof meta.model === "string")
+        agent.model = meta.model;
+    if (typeof meta.color === "string")
+        agent.color = meta.color;
 }
 export function registerAgents(agentConfig, pluginRoot, commands) {
     const rawAgents = readMarkdownEntries(pluginRoot, "agents");
     function collectPreloadedCommands(agentName, stack = new Set()) {
         const rawAgent = rawAgents[agentName];
-        if (!rawAgent)
-            return [];
         if (stack.has(agentName))
             return parseCsvList(rawAgent.meta.preload_commands);
         stack.add(agentName);
         const merged = [];
-        const parentAgentName = typeof rawAgent.meta.extends === "string" ? rawAgent.meta.extends.trim() : "";
+        const parentAgentName = getParentAgentName(rawAgent);
         if (parentAgentName && rawAgents[parentAgentName]) {
             merged.push(...collectPreloadedCommands(parentAgentName, stack));
         }
@@ -32,30 +61,12 @@ export function registerAgents(agentConfig, pluginRoot, commands) {
         if (agentConfig[name])
             continue;
         const promptParts = [];
-        const parentAgentName = typeof rawAgent.meta.extends === "string" ? rawAgent.meta.extends.trim() : "";
-        if (parentAgentName && rawAgents[parentAgentName]?.body) {
-            promptParts.push(rawAgents[parentAgentName].body);
-        }
-        if (rawAgent.body) {
-            promptParts.push(rawAgent.body);
-        }
-        for (const commandName of collectPreloadedCommands(name)) {
-            const command = commands[commandName];
-            if (!command?.template)
-                continue;
-            promptParts.push(`[Preloaded command /${commandName}]\n${materializePreloadedTemplate(command.template)}`);
-        }
+        appendAgentPromptParts(promptParts, rawAgents, name);
+        appendPreloadedCommandPromptParts(promptParts, collectPreloadedCommands(name), commands);
         const agent = {
             prompt: promptParts.join("\n\n").trim(),
         };
-        if (typeof rawAgent.meta.description === "string")
-            agent.description = rawAgent.meta.description;
-        if (typeof rawAgent.meta.mode === "string")
-            agent.mode = rawAgent.meta.mode;
-        if (typeof rawAgent.meta.model === "string")
-            agent.model = rawAgent.meta.model;
-        if (typeof rawAgent.meta.color === "string")
-            agent.color = rawAgent.meta.color;
+        setOptionalAgentProperties(agent, rawAgent.meta);
         agentConfig[name] = agent;
     }
 }

package/dist/plugin-registry/commands.js

@@ -4,31 +4,34 @@ import { readMarkdownEntries } from "./markdown.js";
 function normalizeCommandReference(value) {
     if (typeof value !== "string")
         return "";
-    return value.trim().replace(/_/g, "-");
+    return value.trim().replaceAll("_", "-");
+}
+function composeTemplate(rawTemplate, composedTemplate) {
+    if (!composedTemplate) {
+        return rawTemplate;
+    }
+    return [rawTemplate, `In addition you must adhere to the following:\n\n${composedTemplate}`]
+        .filter(Boolean)
+        .join("\n\n");
 }
 function loadMarkdownCommands(pluginRoot) {
     const rawCommands = readMarkdownEntries(pluginRoot, "commands");
     const commands = {};
     function buildComposedTemplate(name, stack = new Set()) {
         const rawCommand = rawCommands[name];
-        if (!rawCommand)
-            return "";
         if (stack.has(name))
             return rawCommand.body;
         stack.add(name);
-        let template = rawCommand.body;
         const composeAfterName = normalizeCommandReference(rawCommand.meta.compose_after);
         const composedCommand = rawCommands[composeAfterName];
         if (composeAfterName && composedCommand) {
             const composedTemplate = buildComposedTemplate(composeAfterName, stack);
-            if (composedTemplate) {
-                template = [template, `In addition you must adhere to the following:\n\n${composedTemplate}`]
-                    .filter(Boolean)
-                    .join("\n\n");
-            }
+            const template = composeTemplate(rawCommand.body, composedTemplate);
+            stack.delete(name);
+            return template.trim();
         }
         stack.delete(name);
-        return template.trim();
+        return rawCommand.body.trim();
     }
     for (const [name, rawCommand] of Object.entries(rawCommands)) {
         const description = typeof rawCommand.meta.description === "string" ? rawCommand.meta.description : `Run /${name}`;

package/dist/plugin-registry/index.js

@@ -1,12 +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 { 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 },
+        tool: {
+            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/plugin-registry/markdown.js

@@ -1,9 +1,15 @@
 import fs from "node:fs";
 import path from "node:path";
+const frontmatterPattern = /^---\n([^]*)\n---\n?([^]*)$/;
+const markdownExtension = ".md";
 function extractFrontmatter(content) {
-    const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
-    if (!match)
-        return { meta: {}, body: content };
+    const match = frontmatterPattern.exec(content);
+    if (!match) {
+        return {
+            meta: {},
+            body: content,
+        };
+    }
     const meta = {};
     for (const rawLine of match[1].split("\n")) {
         const line = rawLine.trim();
@@ -13,21 +19,30 @@ function extractFrontmatter(content) {
         if (separatorIndex <= 0)
             continue;
         const key = line.slice(0, separatorIndex).trim();
-        let value = line.slice(separatorIndex + 1).trim().replace(/^['\"]|['\"]$/g, "");
-        if (value === "true")
-            value = true;
-        if (value === "false")
-            value = false;
+        const rawValue = stripEnclosingQuotes(line.slice(separatorIndex + 1).trim());
+        const value = rawValue === "true" || rawValue === "false" ? rawValue === "true" : rawValue;
         meta[key] = value;
     }
-    return { meta, body: match[2] };
+    return {
+        meta,
+        body: match[2],
+    };
+}
+function stripEnclosingQuotes(value) {
+    if (value.startsWith("'") && value.endsWith("'")) {
+        return value.slice(1, -1);
+    }
+    if (value.startsWith('"') && value.endsWith('"')) {
+        return value.slice(1, -1);
+    }
+    return value;
 }
 function readMarkdownFiles(directoryPath) {
     if (!fs.existsSync(directoryPath))
         return [];
     return fs
         .readdirSync(directoryPath)
-        .filter((file) => file.endsWith(".md"))
+        .filter((file) => file.endsWith(markdownExtension))
         .sort((left, right) => left.localeCompare(right));
 }
 export function readMarkdownEntries(pluginRoot, directoryName) {
@@ -35,7 +50,7 @@ export function readMarkdownEntries(pluginRoot, directoryName) {
     const files = readMarkdownFiles(directoryPath);
     const entries = {};
     for (const file of files) {
-        const name = file.replace(/\.md$/, "");
+        const name = file.slice(0, -markdownExtension.length);
         const fullPath = path.join(directoryPath, file);
         const content = fs.readFileSync(fullPath, "utf8");
         const entry = extractFrontmatter(content);

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

@@ -0,0 +1,19 @@
+import { type CommandRunner } from "../source-control/changed-files.js";
+export interface LintReviewRequest {
+    repositoryRoot?: string;
+    pullRequest?: string;
+    base?: string;
+    head?: string;
+}
+interface LintReviewEnvironment {
+    commandRunner: CommandRunner;
+    lintRunner: (request: {
+        repositoryRoot: string;
+        files: string[];
+    }) => Promise<{
+        exitCode: number;
+        output: string;
+    }>;
+}
+export declare function runPrReviewLint(request: LintReviewRequest, environment: LintReviewEnvironment): Promise<string>;
+export {};

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

@@ -0,0 +1,53 @@
+import path from "node:path";
+import process from "node:process";
+import { resolvePullRequestChangedFiles, } from "../source-control/changed-files.js";
+function normalizeTypeScriptFiles(filePaths) {
+    return filePaths.filter((filePath) => filePath.endsWith(".ts") || filePath.endsWith(".tsx"));
+}
+function formatLintMarkdown(output, fileCount, exitCode) {
+    if (fileCount === 0) {
+        return [
+            "<!-- nt-skillz-lint:start -->",
+            "## Lint",
+            "",
+            "No changed TypeScript files.",
+            "<!-- nt-skillz-lint:end -->",
+        ].join("\n");
+    }
+    if (!output) {
+        return [
+            "<!-- nt-skillz-lint:start -->",
+            "## Lint",
+            "",
+            `PASS: ${fileCount} changed TypeScript file(s).`,
+            "<!-- nt-skillz-lint:end -->",
+        ].join("\n");
+    }
+    const status = exitCode === 0 ? "PASS" : "FAIL";
+    return [
+        "<!-- nt-skillz-lint:start -->",
+        "## Lint",
+        "",
+        `${status}: ${fileCount} changed TypeScript file(s).`,
+        "",
+        "```text",
+        output,
+        "```",
+        "<!-- nt-skillz-lint:end -->",
+    ].join("\n");
+}
+export async function runPrReviewLint(request, environment) {
+    const repositoryRoot = path.resolve(request.repositoryRoot ?? process.cwd());
+    const changedFiles = resolvePullRequestChangedFiles({
+        repositoryRoot,
+        pullRequest: request.pullRequest,
+        base: request.base,
+        head: request.head,
+    }, environment.commandRunner);
+    const typeScriptFiles = normalizeTypeScriptFiles(changedFiles);
+    const outcome = await environment.lintRunner({
+        repositoryRoot,
+        files: typeScriptFiles,
+    });
+    return formatLintMarkdown(outcome.output, typeScriptFiles.length, outcome.exitCode);
+}

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;