@nt-ai-lab/opencode-skillz 0.3.5 → 0.3.7

package/commands/implement.md

@@ -10,8 +10,9 @@ Implement the required task to the highest standards possible. Do not take short
 
 ## Linting
 
-After each small TypeScript code change, call `nt_skillz_lint` for the changed `.ts` or `.tsx` file or files.
+After each small TypeScript code change, call `nt_skillz_lint` with only the `files` argument for the changed `.ts` or `.tsx` file or files from that step.
 
+- do not pass `base` or `head` during normal implementation work
 - all lint errors on new code must be addressed before continuing
 - if the lint fails on existing code, ignore the error unless it is very close to the new code
 - line-length limits do not count as existing code; if new code causes a file-length lint error, it must be fixed

package/dist/tools/lint.d.ts

@@ -1,5 +1,16 @@
-import { type ToolContext } from "@opencode-ai/plugin";
+interface PortableLintRequest {
+    repositoryRoot?: string;
+    files?: string[];
+    base?: string;
+    head?: string;
+}
+interface PortableLintOutcome {
+    exitCode: number;
+    output: string;
+}
 export declare const LINT_TOOL_NAME = "nt_skillz_lint";
+export declare function runPortableLint(request: PortableLintRequest): Promise<PortableLintOutcome>;
+export declare function runPortableLintFromCommandLine(commandLineArguments: string[]): Promise<number>;
 export declare const lintTool: {
     description: string;
     args: {
@@ -11,5 +22,6 @@ export declare const lintTool: {
         files?: string[] | undefined;
         base?: string | undefined;
         head?: string | undefined;
-    }, context: ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+    }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
 };
+export {};

package/dist/tools/lint.js

@@ -1,89 +1,218 @@
-import { spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { tool, } from "@opencode-ai/plugin";
-class InvalidLintRequestError extends Error {
+import { parseArgs } from "node:util";
+import { ESLint } from "eslint";
+import { tool } from "@opencode-ai/plugin";
+class UsageError extends Error {
     constructor(message) {
         super(message);
     }
 }
-class LintRunFailedError extends Error {
+class GitCommandError extends Error {
     constructor(message) {
         super(message);
     }
 }
-const lintScriptPath = fileURLToPath(new URL("../../scripts/lint-ts.mjs", import.meta.url));
+class MissingBundledLintAssetError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+class LintExecutionError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+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";
 export const LINT_TOOL_NAME = "nt_skillz_lint";
-function validateLintRequest(request) {
-    if (request.base && request.files?.length) {
-        throw new InvalidLintRequestError("Expected either file paths or base reference. Got both.");
+function normalizeOptionalText(value) {
+    if (typeof value !== "string") {
+        return undefined;
     }
-    if (!request.base && request.head) {
-        throw new InvalidLintRequestError("Expected head reference to be used together with base reference.");
+    const trimmedValue = value.trim();
+    if (!trimmedValue) {
+        return undefined;
     }
+    return trimmedValue;
 }
-function createLintCommandArguments(request) {
-    const commandArguments = [lintScriptPath];
-    if (request.base) {
-        commandArguments.push("--base", request.base);
-        if (request.head) {
-            commandArguments.push("--head", request.head);
-        }
+function resolveDirectory(directoryPath) {
+    const absoluteDirectoryPath = path.resolve(directoryPath);
+    if (!fs.existsSync(absoluteDirectoryPath)) {
+        throw new UsageError(`Expected repository path to exist. Got ${absoluteDirectoryPath}.`);
+    }
+    if (!fs.statSync(absoluteDirectoryPath).isDirectory()) {
+        throw new UsageError(`Expected repository path to be a directory. Got ${absoluteDirectoryPath}.`);
+    }
+    return absoluteDirectoryPath;
+}
+function ensureSupportedFilePath(filePath) {
+    if (filePath.endsWith(".ts") || filePath.endsWith(".tsx")) {
+        return;
     }
-    for (const filePath of request.files ?? []) {
-        commandArguments.push(filePath);
+    throw new UsageError(`Expected a TypeScript file path ending in .ts or .tsx. Got ${filePath}.`);
+}
+function normalizeFilePaths(filePaths) {
+    const normalizedFilePaths = (filePaths ?? []).map((filePath) => filePath.trim()).filter(Boolean);
+    normalizedFilePaths.forEach(ensureSupportedFilePath);
+    return normalizedFilePaths;
+}
+function ensureBundledLintAssetsExist() {
+    if (fs.existsSync(eslintConfigPath)) {
+        return;
     }
-    return commandArguments;
+    throw new MissingBundledLintAssetError(`Expected bundled lint config to exist at ${eslintConfigPath}.`);
 }
-function createLintTitle(request) {
-    if (request.files?.length) {
-        return `Lint ${request.files.length} TypeScript file(s)`;
+function runGitCommand(repositoryRoot, gitArguments) {
+    const gitResult = spawnSync(gitBinaryPath, ["-C", repositoryRoot, ...gitArguments], { encoding: "utf8" });
+    if (gitResult.error) {
+        throw new GitCommandError(`Expected git command to run. Got ${gitResult.error.message}.`);
     }
-    if (request.base) {
-        return `Lint TypeScript changes from ${request.base}`;
+    if (gitResult.status === 0) {
+        return gitResult.stdout;
     }
-    return "Lint current TypeScript files";
+    const errorOutput = gitResult.stderr.trim() || gitResult.stdout.trim() || "git command failed";
+    throw new GitCommandError(`Expected git command to succeed. Got ${errorOutput}.`);
+}
+function readChangedTypeScriptFiles(repositoryRoot, baseReference, headReference) {
+    const diffRange = `${baseReference}...${headReference}`;
+    const output = runGitCommand(repositoryRoot, [
+        "diff",
+        "--name-only",
+        "--diff-filter=ACMR",
+        diffRange,
+        "--",
+        "*.ts",
+        "*.tsx",
+    ]);
+    return output.split("\n").filter(Boolean);
 }
-function createLintOutput(standardOutputParts, standardErrorParts) {
-    const sections = [standardOutputParts.join("").trim(), standardErrorParts.join("").trim()].filter(Boolean);
-    return sections.join("\n");
+function readTrackedAndUntrackedTypeScriptFiles(repositoryRoot) {
+    const output = runGitCommand(repositoryRoot, [
+        "ls-files",
+        "--cached",
+        "--others",
+        "--exclude-standard",
+        "--",
+        "*.ts",
+        "*.tsx",
+    ]);
+    return output.split("\n").filter(Boolean);
 }
-function normalizeExitCode(value) {
-    if (typeof value === "number") {
-        return value;
+function ensureValidLintRequest(baseReference, headReference, filePaths) {
+    if (baseReference && filePaths.length > 0) {
+        throw new UsageError("Expected either file paths or base reference. Got both.");
+    }
+    if (!baseReference && headReference) {
+        throw new UsageError("Expected head reference to be used together with base reference.");
     }
-    return 1;
 }
-function runLintCommand(request, context) {
-    return new Promise((resolve, reject) => {
-        const lintCommand = spawn(process.execPath, createLintCommandArguments(request), {
-            cwd: context.worktree,
-            signal: context.abort,
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        const standardOutputParts = [];
-        const standardErrorParts = [];
-        lintCommand.stdout.on("data", (chunk) => {
-            standardOutputParts.push(chunk.toString());
-        });
-        lintCommand.stderr.on("data", (chunk) => {
-            standardErrorParts.push(chunk.toString());
-        });
-        lintCommand.on("error", (error) => {
-            reject(error);
-        });
-        lintCommand.on("close", (exitCode) => {
-            resolve({
-                exitCode: normalizeExitCode(exitCode),
-                output: createLintOutput(standardOutputParts, standardErrorParts),
-            });
-        });
+function resolveLintTargets(repositoryRoot, baseReference, headReference, filePaths) {
+    if (filePaths.length > 0) {
+        return filePaths;
+    }
+    if (baseReference) {
+        return readChangedTypeScriptFiles(repositoryRoot, baseReference, headReference ?? "HEAD");
+    }
+    return readTrackedAndUntrackedTypeScriptFiles(repositoryRoot);
+}
+function createLintTitle(filePaths, baseReference) {
+    if (filePaths.length > 0) {
+        return `Lint ${filePaths.length} TypeScript file(s)`;
+    }
+    if (baseReference) {
+        return `Lint TypeScript changes from ${baseReference}`;
+    }
+    return "Lint current TypeScript files";
+}
+async function runEslint(repositoryRoot, lintTargets) {
+    const previousLintRepositoryRoot = process.env.NT_SKILLZ_LINT_REPO_ROOT;
+    process.env.NT_SKILLZ_LINT_REPO_ROOT = repositoryRoot;
+    const eslint = new ESLint({
+        cwd: repositoryRoot,
+        errorOnUnmatchedPattern: false,
+        overrideConfigFile: eslintConfigPath,
+        warnIgnored: false,
+    });
+    try {
+        const lintResults = await eslint.lintFiles(lintTargets);
+        const formatter = await eslint.loadFormatter("stylish");
+        const formattedOutput = (await formatter.format(lintResults)).trim();
+        const errorCount = lintResults.reduce((count, lintResult) => count + lintResult.errorCount + lintResult.fatalErrorCount, 0);
+        return {
+            exitCode: errorCount > 0 ? 1 : 0,
+            output: formattedOutput,
+        };
+    }
+    finally {
+        if (previousLintRepositoryRoot) {
+            process.env.NT_SKILLZ_LINT_REPO_ROOT = previousLintRepositoryRoot;
+        }
+        else {
+            delete process.env.NT_SKILLZ_LINT_REPO_ROOT;
+        }
+    }
+}
+function parsePortableLintCommandLine(commandLineArguments) {
+    const parsedArguments = parseArgs({
+        args: commandLineArguments,
+        options: {
+            repo: { type: "string" },
+            base: { type: "string" },
+            head: { type: "string" },
+            help: {
+                type: "boolean",
+                short: "h",
+            },
+        },
+        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),
+        base: normalizeOptionalText(parsedArguments.values.base),
+        head: normalizeOptionalText(parsedArguments.values.head),
+    };
 }
-function createLintFailureMessage(outcome) {
+export async function runPortableLint(request) {
+    ensureBundledLintAssetsExist();
+    const repositoryRoot = resolveDirectory(request.repositoryRoot ?? process.cwd());
+    const baseReference = normalizeOptionalText(request.base);
+    const headReference = normalizeOptionalText(request.head);
+    const filePaths = normalizeFilePaths(request.files);
+    ensureValidLintRequest(baseReference, headReference, filePaths);
+    const lintTargets = resolveLintTargets(repositoryRoot, baseReference, headReference, filePaths);
+    if (lintTargets.length === 0) {
+        return {
+            exitCode: 0,
+            output: "No TypeScript files matched.",
+        };
+    }
+    return runEslint(repositoryRoot, lintTargets);
+}
+export async function runPortableLintFromCommandLine(commandLineArguments) {
+    const request = parsePortableLintCommandLine(commandLineArguments);
+    const outcome = await runPortableLint(request);
     if (outcome.output) {
-        return outcome.output;
+        process.stdout.write(`${outcome.output}\n`);
     }
-    return `Lint failed with exit code ${outcome.exitCode}.`;
+    return outcome.exitCode;
 }
 export const lintTool = tool({
     description: "Run bundled TypeScript lint rules against current project files.",
@@ -93,18 +222,26 @@ export const lintTool = tool({
         head: tool.schema.string().optional().describe("Optional head git reference used with base."),
     },
     async execute(request, context) {
-        validateLintRequest(request);
-        context.metadata({ title: createLintTitle(request) });
-        const outcome = await runLintCommand(request, context);
+        const filePaths = normalizeFilePaths(request.files);
+        const baseReference = normalizeOptionalText(request.base);
+        const headReference = normalizeOptionalText(request.head);
+        ensureValidLintRequest(baseReference, headReference, filePaths);
+        context.metadata({ title: createLintTitle(filePaths, baseReference) });
+        const outcome = await runPortableLint({
+            repositoryRoot: context.worktree,
+            files: filePaths,
+            base: baseReference,
+            head: headReference,
+        });
         if (outcome.exitCode !== 0) {
-            throw new LintRunFailedError(createLintFailureMessage(outcome));
+            throw new LintExecutionError(outcome.output || "Lint failed.");
         }
         return {
             output: outcome.output || "Lint passed.",
             metadata: {
-                base: request.base ?? null,
-                fileCount: request.files?.length ?? 0,
-                head: request.head ?? null,
+                base: baseReference ?? null,
+                fileCount: filePaths.length,
+                head: headReference ?? null,
             },
         };
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nt-ai-lab/opencode-skillz",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "description": "Bundled OpenCode commands and agents",
   "type": "module",
   "main": "dist/index.js",
@@ -24,14 +24,11 @@
     "README.md"
   ],
   "dependencies": {
-    "@opencode-ai/plugin": "^1.14.28"
-  },
-  "devDependencies": {
     "@eslint-community/eslint-plugin-eslint-comments": "^4.5.0",
     "@eslint/js": "^9.39.0",
+    "@opencode-ai/plugin": "^1.14.28",
     "@stylistic/eslint-plugin": "^5.6.1",
     "@vitest/eslint-plugin": "^1.0.1",
-    "@types/node": "^24.7.2",
     "eslint": "^9.39.0",
     "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-sonarjs": "^3.0.5",
@@ -39,6 +36,9 @@
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.50.1"
   },
+  "devDependencies": {
+    "@types/node": "^24.7.2"
+  },
   "publishConfig": {
     "access": "public"
   }

package/scripts/lint-ts.mjs

@@ -1,218 +1,8 @@
-import fs from 'node:fs'
-import path from 'node:path'
 import process from 'node:process'
-import { spawnSync } from 'node:child_process'
-import { fileURLToPath } from 'node:url'
-import { parseArgs } from 'node:util'
-
-class UsageError extends Error {
-  constructor(message) {
-    super(message)
-  }
-}
-
-class GitCommandError extends Error {
-  constructor(message) {
-    super(message)
-  }
-}
-
-class MissingLocalDependencyError extends Error {
-  constructor(message) {
-    super(message)
-  }
-}
-
-class LintExecutionError extends Error {
-  constructor(message) {
-    super(message)
-  }
-}
-
-const scriptDirectory = path.dirname(fileURLToPath(import.meta.url))
-const toolRepositoryRoot = path.resolve(scriptDirectory, '..')
-const eslintCliPath = path.join(toolRepositoryRoot, 'node_modules', 'eslint', 'bin', 'eslint.js')
-const eslintConfigPath = path.join(toolRepositoryRoot, 'scripts', 'living-architecture-eslint.config.mjs')
-
-const printUsage = () => {
-  const usage = [
-    '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')
-
-  process.stdout.write(`${usage}\n`)
-}
-
-const parseCommandLine = () => {
-  return parseArgs({
-    options: {
-      repo: { type: 'string' },
-      base: { type: 'string' },
-      head: { type: 'string' },
-      help: { type: 'boolean', short: 'h' },
-    },
-    allowPositionals: true,
-  })
-}
-
-const resolveDirectory = (directoryPath) => {
-  const absoluteDirectoryPath = path.resolve(directoryPath)
-
-  if (!fs.existsSync(absoluteDirectoryPath)) {
-    throw new UsageError(`Expected repository path to exist. Got ${absoluteDirectoryPath}.`)
-  }
-
-  if (!fs.statSync(absoluteDirectoryPath).isDirectory()) {
-    throw new UsageError(`Expected repository path to be a directory. Got ${absoluteDirectoryPath}.`)
-  }
-
-  return absoluteDirectoryPath
-}
-
-const ensureSupportedFilePath = (filePath) => {
-  if (filePath.endsWith('.ts') || filePath.endsWith('.tsx')) {
-    return
-  }
-
-  throw new UsageError(`Expected a TypeScript file path ending in .ts or .tsx. Got ${filePath}.`)
-}
-
-const runGit = (repositoryRoot, args) => {
-  const gitResult = spawnSync('git', ['-C', repositoryRoot, ...args], {
-    encoding: 'utf8',
-  })
-
-  if (gitResult.error) {
-    throw new GitCommandError(`Expected git command to run. Got ${gitResult.error.message}.`)
-  }
-
-  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 readChangedTypeScriptFiles = (repositoryRoot, baseReference, headReference) => {
-  const diffRange = `${baseReference}...${headReference}`
-  const output = runGit(repositoryRoot, [
-    'diff',
-    '--name-only',
-    '--diff-filter=ACMR',
-    diffRange,
-    '--',
-    '*.ts',
-    '*.tsx',
-  ])
-
-  return output.split('\n').filter(Boolean)
-}
-
-const readTrackedAndUntrackedTypeScriptFiles = (repositoryRoot) => {
-  const output = runGit(repositoryRoot, [
-    'ls-files',
-    '--cached',
-    '--others',
-    '--exclude-standard',
-    '--',
-    '*.ts',
-    '*.tsx',
-  ])
-
-  return output.split('\n').filter(Boolean)
-}
-
-const resolveLintTargets = (repositoryRoot, baseReference, headReference, positionalArguments) => {
-  if (positionalArguments.length > 0) {
-    positionalArguments.forEach(ensureSupportedFilePath)
-    return positionalArguments
-  }
-
-  if (baseReference) {
-    return readChangedTypeScriptFiles(repositoryRoot, baseReference, headReference)
-  }
-
-  return readTrackedAndUntrackedTypeScriptFiles(repositoryRoot)
-}
-
-const ensureValidArguments = (baseReference, headReference, positionalArguments) => {
-  if (baseReference && positionalArguments.length > 0) {
-    throw new UsageError('Expected either explicit file paths or --base. Got both.')
-  }
-
-  if (!baseReference && headReference !== 'HEAD') {
-    throw new UsageError('Expected --head to be used together with --base.')
-  }
-}
-
-const ensureLocalDependencies = () => {
-  if (fs.existsSync(eslintCliPath)) {
-    return
-  }
-
-  throw new MissingLocalDependencyError(
-    `Expected ESLint dependencies to be installed in ${toolRepositoryRoot}. Run npm install in this repository.`,
-  )
-}
-
-const runEslint = (repositoryRoot, lintTargets) => {
-  const eslintResult = spawnSync(
-    process.execPath,
-    [eslintCliPath, '--no-config-lookup', '--no-warn-ignored', '--config', eslintConfigPath, ...lintTargets],
-    {
-      cwd: repositoryRoot,
-      env: {
-        ...process.env,
-        NT_SKILLZ_LINT_REPO_ROOT: repositoryRoot,
-      },
-      stdio: 'inherit',
-    },
-  )
-
-  if (eslintResult.error) {
-    throw new LintExecutionError(`Expected ESLint to run. Got ${eslintResult.error.message}.`)
-  }
-
-  if (typeof eslintResult.status === 'number') {
-    return eslintResult.status
-  }
-
-  throw new LintExecutionError(`Expected ESLint to exit with a status code. Got signal ${eslintResult.signal}.`)
-}
-
-const main = () => {
-  const parsedArguments = parseCommandLine()
-
-  if (parsedArguments.values.help) {
-    printUsage()
-    return 0
-  }
-
-  const repositoryRoot = resolveDirectory(parsedArguments.values.repo ?? process.cwd())
-  const baseReference = parsedArguments.values.base
-  const headReference = parsedArguments.values.head ?? 'HEAD'
-  const positionalArguments = parsedArguments.positionals
-
-  ensureValidArguments(baseReference, headReference, positionalArguments)
-  ensureLocalDependencies()
-
-  const lintTargets = resolveLintTargets(repositoryRoot, baseReference, headReference, positionalArguments)
-
-  if (lintTargets.length === 0) {
-    process.stdout.write('No TypeScript files matched.\n')
-    return 0
-  }
-
-  return runEslint(repositoryRoot, lintTargets)
-}
+import { runPortableLintFromCommandLine } from '../dist/tools/lint.js'
 
 try {
-  process.exitCode = main()
+  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`)