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

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;

package/dist/tools/infra/vitest-coverage/test-support.js

@@ -0,0 +1,156 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export function createRepository(sourceFilePath) {
+    const repositoryRoot = fs.mkdtempSync(path.join(os.tmpdir(), "nt-skillz-test-repo-"));
+    const sourceAbsolutePath = path.join(repositoryRoot, sourceFilePath);
+    const vitestBinaryPath = path.join(repositoryRoot, "node_modules", ".bin", "vitest");
+    fs.mkdirSync(path.dirname(sourceAbsolutePath), { recursive: true });
+    fs.mkdirSync(path.dirname(vitestBinaryPath), { recursive: true });
+    fs.writeFileSync(path.join(repositoryRoot, "package.json"), "{}");
+    fs.writeFileSync(sourceAbsolutePath, "export const answer = 42\n");
+    fs.writeFileSync(vitestBinaryPath, "");
+    return repositoryRoot;
+}
+export function createRepositoryWithoutVitest(sourceFilePath) {
+    const repositoryRoot = fs.mkdtempSync(path.join(os.tmpdir(), "nt-skillz-test-repo-"));
+    const sourceAbsolutePath = path.join(repositoryRoot, sourceFilePath);
+    fs.mkdirSync(path.dirname(sourceAbsolutePath), { recursive: true });
+    fs.writeFileSync(path.join(repositoryRoot, "package.json"), "{}");
+    fs.writeFileSync(sourceAbsolutePath, "export const answer = 42\n");
+    return repositoryRoot;
+}
+export function createRepositoryWithoutPackage(sourceFilePath) {
+    const repositoryRoot = fs.mkdtempSync(path.join(os.tmpdir(), "nt-skillz-test-repo-"));
+    const sourceAbsolutePath = path.join(repositoryRoot, sourceFilePath);
+    fs.mkdirSync(path.dirname(sourceAbsolutePath), { recursive: true });
+    fs.writeFileSync(sourceAbsolutePath, "export const answer = 42\n");
+    return repositoryRoot;
+}
+function createCoverageMetric(percent) {
+    return {
+        total: 1,
+        covered: percent === 100 ? 1 : 0,
+        skipped: 0,
+        pct: percent,
+    };
+}
+function writeCoverageSummary(reportsDirectory, filePath, percent) {
+    fs.mkdirSync(reportsDirectory, { recursive: true });
+    fs.writeFileSync(path.join(reportsDirectory, "coverage-summary.json"), JSON.stringify({
+        total: {
+            lines: createCoverageMetric(percent),
+            statements: createCoverageMetric(percent),
+            functions: createCoverageMetric(percent),
+            branches: createCoverageMetric(percent),
+        },
+        [filePath]: {
+            lines: createCoverageMetric(percent),
+            statements: createCoverageMetric(percent),
+            functions: createCoverageMetric(percent),
+            branches: createCoverageMetric(percent),
+        },
+    }));
+}
+export function createCoverageCommandRunner(percent, capturedRuns, commandOutput = "coverage output") {
+    return {
+        run(executable, commandArguments, workingDirectory) {
+            capturedRuns.push({
+                executable,
+                commandArguments,
+                workingDirectory,
+            });
+            const reportsDirectoryArgument = commandArguments.find((commandArgument) => commandArgument.startsWith("--coverage.reportsDirectory="));
+            if (reportsDirectoryArgument === undefined) {
+                return {
+                    status: 1,
+                    stdout: "",
+                    stderr: "missing reports directory",
+                };
+            }
+            const reportsDirectory = reportsDirectoryArgument.replace("--coverage.reportsDirectory=", "");
+            const coverageIncludeArgument = commandArguments.find((commandArgument) => commandArgument.startsWith("--coverage.include="));
+            if (coverageIncludeArgument === undefined) {
+                return {
+                    status: 1,
+                    stdout: "",
+                    stderr: "missing coverage include",
+                };
+            }
+            const coveredFilePath = coverageIncludeArgument.replace("--coverage.include=", "");
+            writeCoverageSummary(reportsDirectory, path.join(workingDirectory, coveredFilePath), percent);
+            return {
+                status: percent === 100 ? 0 : 1,
+                stdout: commandOutput,
+                stderr: "",
+            };
+        },
+    };
+}
+export function createPullRequestCoverageCommandRunner(changedFiles, percent) {
+    return {
+        run(executable, commandArguments, workingDirectory) {
+            if (executable === "gh") {
+                return {
+                    status: 0,
+                    stdout: changedFiles.join("\n"),
+                    stderr: "",
+                };
+            }
+            return createCoverageCommandRunner(percent, []).run(executable, commandArguments, workingDirectory);
+        },
+    };
+}
+export function createCoverageSummaryCommandRunner(summaryJson) {
+    return {
+        run(_executable, commandArguments) {
+            const reportsDirectoryArgument = commandArguments.find((commandArgument) => commandArgument.startsWith("--coverage.reportsDirectory="));
+            if (reportsDirectoryArgument !== undefined) {
+                const reportsDirectory = reportsDirectoryArgument.replace("--coverage.reportsDirectory=", "");
+                fs.mkdirSync(reportsDirectory, { recursive: true });
+                fs.writeFileSync(path.join(reportsDirectory, "coverage-summary.json"), summaryJson);
+            }
+            return {
+                status: 0,
+                stdout: "",
+                stderr: "",
+            };
+        },
+    };
+}
+export function createCoverageErrorCommandRunner() {
+    return {
+        run() {
+            return {
+                status: null,
+                stdout: "coverage stdout",
+                stderr: "coverage stderr",
+                errorMessage: "spawn failed",
+            };
+        },
+    };
+}
+export function installFailingVitestBinary(repositoryRoot) {
+    const vitestBinaryPath = path.join(repositoryRoot, "node_modules", ".bin", "vitest");
+    const scriptContent = [
+        "#!/usr/bin/env node",
+        "const fs = require('node:fs')",
+        "const path = require('node:path')",
+        "const filePath = path.join(process.cwd(), process.argv[3])",
+        "const reportsArgument = process.argv.find((argument) => argument.startsWith('--coverage.reportsDirectory='))",
+        "const reportsDirectory = reportsArgument.replace('--coverage.reportsDirectory=', '')",
+        "const metric = { total: 1, covered: 0, skipped: 0, pct: 50 }",
+        "fs.mkdirSync(reportsDirectory, { recursive: true })",
+        "fs.writeFileSync(path.join(reportsDirectory, 'coverage-summary.json'), JSON.stringify({ total: { lines: metric, statements: metric, functions: metric, branches: metric }, [filePath]: { lines: metric, statements: metric, functions: metric, branches: metric } }))",
+        "process.stdout.write('tool coverage output')",
+        "process.exit(1)",
+    ].join("\n");
+    fs.rmSync(vitestBinaryPath, { force: true });
+    fs.writeFileSync(vitestBinaryPath, scriptContent, { mode: 0o755 });
+}
+export function removeDirectory(directoryPath) {
+    fs.rmSync(directoryPath, {
+        recursive: true,
+        force: true,
+    });
+}

package/dist/tools/lint.d.ts

@@ -1,3 +1,4 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
 interface PortableLintRequest {
     repositoryRoot?: string;
     files?: string[];
@@ -9,23 +10,8 @@ interface PortableLintOutcome {
     output: string;
 }
 export declare const LINT_TOOL_NAME = "nt_skillz_lint";
+export declare function prependLintFailureGuidance(formattedOutput: string, errorCount: number, lintFailureGuidance: string): string;
 export declare function runPortableLint(request: PortableLintRequest): Promise<PortableLintOutcome>;
 export declare function runPortableLintFromCommandLine(commandLineArguments: string[]): Promise<number>;
-export declare const lintTool: {
-    description: string;
-    args: {
-        mode: import("zod").ZodOptional<import("zod").ZodString>;
-        pullRequest: import("zod").ZodOptional<import("zod").ZodString>;
-        files: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-        base: import("zod").ZodOptional<import("zod").ZodString>;
-        head: import("zod").ZodOptional<import("zod").ZodString>;
-    };
-    execute(args: {
-        mode?: string | undefined;
-        pullRequest?: string | undefined;
-        files?: string[] | undefined;
-        base?: string | undefined;
-        head?: string | undefined;
-    }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
-};
+export declare const lintTool: ToolDefinition;
 export {};

package/dist/tools/lint.js

@@ -5,9 +5,10 @@ import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { parseArgs } from "node:util";
 import { ESLint } from "eslint";
-import { tool } from "@opencode-ai/plugin";
-import { childProcessCommandRunner } from "./pull-request-files.js";
-import { runPrReviewLint } from "./lint-review.js";
+import { tool, } from "@opencode-ai/plugin";
+import { createLintFailureGuidance } from "./infra/lint/guidance.js";
+import { childProcessCommandRunner } from "./infra/source-control/changed-files.js";
+import { runPrReviewLint } from "./infra/lint/review.js";
 class UsageError extends Error {
     constructor(message) {
         super(message);
@@ -33,6 +34,14 @@ const toolDirectory = path.dirname(fileURLToPath(import.meta.url));
 const toolRepositoryRoot = path.resolve(toolDirectory, "..", "..");
 const eslintConfigPath = path.join(toolRepositoryRoot, "scripts", "living-architecture-eslint.config.mjs");
 const gitBinaryPath = "/usr/bin/git";
+const helpText = [
+    "Usage: ./scripts/lint-ts.sh [--repo PATH] [--base REF] [--head REF] [file ...]",
+    "",
+    "Examples:",
+    "  ./scripts/lint-ts.sh --repo ../living-architecture --base origin/main",
+    "  ./scripts/lint-ts.sh --repo ../living-architecture packages/example/src/example.ts",
+    "  ./scripts/lint-ts.sh src/example.ts",
+].join("\n");
 export const LINT_TOOL_NAME = "nt_skillz_lint";
 function normalizeOptionalText(value) {
     if (typeof value !== "string") {
@@ -89,8 +98,8 @@ function runGitCommand(repositoryRoot, gitArguments) {
     if (gitResult.status === 0) {
         return gitResult.stdout;
     }
-    const errorOutput = gitResult.stderr.trim() || gitResult.stdout.trim() || "git command failed";
-    throw new GitCommandError(`Expected git command to succeed. Got ${errorOutput}.`);
+    const failureOutput = gitResult.stderr.trim() || gitResult.stdout.trim() || `exit status ${gitResult.status}`;
+    throw new GitCommandError(`Expected git command to succeed. Got ${failureOutput}.`);
 }
 function readChangedTypeScriptFiles(repositoryRoot, baseReference, headReference) {
     const diffRange = `${baseReference}...${headReference}`;
@@ -146,6 +155,15 @@ function createLintTitle(filePaths, baseReference) {
 function removeAnsiEscapeSequences(value) {
     return value.replaceAll(ansiEscapeSequencePattern, "");
 }
+export function prependLintFailureGuidance(formattedOutput, errorCount, lintFailureGuidance) {
+    if (errorCount === 0) {
+        return formattedOutput;
+    }
+    if (!formattedOutput) {
+        return lintFailureGuidance;
+    }
+    return [lintFailureGuidance, "", formattedOutput].join("\n");
+}
 async function runEslint(repositoryRoot, lintTargets) {
     const previousLintRepositoryRoot = process.env.NT_SKILLZ_LINT_REPO_ROOT;
     process.env.NT_SKILLZ_LINT_REPO_ROOT = repositoryRoot;
@@ -162,7 +180,7 @@ async function runEslint(repositoryRoot, lintTargets) {
         const errorCount = lintResults.reduce((count, lintResult) => count + lintResult.errorCount + lintResult.fatalErrorCount, 0);
         return {
             exitCode: errorCount > 0 ? 1 : 0,
-            output: formattedOutput,
+            output: prependLintFailureGuidance(formattedOutput, errorCount, createLintFailureGuidance(lintResults)),
         };
     }
     finally {
@@ -188,17 +206,6 @@ function parsePortableLintCommandLine(commandLineArguments) {
         },
         allowPositionals: true,
     });
-    if (parsedArguments.values.help) {
-        process.stdout.write([
-            "Usage: ./scripts/lint-ts.sh [--repo PATH] [--base REF] [--head REF] [file ...]",
-            "",
-            "Examples:",
-            "  ./scripts/lint-ts.sh --repo ../living-architecture --base origin/main",
-            "  ./scripts/lint-ts.sh --repo ../living-architecture packages/example/src/example.ts",
-            "  ./scripts/lint-ts.sh src/example.ts",
-        ].join("\n") + "\n");
-        process.exit(0);
-    }
     return {
         repositoryRoot: resolveDirectory(parsedArguments.values.repo ?? process.cwd()),
         files: normalizeFilePaths(parsedArguments.positionals),
@@ -223,6 +230,10 @@ export async function runPortableLint(request) {
     return runEslint(repositoryRoot, lintTargets);
 }
 export async function runPortableLintFromCommandLine(commandLineArguments) {
+    if (commandLineArguments.includes("--help") || commandLineArguments.includes("-h")) {
+        process.stdout.write(`${helpText}\n`);
+        return 0;
+    }
     const request = parsePortableLintCommandLine(commandLineArguments);
     const outcome = await runPortableLint(request);
     if (outcome.output) {
@@ -267,7 +278,7 @@ export const lintTool = tool({
             head: headReference,
         });
         if (outcome.exitCode !== 0) {
-            throw new LintExecutionError(outcome.output || "Lint failed.");
+            throw new LintExecutionError(outcome.output);
         }
         return {
             output: outcome.output || "Lint passed.",

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

@@ -0,0 +1,5 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+import { PULL_REQUEST_FEEDBACK_TOOL_NAME, type PullRequestFeedbackDependencies } from "./infra/pull-request/feedback.js";
+export declare function createPullRequestFeedbackTool(dependencies?: PullRequestFeedbackDependencies): ToolDefinition;
+export declare const pullRequestFeedbackTool: ToolDefinition;
+export { PULL_REQUEST_FEEDBACK_TOOL_NAME };

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

@@ -0,0 +1,23 @@
+import { tool, } from "@opencode-ai/plugin";
+import { PULL_REQUEST_FEEDBACK_TOOL_NAME, readPullRequestFeedback, } from "./infra/pull-request/feedback.js";
+export function createPullRequestFeedbackTool(dependencies = {}) {
+    return tool({
+        description: "Fetch unresolved GitHub pull request review feedback with diff hunks and local code excerpts.",
+        args: {
+            pullRequestNumber: tool.schema.string().describe("Pull request number from GitHub."),
+            pullRequestUrl: tool.schema.string().describe("Full GitHub pull request URL."),
+        },
+        async execute(request, context) {
+            context.metadata({ title: "Fetch unresolved PR feedback" });
+            return {
+                output: readPullRequestFeedback({
+                    repositoryRoot: context.worktree,
+                    pullRequestNumber: request.pullRequestNumber,
+                    pullRequestUrl: request.pullRequestUrl,
+                }, dependencies),
+            };
+        },
+    });
+}
+export const pullRequestFeedbackTool = createPullRequestFeedbackTool();
+export { PULL_REQUEST_FEEDBACK_TOOL_NAME };

package/dist/tools/vitest-coverage-tool.d.ts

@@ -0,0 +1,4 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+import { VITEST_COVERAGE_TOOL_NAME } from "./infra/vitest-coverage/review.js";
+export declare const vitestCoverageTool: ToolDefinition;
+export { VITEST_COVERAGE_TOOL_NAME };

package/dist/tools/vitest-coverage-tool.js

@@ -0,0 +1,31 @@
+import { tool, } from "@opencode-ai/plugin";
+import { runVitestCoverageReview, VITEST_COVERAGE_TOOL_NAME, } from "./infra/vitest-coverage/review.js";
+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,
+            },
+        };
+    },
+});
+export { VITEST_COVERAGE_TOOL_NAME };

package/dist/types.d.ts

@@ -71,12 +71,20 @@ export interface OpencodeClient {
 export interface PluginHooks {
     config?: (config: PluginConfig) => Promise<void>;
     tool?: Record<string, ToolDefinition>;
+    "tool.execute.before"?: (input: ToolExecuteBeforeInput, output: ToolExecuteBeforeOutput) => Promise<void>;
     "command.execute.before"?: (input: CommandExecuteBeforeInput, output: CommandExecuteBeforeOutput) => Promise<void>;
     "experimental.chat.system.transform"?: (input: ChatSystemTransformInput, output: ChatSystemTransformOutput) => Promise<void>;
     event?: (input: {
         event: SessionEvent;
     }) => Promise<void>;
 }
+export interface ToolExecuteBeforeInput {
+    tool: string;
+}
+export interface ToolExecuteBeforeOutput {
+    args: Record<string, unknown>;
+}
 export interface PluginInput {
     client: OpencodeClient;
+    worktree?: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nt-ai-lab/opencode-skillz",
-  "version": "0.3.15",
+  "version": "0.4.1",
   "description": "Bundled OpenCode commands and agents",
   "type": "module",
   "main": "dist/index.js",
@@ -13,7 +13,7 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "lint": "npm run build && node scripts/lint-ts.mjs",
+    "lint": "npm run build && node scripts/check-tools-folder-boundary.mjs && node scripts/lint-ts.mjs",
     "test": "vitest run",
     "coverage": "vitest run --coverage",
     "prepare": "node scripts/install-git-hooks.mjs",
@@ -38,7 +38,8 @@
     "eslint-plugin-sonarjs": "^3.0.5",
     "eslint-plugin-unicorn": "^62.0.0",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.50.1"
+    "typescript-eslint": "^8.50.1",
+    "zod": "^4.4.1"
   },
   "devDependencies": {
     "@types/node": "^24.7.2",