lintcn 0.5.0 → 0.7.0

package/dist/commands/add.js

@@ -1,60 +1,126 @@
-// 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.js";
 import { generateEditorGoFiles } from "../codegen.js";
 import { ensureTsgolintSource, DEFAULT_TSGOLINT_VERSION } from "../cache.js";
-/** 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) {
-    const blobSplit = url.match(/^(https?:\/\/github\.com\/[^/]+\/[^/]+)\/blob\/(.+)$/);
-    if (!blobSplit) {
-        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}`;
+/** 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) {
+    let hostname;
+    let segments;
+    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 subPath = rest.join('/');
+    if (kind === 'tree') {
+        if (!ref || !subPath)
+            return null;
+        return { owner, repo, ref, dirPath: subPath };
+    }
+    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) {
-    return rawUrl.replace(/\.go$/, '_test.go');
+/** Get a GitHub auth token from gh CLI, GITHUB_TOKEN env, or return undefined. */
+function getGitHubToken() {
+    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;
+    }
 }
-async function fetchFile(url) {
-    const response = await fetch(url);
+/** Resolve the default branch for a repo (e.g. "main", "master"). */
+async function resolveDefaultBranch(owner, repo) {
+    const apiUrl = `https://api.github.com/repos/${owner}/${repo}`;
+    const headers = {
+        '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());
+    return data.default_branch;
 }
-async function tryFetchFile(url) {
-    try {
-        return await fetchFile(url);
+/** 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, repo, dirPath, ref) {
+    const apiUrl = `https://api.github.com/repos/${owner}/${repo}/contents/${dirPath}?ref=${ref}`;
+    const headers = {
+        'Accept': 'application/vnd.github.v3+json',
+        'User-Agent': 'lintcn',
+    };
+    const token = getGitHubToken();
+    if (token) {
+        headers['Authorization'] = `Bearer ${token}`;
     }
-    catch {
-        return null;
+    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;
 }
-function rewritePackageName(content) {
-    // 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) {
+    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, sourceUrl) {
     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++) {
@@ -68,54 +134,134 @@ function ensureSourceComment(content, sourceUrl) {
     lines.splice(insertIndex, 0, `// lintcn:source ${sourceUrl}`);
     return lines.join('\n');
 }
-export async function addRule(url) {
-    const rawUrl = normalizeGithubUrl(url);
-    console.log(`Fetching ${rawUrl}...`);
-    const content = await fetchFile(rawUrl);
-    // 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?');
-    }
-    // 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}`);
+/** 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, repo, ref, dirPath, lintcnDir, sourceUrl) {
+    const folderName = path.posix.basename(dirPath);
+    const items = await listGitHubFolder(owner, repo, dirPath, ref);
+    const filesToFetch = items.filter((item) => {
+        return item.type === 'file' && item.download_url && (item.name.endsWith('.go') || item.name.endsWith('.json'));
+    });
+    if (filesToFetch.length === 0) {
+        console.warn(`  Skipping ${folderName}/ — no .go files found`);
+        return false;
     }
-    const lintcnDir = getLintcnDir();
-    fs.mkdirSync(lintcnDir, { recursive: true });
-    // write the rule file
-    const filePath = path.join(lintcnDir, fileName);
-    if (fs.existsSync(filePath)) {
-        console.log(`Overwriting existing ${fileName}`);
-    }
-    let processed = rewritePackageName(content);
-    processed = ensureSourceComment(processed, url);
-    fs.writeFileSync(filePath, processed);
-    console.log(`Added ${fileName}`);
-    // 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}`);
-    }
-    // ensure .tsgolint source is available and generate editor support files
+    const ruleDir = path.join(lintcnDir, folderName);
+    if (fs.existsSync(ruleDir)) {
+        fs.rmSync(ruleDir, { recursive: true });
+        console.log(`  Overwriting existing ${folderName}/`);
+    }
+    fs.mkdirSync(ruleDir, { recursive: true });
+    for (const item of filesToFetch) {
+        let content = await fetchFile(item.download_url);
+        if (item.name === `${folderName}.go`) {
+            content = ensureSourceComment(content, sourceUrl);
+        }
+        fs.writeFileSync(path.join(ruleDir, item.name), content);
+        console.log(`    ${item.name}`);
+    }
+    console.log(`  Added ${folderName}/ (${filesToFetch.length} files)`);
+    return true;
+}
+/** Ensure tsgolint source, refresh symlink, regenerate go.work/go.mod. */
+async function finalizeLintcnDir(lintcnDir) {
     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, repo, ref, lintcnPath, sourceUrl) {
+    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) {
+    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/dist/commands/clean.d.ts

@@ -0,0 +1,2 @@
+export declare function clean(): void;
+//# sourceMappingURL=clean.d.ts.map

package/dist/commands/clean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clean.d.ts","sourceRoot":"","sources":["../../src/commands/clean.ts"],"names":[],"mappings":"AAMA,wBAAgB,KAAK,IAAI,IAAI,CAW5B"}

package/dist/commands/clean.js

@@ -0,0 +1,44 @@
+// 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.js";
+export function clean() {
+    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) {
+    let totalBytes = 0;
+    const walk = (d) => {
+        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) {
+    if (bytes < 1024) {
+        return `${bytes}B`;
+    }
+    if (bytes < 1024 * 1024) {
+        return `${(bytes / 1024).toFixed(0)}KB`;
+    }
+    return `${(bytes / (1024 * 1024)).toFixed(0)}MB`;
+}

package/dist/commands/lint.d.ts

@@ -2,9 +2,10 @@ export declare function buildBinary({ rebuild, tsgolintVersion, }: {
     rebuild: boolean;
     tsgolintVersion: string;
 }): Promise<string>;
-export declare function lint({ rebuild, tsgolintVersion, passthroughArgs, }: {
+export declare function lint({ rebuild, tsgolintVersion, passthroughArgs, allWarnings, }: {
     rebuild: boolean;
     tsgolintVersion: string;
     passthroughArgs: string[];
+    allWarnings: boolean;
 }): Promise<number>;
 //# sourceMappingURL=lint.d.ts.map

package/dist/commands/lint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lint.d.ts","sourceRoot":"","sources":["../../src/commands/lint.ts"],"names":[],"mappings":"AAuBA,wBAAsB,WAAW,CAAC,EAChC,OAAO,EACP,eAAe,GAChB,EAAE;IACD,OAAO,EAAE,OAAO,CAAA;IAChB,eAAe,EAAE,MAAM,CAAA;CACxB,GAAG,OAAO,CAAC,MAAM,CAAC,CAkDlB;AAED,wBAAsB,IAAI,CAAC,EACzB,OAAO,EACP,eAAe,EACf,eAAe,GAChB,EAAE;IACD,OAAO,EAAE,OAAO,CAAA;IAChB,eAAe,EAAE,MAAM,CAAA;IACvB,eAAe,EAAE,MAAM,EAAE,CAAA;CAC1B,GAAG,OAAO,CAAC,MAAM,CAAC,CAkBlB"}
+{"version":3,"file":"lint.d.ts","sourceRoot":"","sources":["../../src/commands/lint.ts"],"names":[],"mappings":"AAwBA,wBAAsB,WAAW,CAAC,EAChC,OAAO,EACP,eAAe,GAChB,EAAE;IACD,OAAO,EAAE,OAAO,CAAA;IAChB,eAAe,EAAE,MAAM,CAAA;CACxB,GAAG,OAAO,CAAC,MAAM,CAAC,CAkElB;AAED,wBAAsB,IAAI,CAAC,EACzB,OAAO,EACP,eAAe,EACf,eAAe,EACf,WAAW,GACZ,EAAE;IACD,OAAO,EAAE,OAAO,CAAA;IAChB,eAAe,EAAE,MAAM,CAAA;IACvB,eAAe,EAAE,MAAM,EAAE,CAAA;IACzB,WAAW,EAAE,OAAO,CAAA;CACrB,GAAG,OAAO,CAAC,MAAM,CAAC,CAoClB"}

package/dist/commands/lint.js

@@ -1,10 +1,11 @@
 // lintcn lint — build a custom tsgolint binary and run it against the project.
 // 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.js";
 import { discoverRules } from "../discover.js";
-import { generateBuildWorkspace } from "../codegen.js";
+import { generateBuildWorkspace, generateEditorGoFiles } from "../codegen.js";
 import { ensureTsgolintSource, validateVersion, cachedBinaryExists, getBinaryPath, getBuildDir, getBinDir } from "../cache.js";
 import { computeContentHash } from "../hash.js";
 import { execAsync } from "../exec.js";
@@ -29,7 +30,7 @@ export async function buildBinary({ rebuild, tsgolintVersion, }) {
     // ensure tsgolint source
     const tsgolintDir = await ensureTsgolintSource(tsgolintVersion);
     // compute content hash
-    const contentHash = await computeContentHash({
+    const { short: contentHash } = await computeContentHash({
         lintcnDir,
         tsgolintVersion,
     });
@@ -38,6 +39,8 @@ export async function buildBinary({ rebuild, tsgolintVersion, }) {
         console.log('Using cached binary');
         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...');
@@ -51,18 +54,48 @@ export async function buildBinary({ rebuild, tsgolintVersion, }) {
     const binDir = getBinDir();
     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;
 }
-export async function lint({ rebuild, tsgolintVersion, passthroughArgs, }) {
+export async function lint({ rebuild, tsgolintVersion, passthroughArgs, allWarnings, }) {
     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 = [];
+    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',
         });
         proc.on('error', (err) => {
@@ -74,3 +107,56 @@ export async function lint({ rebuild, tsgolintVersion, passthroughArgs, }) {
         });
     });
 }
+/** 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) {
+    const args = [];
+    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() {
+    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();
+        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 = [];
+        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/dist/commands/list.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../src/commands/list.ts"],"names":[],"mappings":"AAKA,wBAAgB,SAAS,IAAI,IAAI,CA0BhC"}
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../src/commands/list.ts"],"names":[],"mappings":"AAKA,wBAAgB,SAAS,IAAI,IAAI,CA6BhC"}

package/dist/commands/list.js

@@ -13,9 +13,12 @@ export function listRules() {
         return;
     }
     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/dist/commands/remove.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"remove.d.ts","sourceRoot":"","sources":["../../src/commands/remove.ts"],"names":[],"mappings":"AAOA,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CA6B7C"}
+{"version":3,"file":"remove.d.ts","sourceRoot":"","sources":["../../src/commands/remove.ts"],"names":[],"mappings":"AAOA,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAmB7C"}

package/dist/commands/remove.js

@@ -1,28 +1,20 @@
-// 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';
 import { requireLintcnDir } from "../paths.js";
 import { discoverRules } from "../discover.js";
 export function removeRule(name) {
     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) {
         throw new Error(`Rule "${name}" not found. Run \`lintcn list\` to see installed rules.`);
     }
-    // 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/dist/discover.d.ts

@@ -1,16 +1,26 @@
 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;
 }
 export declare function parseMetadata(content: string): Record<string, string>;
 export declare function parseRuleVar(content: string): string | undefined;
+/** 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 declare function parseGoRuleName(content: string, varName: string): string | undefined;
 export declare function discoverRules(lintcnDir: string): RuleMetadata[];
 //# sourceMappingURL=discover.d.ts.map