lintcn 0.5.0 → 0.7.0

package/src/commands/add.ts

@@ -1,69 +1,155 @@
-// lintcn add <url> — fetch a .go rule file by URL and copy into .lintcn/
-// Also tries to fetch matching _test.go file from the same directory.
-// Normalizes GitHub blob URLs to raw URLs automatically.
+// lintcn add <url> — fetch a rule folder by URL and copy into .lintcn/{rule_name}/
+// Supports GitHub folder URLs (/tree/) and file URLs (/blob/).
+// For file URLs, auto-detects the parent folder and fetches all sibling files.
+// Uses GitHub API to list folder contents.
 
 import fs from 'node:fs'
 import path from 'node:path'
+import { execSync } from 'node:child_process'
 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 {
-  const blobSplit = url.match(/^(https?:\/\/github\.com\/[^/]+\/[^/]+)\/blob\/(.+)$/)
-  if (!blobSplit) {
-    return url
+interface ParsedGitHubUrl {
+  owner: string
+  repo: string
+  /** Branch/tag/commit. Undefined for bare repo URLs — resolve via API. */
+  ref: string | undefined
+  /** Path to the directory containing the rule files. Empty string for repo root. */
+  dirPath: string
+  /** Set when URL points to a specific file (not a folder) */
+  fileName?: string
+}
+
+/** Parse any GitHub URL into components.
+ *  Supports: bare repo, /tree/ folders, /blob/ files, raw.githubusercontent.com.
+ *  Ref is the first path component after blob/tree — branch names with slashes
+ *  (e.g. feature/foo) are not supported. */
+function parseGitHubUrl(url: string): ParsedGitHubUrl | null {
+  let hostname: string
+  let segments: string[]
+  try {
+    const u = new URL(url)
+    hostname = u.hostname
+    segments = u.pathname.replace(/\/$/, '').split('/').filter(Boolean)
+  } catch {
+    return null
+  }
+
+  // raw.githubusercontent.com/owner/repo/ref/path/to/file
+  if (hostname === 'raw.githubusercontent.com') {
+    if (segments.length < 4) return null
+    const [owner, repo, ref, ...rest] = segments
+    const filePath = rest.join('/')
+    return { owner, repo, ref, dirPath: path.posix.dirname(filePath), fileName: path.posix.basename(filePath) }
+  }
+
+  if (hostname !== 'github.com') return null
+  if (segments.length < 2) return null
+
+  const [owner, repo, kind, ref, ...rest] = segments
+
+  // Bare repo URL: github.com/owner/repo
+  if (!kind) {
+    return { owner, repo, ref: undefined, dirPath: '' }
   }
 
-  const [, repoUrl, refAndPath] = blobSplit
-  // repoUrl = "https://github.com/owner/repo"
-  // refAndPath = "feature/x/rules/my_rule.go" or "main/rules/my_rule.go"
+  const subPath = rest.join('/')
 
-  // Extract owner/repo from repoUrl
-  const repoMatch = repoUrl.match(/github\.com\/([^/]+)\/([^/]+)$/)
-  if (!repoMatch) {
-    return url
+  if (kind === 'tree') {
+    if (!ref || !subPath) return null
+    return { owner, repo, ref, dirPath: subPath }
   }
-  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}`
+  if (kind === 'blob') {
+    if (!ref || !subPath) return null
+    return { owner, repo, ref, dirPath: path.posix.dirname(subPath), fileName: path.posix.basename(subPath) }
+  }
+
+  return null
 }
 
-function deriveTestUrl(rawUrl: string): string {
-  return rawUrl.replace(/\.go$/, '_test.go')
+interface GitHubContentItem {
+  name: string
+  download_url: string | null
+  type: 'file' | 'dir'
 }
 
-async function fetchFile(url: string): Promise<string> {
-  const response = await fetch(url)
+/** Get a GitHub auth token from gh CLI, GITHUB_TOKEN env, or return undefined. */
+function getGitHubToken(): string | undefined {
+  if (process.env.GITHUB_TOKEN) {
+    return process.env.GITHUB_TOKEN
+  }
+  // Try gh CLI token (synchronous to keep it simple)
+  try {
+    return execSync('gh auth token', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim() || undefined
+  } catch {
+    return undefined
+  }
+}
+
+/** Resolve the default branch for a repo (e.g. "main", "master"). */
+async function resolveDefaultBranch(owner: string, repo: string): Promise<string> {
+  const apiUrl = `https://api.github.com/repos/${owner}/${repo}`
+  const headers: Record<string, string> = {
+    'Accept': 'application/vnd.github.v3+json',
+    'User-Agent': 'lintcn',
+  }
+  const token = getGitHubToken()
+  if (token) {
+    headers['Authorization'] = `Bearer ${token}`
+  }
+  const response = await fetch(apiUrl, { headers })
   if (!response.ok) {
-    throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`)
+    throw new Error(`GitHub API error: ${response.status} ${response.statusText}\n  ${apiUrl}`)
   }
-  return response.text()
+  const data = (await response.json()) as { default_branch: string }
+  return data.default_branch
 }
 
-async function tryFetchFile(url: string): Promise<string | null> {
-  try {
-    return await fetchFile(url)
-  } catch {
-    return null
+/** Files/dirs in .lintcn/ that are generated and should not be treated as rule folders. */
+const LINTCN_GENERATED = new Set([
+  '.tsgolint', '.gitignore', 'go.work', 'go.work.sum', 'go.mod', 'go.sum',
+])
+
+/** List files in a GitHub directory via the Contents API. */
+async function listGitHubFolder(owner: string, repo: string, dirPath: string, ref: string): Promise<GitHubContentItem[]> {
+  const apiUrl = `https://api.github.com/repos/${owner}/${repo}/contents/${dirPath}?ref=${ref}`
+  const headers: Record<string, string> = {
+    'Accept': 'application/vnd.github.v3+json',
+    'User-Agent': 'lintcn',
+  }
+  const token = getGitHubToken()
+  if (token) {
+    headers['Authorization'] = `Bearer ${token}`
   }
+  const response = await fetch(apiUrl, { headers })
+
+  if (!response.ok) {
+    throw new Error(`GitHub API error: ${response.status} ${response.statusText}\n  ${apiUrl}`)
+  }
+
+  const data = await response.json()
+  if (!Array.isArray(data)) {
+    throw new Error(`Expected a directory listing from GitHub API but got a single file.\n  ${apiUrl}`)
+  }
+
+  return data as GitHubContentItem[]
 }
 
-function rewritePackageName(content: string): string {
-  // 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')
+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()
 }
 
 function ensureSourceComment(content: string, sourceUrl: string): string {
   if (content.includes('// lintcn:source')) {
     return content
   }
-  // Insert source comment after the first lintcn: comment block, or at the very top
+  // Insert source comment after any existing lintcn: comment block, or at the very top
   const lines = content.split('\n')
   let insertIndex = 0
   for (let i = 0; i < lines.length; i++) {
@@ -77,63 +163,174 @@ function ensureSourceComment(content: string, sourceUrl: string): string {
   return lines.join('\n')
 }
 
-export async function addRule(url: string): Promise<void> {
-  const rawUrl = normalizeGithubUrl(url)
+/** Download a single rule folder into .lintcn/{folderName}/.
+ *  Overwrites existing folder if present.
+ *  Returns true if the rule was added, false if skipped (no .go files). */
+async function downloadSingleRule(
+  owner: string, repo: string, ref: string, dirPath: string,
+  lintcnDir: string, sourceUrl: string,
+): Promise<boolean> {
+  const folderName = path.posix.basename(dirPath)
+  const items = await listGitHubFolder(owner, repo, dirPath, ref)
 
-  console.log(`Fetching ${rawUrl}...`)
-  const content = await fetchFile(rawUrl)
+  const filesToFetch = items.filter((item) => {
+    return item.type === 'file' && item.download_url && (item.name.endsWith('.go') || item.name.endsWith('.json'))
+  })
 
-  // validate it looks like a Go file with a rule
-  if (!content.includes('rule.Rule')) {
-    console.warn('Warning: no rule.Rule reference found in this file. Are you sure this is a tsgolint rule?')
+  if (filesToFetch.length === 0) {
+    console.warn(`  Skipping ${folderName}/ — no .go files found`)
+    return false
   }
 
-  // derive filename from URL
-  const urlPath = new URL(rawUrl).pathname
-  const fileName = path.basename(urlPath)
-  if (!fileName.endsWith('.go')) {
-    throw new Error(`URL must point to a .go file, got: ${fileName}`)
+  const ruleDir = path.join(lintcnDir, folderName)
+
+  if (fs.existsSync(ruleDir)) {
+    fs.rmSync(ruleDir, { recursive: true })
+    console.log(`  Overwriting existing ${folderName}/`)
   }
 
-  const lintcnDir = getLintcnDir()
-  fs.mkdirSync(lintcnDir, { recursive: true })
+  fs.mkdirSync(ruleDir, { recursive: true })
 
-  // write the rule file
-  const filePath = path.join(lintcnDir, fileName)
-  if (fs.existsSync(filePath)) {
-    console.log(`Overwriting existing ${fileName}`)
-  }
+  for (const item of filesToFetch) {
+    let content = await fetchFile(item.download_url!)
 
-  let processed = rewritePackageName(content)
-  processed = ensureSourceComment(processed, url)
-  fs.writeFileSync(filePath, processed)
-  console.log(`Added ${fileName}`)
+    if (item.name === `${folderName}.go`) {
+      content = ensureSourceComment(content, sourceUrl)
+    }
 
-  // try to fetch matching test file
-  const testUrl = deriveTestUrl(rawUrl)
-  const testContent = await tryFetchFile(testUrl)
-  if (testContent) {
-    const testFileName = fileName.replace(/\.go$/, '_test.go')
-    const testProcessed = rewritePackageName(testContent)
-    fs.writeFileSync(path.join(lintcnDir, testFileName), testProcessed)
-    console.log(`Added ${testFileName}`)
+    fs.writeFileSync(path.join(ruleDir, item.name), content)
+    console.log(`    ${item.name}`)
   }
 
-  // ensure .tsgolint source is available and generate editor support files
+  console.log(`  Added ${folderName}/ (${filesToFetch.length} files)`)
+  return true
+}
+
+/** Ensure tsgolint source, refresh symlink, regenerate go.work/go.mod. */
+async function finalizeLintcnDir(lintcnDir: string): Promise<void> {
   const tsgolintDir = await ensureTsgolintSource(DEFAULT_TSGOLINT_VERSION)
 
-  // create .tsgolint symlink inside .lintcn for gopls.
-  // Use lstatSync to detect broken symlinks (existsSync returns false for broken links)
   const tsgolintLink = path.join(lintcnDir, '.tsgolint')
   try {
     fs.lstatSync(tsgolintLink)
-    // exists (possibly broken) — remove and recreate
     fs.rmSync(tsgolintLink, { force: true })
   } catch {
-    // doesn't exist at all
+    // doesn't exist
   }
   fs.symlinkSync(tsgolintDir, tsgolintLink)
 
   generateEditorGoFiles(lintcnDir)
   console.log('Editor support files generated (go.work, go.mod)')
 }
+
+/** Download all rule subfolders from a remote .lintcn/ directory.
+ *  Each subfolder is treated as a separate rule. Local rules not present
+ *  in the remote are preserved (merge, not replace). */
+async function addLintcnFolder(
+  owner: string, repo: string, ref: string, lintcnPath: string, sourceUrl: string,
+): Promise<void> {
+  console.log(`Fetching .lintcn/ from ${owner}/${repo}...`)
+  const items = await listGitHubFolder(owner, repo, lintcnPath, ref)
+
+  const ruleDirs = items.filter((item) => {
+    return item.type === 'dir' && !LINTCN_GENERATED.has(item.name) && !item.name.startsWith('.')
+  })
+
+  if (ruleDirs.length === 0) {
+    throw new Error(`No rule folders found in ${lintcnPath}. Is this a .lintcn/ directory?`)
+  }
+
+  console.log(`Found ${ruleDirs.length} rule(s)`)
+
+  const lintcnDir = getLintcnDir()
+
+  let added = 0
+  for (const dir of ruleDirs) {
+    const ruleDirPath = lintcnPath ? `${lintcnPath}/${dir.name}` : dir.name
+    const ok = await downloadSingleRule(owner, repo, ref, ruleDirPath, lintcnDir, sourceUrl)
+    if (ok) added++
+  }
+
+  if (added === 0) {
+    throw new Error(`No rule folders with .go files found in ${lintcnPath}.`)
+  }
+
+  await finalizeLintcnDir(lintcnDir)
+  console.log(`\nDone — added ${added} rule(s) from ${owner}/${repo}`)
+}
+
+export async function addRule(url: string): Promise<void> {
+  const parsed = parseGitHubUrl(url)
+  if (!parsed) {
+    throw new Error(
+      'Only GitHub URLs are supported.\n' +
+      'Examples:\n' +
+      '  lintcn add https://github.com/someone/their-project\n' +
+      '  lintcn add https://github.com/oxc-project/tsgolint/tree/main/internal/rules/no_floating_promises',
+    )
+  }
+
+  const { owner, repo, fileName } = parsed
+  let { ref, dirPath } = parsed
+
+  // Bare repo URL — resolve default branch and look for .lintcn/ at root
+  if (ref === undefined) {
+    ref = await resolveDefaultBranch(owner, repo)
+    console.log(`Resolved default branch: ${ref}`)
+
+    const rootItems = await listGitHubFolder(owner, repo, '', ref)
+    const lintcnEntry = rootItems.find((item) => item.type === 'dir' && item.name === '.lintcn')
+    if (!lintcnEntry) {
+      throw new Error(
+        `No .lintcn/ directory found in ${owner}/${repo}.\n` +
+        'The repo needs a .lintcn/ folder with rule subfolders.',
+      )
+    }
+
+    await addLintcnFolder(owner, repo, ref, '.lintcn', url)
+    return
+  }
+
+  // For blob/raw URLs, dirPath already points at the parent folder
+  // For tree URLs, dirPath is the folder itself — but it might be a .lintcn/ collection
+  if (!fileName) {
+    const items = await listGitHubFolder(owner, repo, dirPath, ref)
+    const hasGoFiles = items.some((i) => i.type === 'file' && i.name.endsWith('.go'))
+    const hasCandidateSubdirs = items.some((i) => {
+      return i.type === 'dir' && !LINTCN_GENERATED.has(i.name) && !i.name.startsWith('.')
+    })
+    const isLintcnDir = path.posix.basename(dirPath) === '.lintcn'
+
+    // Collection if: explicitly .lintcn/, or has subdirs but no .go files at root.
+    // A single rule folder with testdata/ subdirs won't be misdetected because
+    // it also has .go files at root.
+    if (isLintcnDir || (!hasGoFiles && hasCandidateSubdirs)) {
+      await addLintcnFolder(owner, repo, ref, dirPath, url)
+      return
+    }
+  }
+
+  // Single rule — download one folder
+  const folderName = path.posix.basename(dirPath)
+
+  console.log(`Fetching ${owner}/${repo}/${dirPath}...`)
+  const lintcnDir = getLintcnDir()
+
+  // Warn if this doesn't look like a single-rule folder (too many main .go files)
+  const items = await listGitHubFolder(owner, repo, dirPath, ref)
+  const mainGoFiles = items.filter((f) => {
+    return f.type === 'file' && f.name.endsWith('.go') && !f.name.endsWith('_test.go') && f.name !== 'options.go'
+  })
+  if (mainGoFiles.length > 3) {
+    console.warn(
+      `Warning: folder has ${mainGoFiles.length} non-test .go files. ` +
+      `This may be a directory of multiple rules — consider using a more specific URL.`,
+    )
+  }
+
+  const ok = await downloadSingleRule(owner, repo, ref, dirPath, lintcnDir, url)
+  if (!ok) {
+    throw new Error(`No .go files found in ${dirPath}. Is this a rule folder?`)
+  }
+  await finalizeLintcnDir(lintcnDir)
+}

package/src/commands/clean.ts

@@ -0,0 +1,48 @@
+// lintcn clean — remove cached tsgolint source and compiled binaries.
+// Frees disk space from old versions that accumulate over time.
+
+import fs from 'node:fs'
+import { getCacheDir } from '../cache.ts'
+
+export function clean(): void {
+  const cacheDir = getCacheDir()
+
+  if (!fs.existsSync(cacheDir)) {
+    console.log('No cache to clean')
+    return
+  }
+
+  const stats = getCacheStats(cacheDir)
+  fs.rmSync(cacheDir, { recursive: true })
+  console.log(`Removed ${cacheDir} (${formatBytes(stats.totalBytes)})`)
+}
+
+function getCacheStats(dir: string): { totalBytes: number } {
+  let totalBytes = 0
+  const walk = (d: string): void => {
+    for (const entry of fs.readdirSync(d, { withFileTypes: true })) {
+      const fullPath = `${d}/${entry.name}`
+      if (entry.isDirectory()) {
+        walk(fullPath)
+      } else {
+        totalBytes += fs.statSync(fullPath).size
+      }
+    }
+  }
+  try {
+    walk(dir)
+  } catch {
+    // ignore errors during stat
+  }
+  return { totalBytes }
+}
+
+function formatBytes(bytes: number): string {
+  if (bytes < 1024) {
+    return `${bytes}B`
+  }
+  if (bytes < 1024 * 1024) {
+    return `${(bytes / 1024).toFixed(0)}KB`
+  }
+  return `${(bytes / (1024 * 1024)).toFixed(0)}MB`
+}

package/src/commands/lint.ts

@@ -2,10 +2,11 @@
 // Handles Go workspace generation, compilation with caching, and execution.
 
 import fs from 'node:fs'
+import path from 'node:path'
 import { spawn } from 'node:child_process'
 import { requireLintcnDir } from '../paths.ts'
-import { discoverRules } from '../discover.ts'
-import { generateBuildWorkspace } from '../codegen.ts'
+import { discoverRules, type RuleMetadata } from '../discover.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 +45,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 +56,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 +74,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
@@ -83,16 +100,36 @@ export async function lint({
   rebuild,
   tsgolintVersion,
   passthroughArgs,
+  allWarnings,
 }: {
   rebuild: boolean
   tsgolintVersion: string
   passthroughArgs: string[]
+  allWarnings: boolean
 }): Promise<number> {
   const binaryPath = await buildBinary({ rebuild, tsgolintVersion })
 
-  // run the binary with passthrough args, inheriting stdio
+  // Discover rules to inject --warn flags for warning-severity rules.
+  // buildBinary already discovered rules for compilation, but we need the
+  // metadata here to know which rules are warnings at runtime.
+  const lintcnDir = requireLintcnDir()
+  const rules = discoverRules(lintcnDir)
+  const warnArgs = buildWarnArgs(rules)
+
+  // By default, limit warnings to git-changed files so they don't flood
+  // the output in large codebases. --all-warnings bypasses this filter.
+  const hasWarnRules = rules.some((r) => r.severity === 'warn')
+  let warnFileArgs: string[] = []
+  if (hasWarnRules && allWarnings) {
+    warnFileArgs = ['--all-warnings']
+  } else if (hasWarnRules) {
+    warnFileArgs = await buildWarnFileArgs()
+  }
+
+  // run the binary with --warn + --warn-file/--all-warnings flags + passthrough args
+  const allArgs = [...warnArgs, ...warnFileArgs, ...passthroughArgs]
   return new Promise((resolve) => {
-    const proc = spawn(binaryPath, passthroughArgs, {
+    const proc = spawn(binaryPath, allArgs, {
       stdio: 'inherit',
     })
 
@@ -106,3 +143,59 @@ export async function lint({
     })
   })
 }
+
+/** Build --warn flags for rules with severity 'warn'.
+ *  Uses goRuleName (parsed from Go source) to match the runtime name
+ *  that tsgolint uses in diagnostics, avoiding silent mismatches. */
+function buildWarnArgs(rules: RuleMetadata[]): string[] {
+  const args: string[] = []
+  for (const rule of rules) {
+    if (rule.severity === 'warn') {
+      args.push('--warn', rule.goRuleName)
+    }
+  }
+  return args
+}
+
+/** Get git-changed files and build --warn-file flags so warnings only
+ *  appear for new/modified code. Returns [] if git is unavailable or not
+ *  a git repo — the runner will then show no warnings (safe default).
+ *  Linting must never crash from this. */
+async function buildWarnFileArgs(): Promise<string[]> {
+  try {
+    // Get git repo root to resolve relative paths to absolute.
+    const topLevelResult = await execAsync('git', ['rev-parse', '--show-toplevel'], { stdio: 'pipe' }).catch(() => null)
+    if (!topLevelResult) return []
+    const repoRoot = topLevelResult.stdout.trim()
+
+    // Changed files (staged + unstaged vs HEAD)
+    const diffResult = await execAsync('git', ['diff', '--name-only', 'HEAD'], { stdio: 'pipe' }).catch(() => null)
+    // Untracked files (new files not yet committed)
+    const untrackedResult = await execAsync('git', ['ls-files', '--others', '--exclude-standard'], { stdio: 'pipe' }).catch(() => null)
+
+    const files = new Set<string>()
+
+    for (const result of [diffResult, untrackedResult]) {
+      if (!result) continue
+      for (const line of result.stdout.split('\n')) {
+        const trimmed = line.trim()
+        if (trimmed) {
+          // Resolve to absolute path so it matches SourceFile.FileName() in the runner.
+          files.add(path.resolve(repoRoot, trimmed))
+        }
+      }
+    }
+
+    // No changed files → no --warn-file flags → runner shows no warnings (clean tree)
+    if (files.size === 0) return []
+
+    const args: string[] = []
+    for (const file of files) {
+      args.push('--warn-file', file)
+    }
+    return args
+  } catch {
+    // git not installed, not a repo, or any other failure — no warnings shown
+    return []
+  }
+}

package/src/commands/list.ts

@@ -20,10 +20,13 @@ export function listRules(): void {
 
   console.log('Installed rules:\n')
 
-  const maxNameLen = Math.max(...rules.map((r) => { return r.name.length }))
+  const maxNameLen = Math.max(...rules.map((r) => {
+    return r.name.length + (r.severity === 'warn' ? 7 : 0) // ' (warn)' = 7 chars
+  }))
 
   for (const rule of rules) {
-    const name = rule.name.padEnd(maxNameLen + 2)
+    const suffix = rule.severity === 'warn' ? ' (warn)' : ''
+    const name = (rule.name + suffix).padEnd(maxNameLen + 2)
     const desc = rule.description || '(no description)'
     console.log(`  ${name}${desc}`)
   }

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}/`)
 }