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

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)]}`,
         })
       },
     }

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

@@ -0,0 +1,28 @@
+interface NoGenericNamesRuleReport {
+  message: string
+}
+
+interface NoGenericNamesRuleContext {
+  getFilename(): string | undefined
+  report(report: NoGenericNamesRuleReport): void
+}
+
+interface NoGenericNamesRuleListener {
+  Program(node: unknown): void
+  ClassDeclaration(node: { id: { name: string } | null }): void
+}
+
+interface NoGenericNamesRule {
+  meta: {
+    type: "problem"
+    docs: {
+      description: string
+      recommended: boolean
+    }
+  }
+  create(context: NoGenericNamesRuleContext): NoGenericNamesRuleListener
+}
+
+declare const noGenericNames: NoGenericNamesRule
+
+export default noGenericNames