lintcn 0.5.0 → 0.6.0

package/src/commands/lint.ts

@@ -5,7 +5,7 @@ import fs from 'node:fs'
 import { spawn } from 'node:child_process'
 import { requireLintcnDir } from '../paths.ts'
 import { discoverRules } from '../discover.ts'
-import { generateBuildWorkspace } from '../codegen.ts'
+import { generateBuildWorkspace, generateEditorGoFiles } from '../codegen.ts'
 import { ensureTsgolintSource, validateVersion, cachedBinaryExists, getBinaryPath, getBuildDir, getBinDir } from '../cache.ts'
 import { computeContentHash } from '../hash.ts'
 import { execAsync } from '../exec.ts'
@@ -44,7 +44,7 @@ export async function buildBinary({
   const tsgolintDir = await ensureTsgolintSource(tsgolintVersion)
 
   // compute content hash
-  const contentHash = await computeContentHash({
+  const { short: contentHash } = await computeContentHash({
     lintcnDir,
     tsgolintVersion,
   })
@@ -55,6 +55,9 @@ export async function buildBinary({
     return getBinaryPath(contentHash)
   }
 
+  // ensure .lintcn/go.mod exists (gitignored, needed by the build workspace symlink)
+  generateEditorGoFiles(lintcnDir)
+
   // generate build workspace (per-hash dir to avoid races between concurrent processes)
   const buildDir = getBuildDir(contentHash)
   console.log('Generating build workspace...')
@@ -70,10 +73,23 @@ export async function buildBinary({
   fs.mkdirSync(binDir, { recursive: true })
   const binaryPath = getBinaryPath(contentHash)
 
-  console.log('Compiling custom tsgolint binary...')
-  await execAsync('go', ['build', '-o', binaryPath, './wrapper'], {
+  // Check if any lintcn binary has been built before — if not, this is a cold
+  // build that compiles the full tsgolint + typescript-go dependency tree.
+  const existingBins = fs.existsSync(binDir) ? fs.readdirSync(binDir) : []
+  if (existingBins.length === 0) {
+    console.log('Compiling custom tsgolint binary (first build — may take 30s+ to compile dependencies)...')
+    console.log('Subsequent builds will be fast (~1s). In CI, cache ~/.cache/lintcn/ and GOCACHE (run `go env GOCACHE`).')
+  } else {
+    console.log('Compiling custom tsgolint binary...')
+  }
+
+  const { exitCode: buildExitCode } = await execAsync('go', ['build', '-trimpath', '-o', binaryPath, './wrapper'], {
     cwd: buildDir,
+    stdio: 'inherit',
   })
+  if (buildExitCode !== 0) {
+    throw new Error(`Go compilation failed (exit code ${buildExitCode})`)
+  }
 
   console.log('Build complete')
   return binaryPath

package/src/commands/remove.ts

@@ -1,4 +1,4 @@
-// lintcn remove <name> — delete a rule and its test file from .lintcn/
+// lintcn remove <name> — delete a rule subfolder from .lintcn/
 
 import fs from 'node:fs'
 import path from 'node:path'
@@ -7,13 +7,11 @@ import { discoverRules } from '../discover.ts'
 
 export function removeRule(name: string): void {
   const lintcnDir = requireLintcnDir()
-
-  // match by lintcn:name metadata or by filename
   const rules = discoverRules(lintcnDir)
   const normalizedName = name.replace(/-/g, '_')
 
   const match = rules.find((r) => {
-    return r.name === name || r.fileName.replace(/\.go$/, '') === normalizedName
+    return r.name === name || r.packageName === normalizedName
   })
 
   if (!match) {
@@ -22,16 +20,8 @@ export function removeRule(name: string): void {
     )
   }
 
-  // delete rule file
-  const rulePath = path.join(lintcnDir, match.fileName)
-  fs.rmSync(rulePath)
-  console.log(`Removed ${match.fileName}`)
-
-  // delete test file if exists
-  const testFileName = match.fileName.replace(/\.go$/, '_test.go')
-  const testPath = path.join(lintcnDir, testFileName)
-  if (fs.existsSync(testPath)) {
-    fs.rmSync(testPath)
-    console.log(`Removed ${testFileName}`)
-  }
+  // Remove the entire subfolder
+  const ruleDir = path.join(lintcnDir, match.packageName)
+  fs.rmSync(ruleDir, { recursive: true })
+  console.log(`Removed ${match.packageName}/`)
 }

package/src/discover.ts

@@ -1,11 +1,12 @@
-// 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
   /** one-line description from // lintcn:description */
   description: string
@@ -13,8 +14,8 @@ export interface RuleMetadata {
   source: string
   /** 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
@@ -40,38 +41,46 @@ export function discoverRules(lintcnDir: string): RuleMetadata[] {
     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 })
+
+  // 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 rules: RuleMetadata[] = []
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith('.')) continue
 
-  for (const fileName of files) {
-    const filePath = path.join(lintcnDir, fileName)
-    const content = fs.readFileSync(filePath, 'utf-8')
+    const subDir = path.join(lintcnDir, entry.name)
+    const goFiles = fs.readdirSync(subDir).filter((f) => {
+      return f.endsWith('.go') && !f.endsWith('_test.go')
+    })
 
-    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
-    }
+    for (const fileName of goFiles) {
+      const filePath = path.join(subDir, fileName)
+      const content = fs.readFileSync(filePath, 'utf-8')
 
-    const meta = parseMetadata(content)
-    const baseName = fileName.replace(/\.go$/, '')
+      const varName = parseRuleVar(content)
+      if (!varName) continue
 
-    rules.push({
-      name: meta.name || baseName.replace(/_/g, '-'),
-      description: meta.description || '',
-      source: meta.source || '',
-      varName,
-      fileName,
-    })
+      const meta = parseMetadata(content)
+
+      rules.push({
+        name: meta.name || entry.name.replace(/_/g, '-'),
+        description: meta.description || '',
+        source: meta.source || '',
+        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 }
 }
+
+