lintcn 0.5.0 → 0.7.0

package/src/discover.ts

@@ -1,26 +1,40 @@
-// Scan .lintcn/*.go files for rule.Rule variables and lintcn: metadata comments.
+// Scan .lintcn/*/ subfolders for rule.Rule variables and lintcn: metadata comments.
+// Each subfolder is a Go package containing one rule with its companions.
 // Returns structured info about each discovered rule for codegen and list display.
 
 import fs from 'node:fs'
 import path from 'node:path'
 
 export interface RuleMetadata {
-  /** kebab-case rule name from // lintcn:name or derived from filename */
+  /** kebab-case rule name from // lintcn:name or derived from folder name */
   name: string
+  /** runtime rule name parsed from Go `rule.Rule{Name: "..."}`. This is
+   *  the name tsgolint uses in diagnostics and must match --warn flags.
+   *  Falls back to `name` if the Go Name field can't be parsed. */
+  goRuleName: string
   /** one-line description from // lintcn:description */
   description: string
   /** original source URL from // lintcn:source */
   source: string
+  /** severity from // lintcn:severity — 'error' (default) or 'warn'.
+   *  Warnings are displayed with yellow styling and don't cause exit code 1. */
+  severity: 'error' | 'warn'
   /** exported Go variable name like NoFloatingPromisesRule */
   varName: string
-  /** filename relative to .lintcn/ */
-  fileName: string
+  /** Go package name (= subfolder name, e.g. no_floating_promises) */
+  packageName: string
 }
 
 // Matches `var XxxRule = rule.Rule{` with optional leading whitespace
 // and optional import alias (e.g. `r.Rule{` if imported as `r "...rule"`)
 const RULE_VAR_RE = /^\s*var\s+(\w+)\s*=\s*\w*\.?Rule\s*\{/m
 const METADATA_RE = /^\/\/\s*lintcn:(\w+)\s+(.+)$/gm
+// buildGoRuleNameRe creates a regex scoped to a specific rule variable's
+// struct literal, e.g. `var FooRule = rule.Rule{ ... Name: "foo" ... }`.
+// This avoids matching a Name field in an unrelated struct earlier in the file.
+function buildGoRuleNameRe(varName: string): RegExp {
+  return new RegExp(`var\\s+${varName}\\s*=\\s*\\w*\\.?Rule\\s*\\{[\\s\\S]*?Name:\\s*"([^"]+)"`)
+}
 
 export function parseMetadata(content: string): Record<string, string> {
   const meta: Record<string, string> = {}
@@ -35,43 +49,64 @@ export function parseRuleVar(content: string): string | undefined {
   return match?.[1]
 }
 
+/** Extract the Name field from a specific rule.Rule variable's struct literal.
+ *  Scoped to varName to avoid matching Name fields in unrelated structs. */
+export function parseGoRuleName(content: string, varName: string): string | undefined {
+  const match = content.match(buildGoRuleNameRe(varName))
+  return match?.[1]
+}
+
 export function discoverRules(lintcnDir: string): RuleMetadata[] {
   if (!fs.existsSync(lintcnDir)) {
     return []
   }
 
-  const files = fs.readdirSync(lintcnDir).filter((f) => {
-    return f.endsWith('.go') && !f.endsWith('_test.go')
-  })
-
   const rules: RuleMetadata[] = []
+  const entries = fs.readdirSync(lintcnDir, { withFileTypes: true })
 
-  for (const fileName of files) {
-    const filePath = path.join(lintcnDir, fileName)
-    const content = fs.readFileSync(filePath, 'utf-8')
-
-    const varName = parseRuleVar(content)
-    if (!varName) {
-      // warn if file contains rule.Rule but we couldn't parse the var name
-      if (content.includes('rule.Rule')) {
-        console.warn(
-          `Warning: ${fileName} contains rule.Rule but no exported var was found. ` +
-          `Expected pattern: var XxxRule = rule.Rule{`,
-        )
-      }
-      continue
-    }
+  // Warn about flat .go files that should be in subfolders
+  const flatGoFiles = entries.filter((e) => {
+    return e.isFile() && e.name.endsWith('.go')
+  })
+  for (const file of flatGoFiles) {
+    const baseName = file.name.replace(/(_test)?\.go$/, '')
+    console.error(
+      `Error: ${file.name} is a flat file in .lintcn/ — rules must be in subfolders.\n` +
+      `  Move it to .lintcn/${baseName}/${file.name} and change the package to "${baseName}".\n`,
+    )
+  }
 
-    const meta = parseMetadata(content)
-    const baseName = fileName.replace(/\.go$/, '')
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith('.')) continue
 
-    rules.push({
-      name: meta.name || baseName.replace(/_/g, '-'),
-      description: meta.description || '',
-      source: meta.source || '',
-      varName,
-      fileName,
+    const subDir = path.join(lintcnDir, entry.name)
+    const goFiles = fs.readdirSync(subDir).filter((f) => {
+      return f.endsWith('.go') && !f.endsWith('_test.go')
     })
+
+    for (const fileName of goFiles) {
+      const filePath = path.join(subDir, fileName)
+      const content = fs.readFileSync(filePath, 'utf-8')
+
+      const varName = parseRuleVar(content)
+      if (!varName) continue
+
+      const meta = parseMetadata(content)
+
+      const severity = meta.severity === 'warn' ? 'warn' as const : 'error' as const
+      const displayName = meta.name || entry.name.replace(/_/g, '-')
+      const goRuleName = parseGoRuleName(content, varName) || displayName
+
+      rules.push({
+        name: displayName,
+        goRuleName,
+        description: meta.description,
+        source: meta.source,
+        severity,
+        varName,
+        packageName: entry.name,
+      })
+    }
   }
 
   return rules

package/src/hash.ts

@@ -1,50 +1,56 @@
-// Content hash for binary caching.
-// Combines cache schema version, tsgolint version, rule file contents,
-// Go version, and platform into a single SHA-256 hash.
+// Content hash for binary caching (local + remote).
+// Combines cache schema version, tsgolint version, platform triplet,
+// and non-test rule file contents into a SHA-256 hash.
+//
+// The hash is deterministic across machines — same rules + same tsgolint
+// version + same platform = same hash. Go version is NOT included because
+// the compiled binary is standalone (no Go runtime dependency).
+//
 // Bump CACHE_SCHEMA_VERSION when codegen logic changes to invalidate
 // stale binaries built by older lintcn versions.
 
 import crypto from 'node:crypto'
 import fs from 'node:fs'
 import path from 'node:path'
-import { execAsync } from './exec.ts'
 
-const CACHE_SCHEMA_VERSION = '2'
+const CACHE_SCHEMA_VERSION = '4'
 
+/** Compute a deterministic content hash for binary caching.
+ *  Returns: { short: "a1b2c3d4..." (16 hex), full: "a1b2c3d4..." (64 hex) }
+ *  The short hash is used for local cache paths, the full hash for remote cache keys. */
 export async function computeContentHash({
   lintcnDir,
   tsgolintVersion,
 }: {
   lintcnDir: string
   tsgolintVersion: string
-}): Promise<string> {
+}): Promise<{ short: string; full: string }> {
   const hash = crypto.createHash('sha256')
 
   hash.update(`cache-schema:${CACHE_SCHEMA_VERSION}\n`)
   hash.update(`tsgolint:${tsgolintVersion}\n`)
   hash.update(`platform:${process.platform}-${process.arch}\n`)
 
-  // add Go version
-  try {
-    const { stdout } = await execAsync('go', ['version'])
-    hash.update(`go:${stdout.trim()}\n`)
-  } catch {
-    hash.update('go:unknown\n')
+  // walk rule subfolders for non-test .go files in sorted order
+  const entries = fs.readdirSync(lintcnDir, { withFileTypes: true })
+    .filter((e) => { return e.isDirectory() && !e.name.startsWith('.') })
+    .sort((a, b) => { return a.name.localeCompare(b.name) })
+
+  for (const entry of entries) {
+    const subDir = path.join(lintcnDir, entry.name)
+    const goFiles = fs.readdirSync(subDir)
+      .filter((f) => { return f.endsWith('.go') && !f.endsWith('_test.go') })
+      .sort()
+
+    for (const file of goFiles) {
+      const content = fs.readFileSync(path.join(subDir, file), 'utf-8')
+      hash.update(`file:${entry.name}/${file}\n`)
+      hash.update(content)
+    }
   }
 
-  // add all rule file contents in sorted order
-  const files = fs
-    .readdirSync(lintcnDir)
-    .filter((f) => {
-      return f.endsWith('.go')
-    })
-    .sort()
-
-  for (const file of files) {
-    const content = fs.readFileSync(path.join(lintcnDir, file), 'utf-8')
-    hash.update(`file:${file}\n`)
-    hash.update(content)
-  }
-
-  return hash.digest('hex').slice(0, 16)
+  const full = hash.digest('hex')
+  return { short: full.slice(0, 16), full }
 }
+
+