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

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

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

package/dist/tools/lint.d.ts

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

package/dist/tools/lint.js

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

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

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

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

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

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

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

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

@@ -0,0 +1,31 @@
+import { tool, } from "@opencode-ai/plugin";
+import { runVitestCoverageReview, VITEST_COVERAGE_TOOL_NAME, } from "./infra/vitest-coverage/review.js";
+export const vitestCoverageTool = tool({
+    description: "Run Vitest coverage for changed TypeScript source files.",
+    args: {
+        mode: tool.schema.string().optional().describe("Use 'pr-review' for pull request coverage."),
+        pullRequest: tool.schema.string().optional().describe("Pull request number or URL for pr-review mode."),
+        base: tool.schema.string().optional().describe("Base git reference for pr-review mode when no pull request is provided."),
+        head: tool.schema.string().optional().describe("Head git reference for pr-review mode when base is provided."),
+        files: tool.schema.array(tool.schema.string()).optional().describe("Repository-relative files for files mode."),
+    },
+    async execute(request, context) {
+        context.metadata({ title: "Vitest coverage review" });
+        const outcome = await runVitestCoverageReview({
+            repositoryRoot: context.worktree,
+            mode: request.mode,
+            pullRequest: request.pullRequest,
+            base: request.base,
+            head: request.head,
+            files: request.files,
+        });
+        return {
+            output: outcome.markdown,
+            metadata: {
+                fileCount: outcome.results.length,
+                failedCount: outcome.results.filter((result) => result.status !== "passed").length,
+            },
+        };
+    },
+});
+export { VITEST_COVERAGE_TOOL_NAME };

package/dist/types.d.ts

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

package/package.json

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

package/scripts/check-tools-folder-boundary.mjs

@@ -0,0 +1,78 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import process from 'node:process'
+import { fileURLToPath } from 'node:url'
+
+const topLevelToolFilePattern = /^src\/tools\/[^/]+\.ts$/u
+const testFilePattern = /\.(?:spec|test)\.ts$/u
+const pluginImportPattern = /from\s+["']@opencode-ai\/plugin["']/u
+const exportedToolDefinitionPattern = /export\s+(?:const|function)\s+\w+[^\n]*:\s*ToolDefinition/u
+const toolCallPattern = /\btool\s*\(/u
+
+const boundaryFailureMessage = 'Top-level src/tools files must export a real OpenCode ToolDefinition. Move support code to src/tools/infra/<concept>/. Renaming a support file to *-tool.ts is not valid.'
+
+export function isTopLevelToolsTypeScriptFile(repositoryRoot, filePath) {
+  const relativeFilePath = path.relative(repositoryRoot, filePath).split(path.sep).join('/')
+  return topLevelToolFilePattern.test(relativeFilePath) && !testFilePattern.test(relativeFilePath)
+}
+
+function hasRealToolDefinition(sourceText) {
+  return pluginImportPattern.test(sourceText)
+    && sourceText.includes('ToolDefinition')
+    && sourceText.includes('tool')
+    && exportedToolDefinitionPattern.test(sourceText)
+    && toolCallPattern.test(sourceText)
+}
+
+function readTopLevelToolsTypeScriptFiles(repositoryRoot) {
+  const toolsDirectory = path.join(repositoryRoot, 'src', 'tools')
+
+  if (!fs.existsSync(toolsDirectory)) {
+    return []
+  }
+
+  return fs.readdirSync(toolsDirectory, { withFileTypes: true })
+    .filter((directoryEntry) => directoryEntry.isFile())
+    .map((directoryEntry) => path.join(toolsDirectory, directoryEntry.name))
+    .filter((filePath) => isTopLevelToolsTypeScriptFile(repositoryRoot, filePath))
+}
+
+export function readToolsFolderBoundaryViolations(repositoryRoot) {
+  return readTopLevelToolsTypeScriptFiles(repositoryRoot)
+    .filter((filePath) => !hasRealToolDefinition(fs.readFileSync(filePath, 'utf8')))
+    .map((filePath) => path.relative(repositoryRoot, filePath).split(path.sep).join('/'))
+}
+
+export function formatToolsFolderBoundaryViolations(violations) {
+  if (violations.length === 0) {
+    return ''
+  }
+
+  return [
+    boundaryFailureMessage,
+    ...violations.map((violation) => `- ${violation}`),
+  ].join('\n')
+}
+
+export function runToolsFolderBoundaryCheck(repositoryRoot = process.cwd(), stderr = process.stderr) {
+  const violations = readToolsFolderBoundaryViolations(repositoryRoot)
+  const output = formatToolsFolderBoundaryViolations(violations)
+
+  if (!output) {
+    return 0
+  }
+
+  stderr.write(`${output}\n`)
+  return 1
+}
+
+export async function runToolsFolderBoundaryScriptMain(currentScriptPath = process.argv[1]) {
+  if (currentScriptPath !== fileURLToPath(import.meta.url)) {
+    return false
+  }
+
+  process.exitCode = runToolsFolderBoundaryCheck()
+  return true
+}
+
+await runToolsFolderBoundaryScriptMain()

package/scripts/install-git-hooks.mjs

@@ -1,16 +1,54 @@
 import fs from 'node:fs'
 import path from 'node:path'
+import { fileURLToPath } from 'node:url'
 
-const gitDirectory = path.resolve('.git')
-const hooksDirectory = path.join(gitDirectory, 'hooks')
-const preCommitHookPath = path.join(hooksDirectory, 'pre-commit')
+function resolveGitDirectory(repositoryRoot) {
+  const gitPath = path.resolve(repositoryRoot, '.git')
 
-if (fs.existsSync(gitDirectory)) {
+  if (!fs.existsSync(gitPath)) {
+    return undefined
+  }
+
+  if (fs.statSync(gitPath).isDirectory()) {
+    return gitPath
+  }
+
+  const gitFileContent = fs.readFileSync(gitPath, 'utf8').trim()
+  const gitDirectoryPrefix = 'gitdir: '
+
+  if (!gitFileContent.startsWith(gitDirectoryPrefix)) {
+    throw new Error(`Expected .git file to start with "${gitDirectoryPrefix}". Got ${gitFileContent}.`)
+  }
+
+  return path.resolve(repositoryRoot, gitFileContent.slice(gitDirectoryPrefix.length))
+}
+
+export function installGitHooks(repositoryRoot = process.cwd()) {
+  const gitDirectory = resolveGitDirectory(repositoryRoot)
+
+  if (!gitDirectory) {
+    return false
+  }
+
+  const hooksDirectory = path.join(gitDirectory, 'hooks')
+  const preCommitHookPath = path.join(hooksDirectory, 'pre-commit')
   fs.mkdirSync(hooksDirectory, { recursive: true })
   fs.writeFileSync(preCommitHookPath, [
     '#!/usr/bin/env bash',
     'set -euo pipefail',
     'npm run lint',
+    'npm run coverage',
     '',
   ].join('\n'), { mode: 0o755 })
+  return true
+}
+
+export function runInstallGitHooksScript(currentScriptPath = process.argv[1], repositoryRoot = process.cwd()) {
+  if (currentScriptPath !== fileURLToPath(import.meta.url)) {
+    return false
+  }
+
+  return installGitHooks(repositoryRoot)
 }
+
+runInstallGitHooksScript()

package/scripts/lint-ts.mjs

@@ -1,10 +1,35 @@
 import process from 'node:process'
-import { runPortableLintFromCommandLine } from '../dist/tools/lint.js'
+import { fileURLToPath } from 'node:url'
 
-try {
-  process.exitCode = await runPortableLintFromCommandLine(process.argv.slice(2))
-} catch (error) {
-  const message = error instanceof Error ? error.message : `Expected an error message. Got ${String(error)}.`
-  process.stderr.write(`${message}\n`)
-  process.exitCode = 1
+async function runBundledPortableLint(commandLineArguments) {
+  const lintModule = await import('../dist/tools/lint.js')
+  return lintModule.runPortableLintFromCommandLine(commandLineArguments)
 }
+
+export function readErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message
+  }
+
+  return `Expected an error message. Got ${String(error)}.`
+}
+
+export async function runLintScript(commandLineArguments, stderr = process.stderr, runPortableLint = runBundledPortableLint) {
+  try {
+    return await runPortableLint(commandLineArguments)
+  } catch (error) {
+    stderr.write(`${readErrorMessage(error)}\n`)
+    return 1
+  }
+}
+
+export async function runLintScriptMain(currentScriptPath = process.argv[1], commandLineArguments = process.argv.slice(2), runPortableLint = runBundledPortableLint) {
+  if (currentScriptPath !== fileURLToPath(import.meta.url)) {
+    return false
+  }
+
+  process.exitCode = await runLintScript(commandLineArguments, process.stderr, runPortableLint)
+  return true
+}
+
+await runLintScriptMain()

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

@@ -154,13 +154,13 @@ export default tseslint.config(
       sourceType: 'module',
       parserOptions: {
         projectService: {
-          allowDefaultProject: ['src/tools/*.spec.ts', 'src/tools/*-test-support.ts', 'vitest.config.ts'],
+          allowDefaultProject: ['vitest.config.ts'],
+          maximumDefaultProjectFileMatchCount_THIS_WILL_SLOW_DOWN_LINTING: 50,
         },
         tsconfigRootDir: lintRepositoryRoot,
       },
     },
     rules: {
-      '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',

package/scripts/no-generic-names-eslint-rule.mjs

@@ -35,28 +35,6 @@ const isForbiddenName = (name) => {
   })
 }
 
-const createFilenameMessage = (filename) => {
-  const forbiddenWord = findForbiddenWord(filename)
-
-  if (!forbiddenWord) {
-    return 'Generic filename. Use domain-specific naming.'
-  }
-
-  const guidance = forbiddenWordSuggestions[forbiddenWord]
-  return `Generic word "${forbiddenWord}" in filename. ${guidance}`
-}
-
-const createClassMessage = (className) => {
-  const forbiddenWord = findForbiddenWord(className)
-
-  if (!forbiddenWord) {
-    return `Generic class name "${className}". Use domain-specific naming.`
-  }
-
-  const guidance = forbiddenWordSuggestions[forbiddenWord]
-  return `Generic word "${forbiddenWord}" in class "${className}". ${guidance}`
-}
-
 const noGenericNames = {
   meta: {
     type: 'problem',
@@ -80,7 +58,7 @@ const noGenericNames = {
 
         context.report({
           node: node.id,
-          message: createClassMessage(node.id.name),
+          message: `Generic word "${findForbiddenWord(node.id.name)}" in class "${node.id.name}". ${forbiddenWordSuggestions[findForbiddenWord(node.id.name)]}`,
         })
       },
       Program(node) {
@@ -90,7 +68,7 @@ const noGenericNames = {
 
         context.report({
           node,
-          message: createFilenameMessage(filename),
+          message: `Generic word "${findForbiddenWord(filename)}" in filename. ${forbiddenWordSuggestions[findForbiddenWord(filename)]}`,
         })
       },
     }