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

package/commands/component-design.md

@@ -87,6 +87,35 @@ Components should be put into the correct layer based on the type of logic they
 
 - `/infra/{gateway}`: This sub-layer handles receiving inputs from the outside world and returning responses to the outside world, like gateways sitting at the edge of the application. It's common to see http controllers and event handlers in this layer. Examples of `{gateway}` include `http`, `event-handlers`. Everything inside this layer must live in a sub-folder to avoid the root becoming a dumping ground and hiding design issues.
 
+#### Layer Import Rules
+
+Layering is enforced by imports. The use-case layer is the orchestration layer. Use cases can depend on infra. Infra capability code must stay application-agnostic and must not depend on use cases.
+
+Allowed dependencies:
+
+| Dependency | Reason |
+|---|---|
+| `domain/**` imports `domain/**` | Domain code can use other domain concepts. |
+| `use-case/**` imports `domain/**` | Use cases orchestrate domain behavior. |
+| `use-case/**` imports `infra/**` | Use cases orchestrate technical capabilities and domain behavior. This includes persistence, transactions, external services, logging, queues, caches, clients, and infra-owned types. |
+| `infra/gateway/**` imports `use-case/**` | Gateways receive outside-world input and call the use case that performs the application operation. |
+| composition root imports `use-case/**` and `infra/**` | The composition root wires runtime dependencies. It must not contain business logic. |
+
+Forbidden dependencies:
+
+| Dependency | Reason |
+|---|---|
+| `domain/**` imports `use-case/**` | Domain rules must not know which application operations exist. |
+| `domain/**` imports `infra/**` | Domain rules must not depend on databases, HTTP, queues, SDKs, logging, transactions, or other technical details. |
+| `infra/persistence/**` imports `use-case/**` | Persistence is a reusable technical capability. It must not know which use cases exist. |
+| `infra/external-service/**` imports `use-case/**` | External-service clients are reusable technical capabilities. They must not know which use cases exist. |
+| `infra/transactions/**` imports `use-case/**` | Transaction code is a reusable technical capability. It must not know which use cases exist. |
+| `infra/logging/**` imports `use-case/**` | Logging code is a reusable technical capability. It must not know which use cases exist. |
+| `infra/gateway/**` imports `infra/persistence/**` directly | Gateways must not bypass use cases to load or save application state. |
+| `infra/gateway/**` imports `infra/external-service/**` directly | Gateways must not bypass use cases to call external systems. |
+| `infra/gateway/**` imports `domain/**` to mutate domain objects directly | Gateways must not bypass use-case orchestration. |
+
+
 The following folder names are baned because they are generic terms that become a dumping ground or workaround for bad design. Find a more precise name or ask for help.
 
 - `utils`

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.13",
+  "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',