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

package/commands/review-pr.md

@@ -49,26 +49,19 @@ Provide the subagent with:
 - the changed file list
 - the changed diff context
 
-## Test Coverage Analysis
-
-Add a test coverage analysis results section to the PR description:
-
-1. For each changed path from `gh pr diff <pr> --name-only`, run `/nt-skillz:vitest-coverage <file>`.
-2. Ignore only runs that print a `SKIP:` line.
-3. If every run prints a `SKIP:` line, use one fenced `text` block containing `No changed TypeScript source files.` as the coverage content.
-4. Otherwise, build the PR coverage block in this exact shape:
-    - `<!-- nt-skillz-coverage:start -->`
-    - `## Coverage`
-    - one `### \`<file>\`` heading for each non-`SKIP:` file
-    - one fenced `text` block containing the exact raw `/nt-skillz:vitest-coverage <file>` output directly under that file heading
-    - `<!-- nt-skillz-coverage:end -->`
-5. Run `gh pr view <pr> --json body --jq '.body'` and use the returned text as the current PR body.
-6. If the current PR body already contains both marker lines, replace only the text from `<!-- nt-skillz-coverage:start -->` through `<!-- nt-skillz-coverage:end -->` with the new coverage block.
-7. If the current PR body does not contain both marker lines, append the new coverage block to the end of the PR body separated by two newlines.
-8. Write the updated PR body to a temporary file.
-9. Run `gh pr edit <pr> --body-file <temporary-file>`.
-10. Do not summarize, interpret, or paraphrase the coverage output.
-11. Do not modify any other part of the PR body.
+## Tool-Generated PR Description Sections
+
+Add generated lint and coverage sections to the PR description:
+
+1. Invoke the `nt_skillz_lint` tool with `mode: "pr-review"` and the resolved PR identifier.
+2. Invoke the `nt_skillz_vitest_coverage` tool with `mode: "pr-review"` and the resolved PR identifier.
+3. Use the exact markdown returned by each tool. Do not summarize, interpret, paraphrase, or reformat tool output.
+4. Run `gh pr view <pr> --json body --jq '.body'` and use the returned text as the current PR body.
+5. If the current PR body already contains both marker lines for a generated section, replace only the text from the start marker through the end marker with the new tool output for that section.
+6. If the current PR body does not contain both marker lines for a generated section, append the new tool output to the end of the PR body separated by two newlines.
+7. Write the updated PR body to a temporary file.
+8. Run `gh pr edit <pr> --body-file <temporary-file>`.
+9. Do not modify any other part of the PR body.
 
 ## Basic PR checks
 

package/dist/commands/dont-stop/hooks.js

@@ -1,11 +1,19 @@
 import { CLEAR_DONT_STOP_COMMAND_NAME, DONT_STOP_COMMAND_NAME, } from "./register.js";
 import { createDontStopState } from "./state.js";
+const statusStartMarker = "<dont-stop-status>";
+const statusEndMarker = "</dont-stop-status>";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function unwrapResponse(result) {
-    return typeof result === "object" && result !== null && "data" in result ? result.data : result;
+    if (isRecord(result) && "data" in result) {
+        return result.data;
+    }
+    return result;
 }
 function normalizeCriteria(value) {
     return value
-        .split(/\n|;/)
+        .split(/[\n;]/)
         .map((item) => item.replace(/^\s*[-*]\s*/, "").trim())
         .filter(Boolean);
 }
@@ -41,43 +49,73 @@ function buildSystemInstruction(criteria) {
     ].join("\n");
 }
 function parseAssistantStatus(text) {
-    const match = text.match(/<dont-stop-status>([\s\S]*?)<\/dont-stop-status>/i);
-    if (!match)
+    const lowerText = text.toLowerCase();
+    const startIndex = lowerText.indexOf(statusStartMarker);
+    const endIndex = lowerText.indexOf(statusEndMarker);
+    if (startIndex < 0 || endIndex < 0 || endIndex <= startIndex)
         return null;
-    const body = match[1];
-    const stateMatch = body.match(/^\s*state\s*:\s*(continue|completion-requested|blocked-requested)\s*$/im);
-    const justificationMatch = body.match(/^\s*justification\s*:\s*(.+)\s*$/im);
-    const reasonMatch = body.match(/^\s*reason\s*:\s*(.+)\s*$/im);
+    const body = text.slice(startIndex + statusStartMarker.length, endIndex);
+    const fields = Object.fromEntries(body
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.includes(":"))
+        .map((line) => [line.slice(0, line.indexOf(":")).trim(), line.slice(line.indexOf(":") + 1).trim()]));
+    const state = parseAssistantState(fields.state);
     return {
-        state: stateMatch?.[1] ?? "continue",
-        justification: justificationMatch?.[1]?.trim() ?? "",
-        reason: reasonMatch?.[1]?.trim() ?? "",
+        state,
+        justification: readStatusField(fields, "justification"),
+        reason: readStatusField(fields, "reason"),
     };
 }
+function readStatusField(fields, key) {
+    const value = fields[key];
+    if (typeof value === "string") {
+        return value;
+    }
+    return "";
+}
+function parseAssistantState(value) {
+    if (value === "completion-requested" || value === "blocked-requested") {
+        return value;
+    }
+    return "continue";
+}
 async function showToast(client, body) {
     try {
         await client.tui.showToast({ body });
     }
-    catch { }
+    catch {
+        return;
+    }
+}
+function isMessagePart(value) {
+    return isRecord(value);
+}
+function isSessionMessage(value) {
+    if (!isRecord(value))
+        return false;
+    if (!("parts" in value))
+        return true;
+    return Array.isArray(value.parts) && value.parts.every(isMessagePart);
+}
+function readAssistantText(message) {
+    const parts = message.parts ?? [];
+    return parts
+        .filter((part) => part.type === "text" && typeof part.text === "string")
+        .map((part) => part.text)
+        .join("\n");
 }
 async function getLatestAssistantStatus(client, sessionID) {
     const result = unwrapResponse(await client.session.messages({ path: { id: sessionID } }));
-    const messages = Array.isArray(result) ? result : [];
-    for (let index = messages.length - 1; index >= 0; index -= 1) {
-        const entry = messages[index];
-        if (entry.info?.role !== "assistant")
-            continue;
-        const text = (entry.parts ?? [])
-            .filter((part) => part.type === "text" && typeof part.text === "string")
-            .map((part) => part.text)
-            .join("\n");
-        return parseAssistantStatus(text);
-    }
+    const messages = Array.isArray(result) ? result.filter(isSessionMessage) : [];
+    const latestAssistantMessage = [...messages].reverse().find((entry) => entry.info?.role === "assistant");
+    if (latestAssistantMessage)
+        return parseAssistantStatus(readAssistantText(latestAssistantMessage));
     return null;
 }
 function buildContinuationPrompt(criteria, status) {
     const reportedState = status?.state ?? "missing";
-    const reason = status?.reason || "none";
+    const reason = status?.reason ?? "none";
     return [
         "dont-stop remains active.",
         "",
@@ -116,16 +154,18 @@ function getDeletedSessionID(event) {
     if (event.type !== "session.deleted")
         return undefined;
     const properties = event.properties;
-    if (!properties || typeof properties !== "object")
+    if (!isRecord(properties))
         return undefined;
     const info = properties.info;
-    return typeof info?.id === "string" ? info.id : undefined;
+    if (!isRecord(info))
+        return undefined;
+    return typeof info.id === "string" ? info.id : undefined;
 }
 function getIdleSessionID(event) {
     if (event.type !== "session.idle")
         return undefined;
     const properties = event.properties;
-    if (!properties || typeof properties !== "object")
+    if (!isRecord(properties))
         return undefined;
     const sessionID = properties.sessionID;
     return typeof sessionID === "string" ? sessionID : undefined;

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,7 +8,40 @@ 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];
+    if (!rawAgent)
+        return;
+    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");
@@ -20,7 +53,7 @@ export function registerAgents(agentConfig, pluginRoot, commands) {
             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 +65,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,7 +4,15 @@ 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");
@@ -16,19 +24,16 @@ function loadMarkdownCommands(pluginRoot) {
         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,16 @@
 import { createDontStopHooks } from "../commands/dont-stop/index.js";
 import { LINT_TOOL_NAME, lintTool, } from "../tools/lint.js";
+import { VITEST_COVERAGE_TOOL_NAME, vitestCoverageTool, } from "../tools/vitest-coverage.js";
 import { registerAgents } from "./agents.js";
 import { registerCommands } from "./commands.js";
 export function createPluginRegistry(input, pluginRoot) {
     const dontStopHooks = createDontStopHooks(input.client);
     return {
         ...dontStopHooks,
-        tool: { [LINT_TOOL_NAME]: lintTool },
+        tool: {
+            [LINT_TOOL_NAME]: lintTool,
+            [VITEST_COVERAGE_TOOL_NAME]: vitestCoverageTool,
+        },
         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/lint-review.d.ts

@@ -0,0 +1,19 @@
+import { type CommandRunner } from "./pull-request-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/lint-review.js

@@ -0,0 +1,53 @@
+import path from "node:path";
+import process from "node:process";
+import { resolvePullRequestChangedFiles, } from "./pull-request-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/lint.d.ts

@@ -14,11 +14,15 @@ export declare function runPortableLintFromCommandLine(commandLineArguments: str
 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;

package/dist/tools/lint.js

@@ -6,6 +6,8 @@ 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";
 class UsageError extends Error {
     constructor(message) {
         super(message);
@@ -42,6 +44,16 @@ function normalizeOptionalText(value) {
     }
     return trimmedValue;
 }
+function normalizeToolMode(value) {
+    const normalizedValue = normalizeOptionalText(value);
+    if (!normalizedValue) {
+        return "files";
+    }
+    if (normalizedValue === "files" || normalizedValue === "pr-review") {
+        return normalizedValue;
+    }
+    throw new UsageError(`Expected lint mode to be 'files' or 'pr-review'. Got ${normalizedValue}.`);
+}
 function resolveDirectory(directoryPath) {
     const absoluteDirectoryPath = path.resolve(directoryPath);
     if (!fs.existsSync(absoluteDirectoryPath)) {
@@ -221,11 +233,28 @@ export async function runPortableLintFromCommandLine(commandLineArguments) {
 export const lintTool = tool({
     description: "Run bundled TypeScript lint rules against current project files.",
     args: {
+        mode: tool.schema.string().optional().describe("Use 'pr-review' to lint changed pull request TypeScript files."),
+        pullRequest: tool.schema.string().optional().describe("Pull request number or URL for pr-review mode."),
         files: tool.schema.array(tool.schema.string()).optional().describe("Relative .ts or .tsx file paths to lint."),
         base: tool.schema.string().optional().describe("Base git reference for PR-style changed-file linting."),
         head: tool.schema.string().optional().describe("Optional head git reference used with base."),
     },
     async execute(request, context) {
+        const mode = normalizeToolMode(request.mode);
+        if (mode === "pr-review") {
+            context.metadata({ title: "Lint pull request TypeScript changes" });
+            return {
+                output: await runPrReviewLint({
+                    repositoryRoot: context.worktree,
+                    pullRequest: normalizeOptionalText(request.pullRequest),
+                    base: normalizeOptionalText(request.base),
+                    head: normalizeOptionalText(request.head),
+                }, {
+                    commandRunner: childProcessCommandRunner,
+                    lintRunner: runPortableLint,
+                }),
+            };
+        }
         const filePaths = normalizeFilePaths(request.files);
         const baseReference = normalizeOptionalText(request.base);
         const headReference = normalizeOptionalText(request.head);

package/dist/tools/pull-request-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/pull-request-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/vitest-coverage.d.ts

@@ -0,0 +1,67 @@
+import { type CommandRunner } from "./pull-request-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 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

@@ -0,0 +1,335 @@
+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";
+export const VITEST_COVERAGE_TOOL_NAME = "nt_skillz_vitest_coverage";
+class CoverageUsageError extends Error {
+}
+class CoverageSummaryReadError extends Error {
+}
+function normalizeOptionalText(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmedValue = value.trim();
+    if (!trimmedValue) {
+        return undefined;
+    }
+    return trimmedValue;
+}
+function normalizeMode(value) {
+    const normalizedMode = normalizeOptionalText(value);
+    if (!normalizedMode) {
+        return "files";
+    }
+    if (normalizedMode === "pr-review") {
+        return "pr-review";
+    }
+    if (normalizedMode === "files") {
+        return "files";
+    }
+    throw new CoverageUsageError(`Expected coverage mode to be 'files' or 'pr-review'. Got ${normalizedMode}.`);
+}
+function isTypeScriptPath(filePath) {
+    return filePath.endsWith(".ts") || filePath.endsWith(".tsx");
+}
+function isExcludedTypeScriptPath(filePath) {
+    return (filePath.endsWith(".spec.ts")
+        || filePath.endsWith(".spec.tsx")
+        || filePath.endsWith(".test.ts")
+        || filePath.endsWith(".test.tsx")
+        || filePath.endsWith(".d.ts")
+        || filePath.endsWith(".config.ts")
+        || filePath.endsWith(".config.tsx")
+        || filePath.includes("/fixtures/")
+        || filePath.includes("/__fixtures__/"));
+}
+function isCoverableSourcePath(repositoryRoot, filePath) {
+    if (!isTypeScriptPath(filePath)) {
+        return false;
+    }
+    if (isExcludedTypeScriptPath(filePath)) {
+        return false;
+    }
+    const absoluteFilePath = path.resolve(repositoryRoot, filePath);
+    return fs.existsSync(absoluteFilePath) && fs.statSync(absoluteFilePath).isFile();
+}
+function normalizeFileList(filePaths) {
+    if (!filePaths) {
+        return [];
+    }
+    return [...new Set(filePaths.map((filePath) => filePath.trim()).filter(Boolean))];
+}
+function resolveCoverageTargets(request, repositoryRoot, commandRunner) {
+    const mode = normalizeMode(request.mode);
+    if (mode === "pr-review") {
+        return resolvePullRequestChangedFiles({
+            repositoryRoot,
+            pullRequest: request.pullRequest,
+            base: request.base,
+            head: request.head,
+        }, commandRunner).filter((filePath) => isCoverableSourcePath(repositoryRoot, filePath));
+    }
+    return normalizeFileList(request.files).filter((filePath) => isCoverableSourcePath(repositoryRoot, filePath));
+}
+function findPackageRootFromDirectory(repositoryRoot, directoryPath) {
+    if (fs.existsSync(path.join(directoryPath, "package.json"))) {
+        return directoryPath;
+    }
+    if (directoryPath === repositoryRoot) {
+        throw new CoverageUsageError(`Expected package.json ancestor for ${directoryPath}.`);
+    }
+    const parentDirectoryPath = path.dirname(directoryPath);
+    if (parentDirectoryPath === directoryPath) {
+        throw new CoverageUsageError(`Expected package.json ancestor for ${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);
+    const output = [commandResult.stdout, commandResult.stderr].filter(Boolean).join("\n").trim();
+    return {
+        status: commandResult.status,
+        output,
+        errorMessage: commandResult.errorMessage,
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readNumber(record, key) {
+    const value = record[key];
+    if (typeof value === "number") {
+        return value;
+    }
+    throw new CoverageSummaryReadError(`Expected numeric coverage field '${key}'.`);
+}
+function readMetric(record, key) {
+    const value = record[key];
+    if (!isRecord(value)) {
+        throw new CoverageSummaryReadError(`Expected coverage metric '${key}'.`);
+    }
+    return {
+        total: readNumber(value, "total"),
+        covered: readNumber(value, "covered"),
+        skipped: readNumber(value, "skipped"),
+        pct: readNumber(value, "pct"),
+    };
+}
+function readFileCoverageSummary(value) {
+    if (!isRecord(value)) {
+        throw new CoverageSummaryReadError("Expected file coverage summary object.");
+    }
+    return {
+        lines: readMetric(value, "lines"),
+        statements: readMetric(value, "statements"),
+        functions: readMetric(value, "functions"),
+        branches: readMetric(value, "branches"),
+    };
+}
+function normalizeCoverageKey(packageRoot, coverageKey) {
+    if (path.isAbsolute(coverageKey)) {
+        return path.resolve(coverageKey);
+    }
+    return path.resolve(packageRoot, coverageKey);
+}
+function readCoverageSummary(packageRoot, reportsDirectory, packageRelativeFilePath) {
+    const summaryPath = path.join(reportsDirectory, "coverage-summary.json");
+    if (!fs.existsSync(summaryPath)) {
+        throw new CoverageSummaryReadError(`Expected coverage summary at ${summaryPath}.`);
+    }
+    const parsedSummary = JSON.parse(fs.readFileSync(summaryPath, "utf8"));
+    if (!isRecord(parsedSummary)) {
+        throw new CoverageSummaryReadError("Expected coverage summary JSON object.");
+    }
+    const expectedFilePath = path.resolve(packageRoot, packageRelativeFilePath);
+    const matchingCoverageEntry = Object.entries(parsedSummary).find(([coverageKey]) => normalizeCoverageKey(packageRoot, coverageKey) === expectedFilePath);
+    if (!matchingCoverageEntry) {
+        throw new CoverageSummaryReadError(`Expected coverage summary row for ${packageRelativeFilePath}.`);
+    }
+    return readFileCoverageSummary(matchingCoverageEntry[1]);
+}
+function hasCompleteCoverage(summary) {
+    return summary.statements.pct === 100
+        && summary.branches.pct === 100
+        && summary.functions.pct === 100
+        && summary.lines.pct === 100;
+}
+function formatCoverageErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return `Expected coverage error message. Got ${String(error)}.`;
+}
+function executeCoverageWithReports(filePath, packageRoot, packageRelativeFilePath, environment) {
+    const reportsDirectory = environment.temporaryDirectoryCreator(path.join(os.tmpdir(), "nt-skillz-coverage-"));
+    try {
+        const commandResult = runCoverageCommand(packageRoot, packageRelativeFilePath, reportsDirectory, environment);
+        if (commandResult.errorMessage) {
+            return {
+                status: "errored",
+                filePath,
+                message: commandResult.errorMessage,
+                commandOutput: commandResult.output,
+            };
+        }
+        const summary = readCoverageSummary(packageRoot, reportsDirectory, packageRelativeFilePath);
+        if (commandResult.status === 0 && hasCompleteCoverage(summary)) {
+            return {
+                status: "passed",
+                filePath,
+                summary,
+            };
+        }
+        return {
+            status: "failed",
+            filePath,
+            summary,
+            commandOutput: commandResult.output,
+        };
+    }
+    catch (error) {
+        const message = formatCoverageErrorMessage(error);
+        return {
+            status: "errored",
+            filePath,
+            message,
+            commandOutput: "",
+        };
+    }
+    finally {
+        environment.temporaryDirectoryRemover(reportsDirectory);
+    }
+}
+function executeFileCoverage(repositoryRoot, filePath, environment) {
+    try {
+        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);
+    }
+    catch (error) {
+        const message = formatCoverageErrorMessage(error);
+        return {
+            status: "errored",
+            filePath,
+            message,
+            commandOutput: "",
+        };
+    }
+}
+function formatPercent(metric) {
+    return `${metric.pct}%`;
+}
+function formatCoverageRow(result) {
+    if (result.status === "errored") {
+        return `| \`${result.filePath}\` | error | error | error | error | ERROR |`;
+    }
+    const status = result.status === "passed" ? "PASS" : "FAIL";
+    return `| \`${result.filePath}\` | ${formatPercent(result.summary.statements)} | ${formatPercent(result.summary.branches)} | ${formatPercent(result.summary.functions)} | ${formatPercent(result.summary.lines)} | ${status} |`;
+}
+function formatCoverageDetails(result) {
+    if (result.status === "passed") {
+        return [];
+    }
+    const detailContent = result.status === "failed" ? result.commandOutput : [result.message, result.commandOutput].filter(Boolean).join("\n");
+    if (!detailContent) {
+        return [];
+    }
+    return [
+        `<details><summary>Coverage output for \`${result.filePath}\`</summary>`,
+        "",
+        "```text",
+        detailContent,
+        "```",
+        "",
+        "</details>",
+    ];
+}
+function formatCoverageMarkdown(results) {
+    if (results.length === 0) {
+        return [
+            "<!-- nt-skillz-coverage:start -->",
+            "## Coverage",
+            "",
+            "No changed TypeScript source files.",
+            "<!-- nt-skillz-coverage:end -->",
+        ].join("\n");
+    }
+    const tableRows = results.map(formatCoverageRow);
+    const detailRows = results.flatMap(formatCoverageDetails);
+    const lines = [
+        "<!-- nt-skillz-coverage:start -->",
+        "## Coverage",
+        "",
+        "| File | Statements | Branches | Functions | Lines | Status |",
+        "| --- | ---: | ---: | ---: | ---: | --- |",
+        ...tableRows,
+    ];
+    if (detailRows.length > 0) {
+        return [...lines, "", ...detailRows, "<!-- nt-skillz-coverage:end -->"].join("\n");
+    }
+    return [...lines, "<!-- nt-skillz-coverage:end -->"].join("\n");
+}
+export async function runVitestCoverageReview(request, environment = {
+    commandRunner: childProcessCommandRunner,
+    temporaryDirectoryCreator: fs.mkdtempSync,
+    temporaryDirectoryRemover: (directoryPath) => fs.rmSync(directoryPath, {
+        recursive: true,
+        force: true,
+    }),
+}) {
+    const repositoryRoot = path.resolve(request.repositoryRoot ?? process.cwd());
+    const coverageTargets = resolveCoverageTargets(request, repositoryRoot, environment.commandRunner);
+    const results = coverageTargets.map((filePath) => executeFileCoverage(repositoryRoot, filePath, environment));
+    return {
+        markdown: formatCoverageMarkdown(results),
+        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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nt-ai-lab/opencode-skillz",
-  "version": "0.3.14",
+  "version": "0.3.15",
   "description": "Bundled OpenCode commands and agents",
   "type": "module",
   "main": "dist/index.js",
@@ -13,6 +13,10 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
+    "lint": "npm run build && node scripts/lint-ts.mjs",
+    "test": "vitest run",
+    "coverage": "vitest run --coverage",
+    "prepare": "node scripts/install-git-hooks.mjs",
     "prepack": "npm run build"
   },
   "files": [
@@ -37,7 +41,9 @@
     "typescript-eslint": "^8.50.1"
   },
   "devDependencies": {
-    "@types/node": "^24.7.2"
+    "@types/node": "^24.7.2",
+    "@vitest/coverage-v8": "^4.1.5",
+    "vitest": "^4.1.5"
   },
   "publishConfig": {
     "access": "public"

package/scripts/install-git-hooks.mjs

@@ -0,0 +1,16 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+const gitDirectory = path.resolve('.git')
+const hooksDirectory = path.join(gitDirectory, 'hooks')
+const preCommitHookPath = path.join(hooksDirectory, 'pre-commit')
+
+if (fs.existsSync(gitDirectory)) {
+  fs.mkdirSync(hooksDirectory, { recursive: true })
+  fs.writeFileSync(preCommitHookPath, [
+    '#!/usr/bin/env bash',
+    'set -euo pipefail',
+    'npm run lint',
+    '',
+  ].join('\n'), { mode: 0o755 })
+}

package/scripts/living-architecture-eslint.config.mjs

@@ -153,12 +153,14 @@ export default tseslint.config(
       ecmaVersion: 2020,
       sourceType: 'module',
       parserOptions: {
-        projectService: true,
+        projectService: {
+          allowDefaultProject: ['src/tools/*.spec.ts', 'src/tools/*-test-support.ts', 'vitest.config.ts'],
+        },
         tsconfigRootDir: lintRepositoryRoot,
       },
     },
     rules: {
-      'import/extensions': ['error', 'never', { ts: 'never', tsx: 'never', js: 'never', json: 'always' }],
+      'import/extensions': ['error', 'ignorePackages', { ts: 'never', tsx: 'never', js: 'always', json: 'always' }],
       'custom/no-generic-names': 'error',
       'no-warning-comments': 'off',
       'multiline-comment-style': 'off',