lintcn 0.2.0 → 0.3.0

package/src/commands/add.ts

@@ -8,36 +8,54 @@ import { getLintcnDir } from '../paths.ts'
 import { generateEditorGoFiles } from '../codegen.ts'
 import { ensureTsgolintSource, DEFAULT_TSGOLINT_VERSION } from '../cache.ts'
 
+/** Convert GitHub blob URLs to raw.githubusercontent.com.
+ *  Handles branch names containing slashes (e.g. feature/x) by splitting
+ *  on /blob/ then finding the file path from the end (must end in .go). */
 function normalizeGithubUrl(url: string): string {
-  // Convert github.com/user/repo/blob/branch/path to raw.githubusercontent.com
-  const blobMatch = url.match(
-    /^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/blob\/([^/]+)\/(.+)$/,
-  )
-  if (blobMatch) {
-    const [, owner, repo, branch, filePath] = blobMatch
-    return `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/${filePath}`
+  const blobSplit = url.match(/^(https?:\/\/github\.com\/[^/]+\/[^/]+)\/blob\/(.+)$/)
+  if (!blobSplit) {
+    return url
   }
-  return url
+
+  const [, repoUrl, refAndPath] = blobSplit
+  // repoUrl = "https://github.com/owner/repo"
+  // refAndPath = "feature/x/rules/my_rule.go" or "main/rules/my_rule.go"
+
+  // Extract owner/repo from repoUrl
+  const repoMatch = repoUrl.match(/github\.com\/([^/]+)\/([^/]+)$/)
+  if (!repoMatch) {
+    return url
+  }
+  const [, owner, repo] = repoMatch
+
+  // For raw.githubusercontent.com, the format is owner/repo/ref/path.
+  // We can pass refAndPath directly since GitHub resolves it.
+  return `https://raw.githubusercontent.com/${owner}/${repo}/${refAndPath}`
 }
 
 function deriveTestUrl(rawUrl: string): string {
   return rawUrl.replace(/\.go$/, '_test.go')
 }
 
-async function fetchFile(url: string): Promise<string | null> {
+async function fetchFile(url: string): Promise<string> {
+  const response = await fetch(url)
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`)
+  }
+  return response.text()
+}
+
+async function tryFetchFile(url: string): Promise<string | null> {
   try {
-    const response = await fetch(url)
-    if (!response.ok) {
-      return null
-    }
-    return await response.text()
+    return await fetchFile(url)
   } catch {
     return null
   }
 }
 
 function rewritePackageName(content: string): string {
-  // Rewrite first package declaration to package lintcn
+  // Rewrite first package declaration to package lintcn.
+  // Only matches before the first import or func to avoid touching comments.
   return content.replace(/^package\s+\w+/m, 'package lintcn')
 }
 
@@ -64,9 +82,6 @@ export async function addRule(url: string): Promise<void> {
 
   console.log(`Fetching ${rawUrl}...`)
   const content = await fetchFile(rawUrl)
-  if (!content) {
-    throw new Error(`Could not fetch rule from ${rawUrl}`)
-  }
 
   // validate it looks like a Go file with a rule
   if (!content.includes('rule.Rule')) {
@@ -96,7 +111,7 @@ export async function addRule(url: string): Promise<void> {
 
   // try to fetch matching test file
   const testUrl = deriveTestUrl(rawUrl)
-  const testContent = await fetchFile(testUrl)
+  const testContent = await tryFetchFile(testUrl)
   if (testContent) {
     const testFileName = fileName.replace(/\.go$/, '_test.go')
     const testProcessed = rewritePackageName(testContent)

package/src/commands/lint.ts

@@ -3,7 +3,7 @@
 
 import fs from 'node:fs'
 import { spawn } from 'node:child_process'
-import { getLintcnDir } from '../paths.ts'
+import { requireLintcnDir } from '../paths.ts'
 import { discoverRules } from '../discover.ts'
 import { generateBuildWorkspace } from '../codegen.ts'
 import { ensureTsgolintSource, DEFAULT_TSGOLINT_VERSION, cachedBinaryExists, getBinaryPath, getBuildDir, getBinDir } from '../cache.ts'
@@ -30,10 +30,7 @@ export async function buildBinary({
 }): Promise<string> {
   await checkGoInstalled()
 
-  const lintcnDir = getLintcnDir()
-  if (!fs.existsSync(lintcnDir)) {
-    throw new Error('No .lintcn/ directory found. Run `lintcn add <url>` first.')
-  }
+  const lintcnDir = requireLintcnDir()
 
   const rules = discoverRules(lintcnDir)
   if (rules.length === 0) {

package/src/commands/list.ts

@@ -1,13 +1,12 @@
 // lintcn list — list installed rules with metadata from .lintcn/
 
-import fs from 'node:fs'
-import { getLintcnDir } from '../paths.ts'
+import { findLintcnDir } from '../paths.ts'
 import { discoverRules } from '../discover.ts'
 
 export function listRules(): void {
-  const lintcnDir = getLintcnDir()
+  const lintcnDir = findLintcnDir()
 
-  if (!fs.existsSync(lintcnDir)) {
+  if (!lintcnDir) {
     console.log('No .lintcn/ directory found. Run `lintcn add <url>` to add rules.')
     return
   }

package/src/commands/remove.ts

@@ -2,15 +2,11 @@
 
 import fs from 'node:fs'
 import path from 'node:path'
-import { getLintcnDir } from '../paths.ts'
+import { requireLintcnDir } from '../paths.ts'
 import { discoverRules } from '../discover.ts'
 
 export function removeRule(name: string): void {
-  const lintcnDir = getLintcnDir()
-
-  if (!fs.existsSync(lintcnDir)) {
-    throw new Error('No .lintcn/ directory found.')
-  }
+  const lintcnDir = requireLintcnDir()
 
   // match by lintcn:name metadata or by filename
   const rules = discoverRules(lintcnDir)

package/src/discover.ts

@@ -17,7 +17,9 @@ export interface RuleMetadata {
   fileName: string
 }
 
-const RULE_VAR_RE = /^var\s+(\w+)\s*=\s*rule\.Rule\s*\{/m
+// 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
 
 export function parseMetadata(content: string): Record<string, string> {
@@ -50,6 +52,13 @@ export function discoverRules(lintcnDir: string): RuleMetadata[] {
 
     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
     }
 

package/src/hash.ts

@@ -1,12 +1,16 @@
 // Content hash for binary caching.
-// Combines tsgolint version, rule file contents, Go version, and platform
-// into a single SHA-256 hash used as the cached binary filename.
+// Combines cache schema version, tsgolint version, rule file contents,
+// Go version, and platform into a single SHA-256 hash.
+// 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'
+
 export async function computeContentHash({
   lintcnDir,
   tsgolintVersion,
@@ -16,6 +20,7 @@ export async function computeContentHash({
 }): Promise<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`)
 

package/src/index.ts

@@ -5,3 +5,4 @@ export { lint, buildBinary } from './commands/lint.ts'
 export { listRules } from './commands/list.ts'
 export { removeRule } from './commands/remove.ts'
 export { DEFAULT_TSGOLINT_VERSION } from './cache.ts'
+export { findLintcnDir, getLintcnDir, requireLintcnDir } from './paths.ts'

package/src/paths.ts

@@ -1,7 +1,31 @@
-// Resolve the .lintcn/ directory path relative to cwd.
+// Resolve the .lintcn/ directory by walking up from cwd.
+// This lets users run `lintcn lint` from any subdirectory of their project.
 
+import { findUpSync } from 'find-up'
 import path from 'node:path'
 
+/** Find the nearest .lintcn/ directory by walking up from cwd.
+ *  Returns the absolute path to the directory, or null if not found. */
+export function findLintcnDir(): string | null {
+  const found = findUpSync('.lintcn', { type: 'directory' })
+  return found ?? null
+}
+
+/** Find .lintcn/ or throw with a helpful error. */
 export function getLintcnDir(): string {
+  const dir = findLintcnDir()
+  if (dir) {
+    return dir
+  }
+  // fall back to cwd/.lintcn for `lintcn add` (creates the directory)
   return path.resolve(process.cwd(), '.lintcn')
 }
+
+/** Find .lintcn/ or throw — for commands that require it to exist. */
+export function requireLintcnDir(): string {
+  const dir = findLintcnDir()
+  if (!dir) {
+    throw new Error('No .lintcn/ directory found in current or parent directories. Run `lintcn add <url>` first.')
+  }
+  return dir
+}