lintcn 0.5.0 → 0.7.0

package/dist/discover.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discover.d.ts","sourceRoot":"","sources":["../src/discover.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,YAAY;IAC3B,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAA;IACZ,sDAAsD;IACtD,WAAW,EAAE,MAAM,CAAA;IACnB,gDAAgD;IAChD,MAAM,EAAE,MAAM,CAAA;IACd,4DAA4D;IAC5D,OAAO,EAAE,MAAM,CAAA;IACf,oCAAoC;IACpC,QAAQ,EAAE,MAAM,CAAA;CACjB;AAOD,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAMrE;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAGhE;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY,EAAE,CAwC/D"}
+{"version":3,"file":"discover.d.ts","sourceRoot":"","sources":["../src/discover.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,YAAY;IAC3B,2EAA2E;IAC3E,IAAI,EAAE,MAAM,CAAA;IACZ;;qEAEiE;IACjE,UAAU,EAAE,MAAM,CAAA;IAClB,sDAAsD;IACtD,WAAW,EAAE,MAAM,CAAA;IACnB,gDAAgD;IAChD,MAAM,EAAE,MAAM,CAAA;IACd;kFAC8E;IAC9E,QAAQ,EAAE,OAAO,GAAG,MAAM,CAAA;IAC1B,4DAA4D;IAC5D,OAAO,EAAE,MAAM,CAAA;IACf,oEAAoE;IACpE,WAAW,EAAE,MAAM,CAAA;CACpB;AAaD,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAMrE;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAGhE;AAED;4EAC4E;AAC5E,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAGpF;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY,EAAE,CAsD/D"}

package/dist/discover.js

@@ -1,4 +1,5 @@
-// 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';
@@ -6,6 +7,12 @@ import path from 'node:path';
 // 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) {
+    return new RegExp(`var\\s+${varName}\\s*=\\s*\\w*\\.?Rule\\s*\\{[\\s\\S]*?Name:\\s*"([^"]+)"`);
+}
 export function parseMetadata(content) {
     const meta = {};
     for (const match of content.matchAll(METADATA_RE)) {
@@ -17,35 +24,54 @@ export function parseRuleVar(content) {
     const match = content.match(RULE_VAR_RE);
     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, varName) {
+    const match = content.match(buildGoRuleNameRe(varName));
+    return match?.[1];
+}
 export function discoverRules(lintcnDir) {
     if (!fs.existsSync(lintcnDir)) {
         return [];
     }
-    const files = fs.readdirSync(lintcnDir).filter((f) => {
-        return f.endsWith('.go') && !f.endsWith('_test.go');
-    });
     const rules = [];
-    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{`);
-            }
+    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`);
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name.startsWith('.'))
             continue;
-        }
-        const meta = parseMetadata(content);
-        const baseName = fileName.replace(/\.go$/, '');
-        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' : 'error';
+            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/dist/hash.d.ts

@@ -1,5 +1,11 @@
+/** 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 declare function computeContentHash({ lintcnDir, tsgolintVersion, }: {
     lintcnDir: string;
     tsgolintVersion: string;
-}): Promise<string>;
+}): Promise<{
+    short: string;
+    full: string;
+}>;
 //# sourceMappingURL=hash.d.ts.map

package/dist/hash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../src/hash.ts"],"names":[],"mappings":"AAaA,wBAAsB,kBAAkB,CAAC,EACvC,SAAS,EACT,eAAe,GAChB,EAAE;IACD,SAAS,EAAE,MAAM,CAAA;IACjB,eAAe,EAAE,MAAM,CAAA;CACxB,GAAG,OAAO,CAAC,MAAM,CAAC,CA8BlB"}
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../src/hash.ts"],"names":[],"mappings":"AAiBA;;yFAEyF;AACzF,wBAAsB,kBAAkB,CAAC,EACvC,SAAS,EACT,eAAe,GAChB,EAAE;IACD,SAAS,EAAE,MAAM,CAAA;IACjB,eAAe,EAAE,MAAM,CAAA;CACxB,GAAG,OAAO,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CA2B3C"}

package/dist/hash.js

@@ -1,37 +1,40 @@
-// 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.js";
-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, }) {
     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`);
+    // 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);
+        }
     }
-    catch {
-        hash.update('go:unknown\n');
-    }
-    // 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 };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lintcn",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "type": "module",
   "description": "The shadcn for type-aware TypeScript lint rules. Browse, pick, and copy rules into your project.",
   "bin": "dist/cli.js",
@@ -60,6 +60,7 @@
     "tar": "^7.5.12"
   },
   "scripts": {
-    "build": "rm -rf dist *.tsbuildinfo && tsc && chmod +x dist/cli.js"
+    "build": "rm -rf dist *.tsbuildinfo && tsc && chmod +x dist/cli.js",
+    "cli": "tsx src/cli"
   }
 }

package/src/cache.ts

@@ -18,7 +18,7 @@ import { execAsync } from './exec.ts'
 // Pinned tsgolint fork commit — updated with each lintcn release.
 // Uses remorses/tsgolint fork which adds internal/runner.Run().
 // Only 1 commit on top of upstream — zero modifications to existing files.
-export const DEFAULT_TSGOLINT_VERSION = 'e945641eabec22993eda3e7c101692e80417e0ea'
+export const DEFAULT_TSGOLINT_VERSION = '23190a08a6315eba8ef11818fc1c38d7b01c9e10'
 
 // Pinned typescript-go base commit from microsoft/typescript-go (before patches).
 // Patches from tsgolint/patches/ are applied on top during setup.

package/src/cli.ts

@@ -9,6 +9,7 @@ import { addRule } from './commands/add.ts'
 import { lint, buildBinary } from './commands/lint.ts'
 import { listRules } from './commands/list.ts'
 import { removeRule } from './commands/remove.ts'
+import { clean } from './commands/clean.ts'
 import { DEFAULT_TSGOLINT_VERSION } from './cache.ts'
 
 const require = createRequire(import.meta.url)
@@ -17,11 +18,13 @@ const packageJson = require('../package.json') as { version: string }
 const cli = goke('lintcn')
 
 cli
-  .command('add <url>', 'Add a rule by URL. Fetches the .go file and copies it into .lintcn/')
-  .example('# Add a rule from GitHub')
-  .example('lintcn add https://github.com/user/repo/blob/main/rules/no_floating_promises.go')
-  .example('# Add from raw URL')
-  .example('lintcn add https://raw.githubusercontent.com/user/repo/main/rules/no_unused_result.go')
+  .command('add <url>', 'Add rules by GitHub URL. Supports single rule folders, .lintcn/ directories, or full repo URLs.')
+  .example('# Add a single rule folder')
+  .example('lintcn add https://github.com/oxc-project/tsgolint/tree/main/internal/rules/no_floating_promises')
+  .example('# Add by file URL (auto-fetches the whole folder)')
+  .example('lintcn add https://github.com/oxc-project/tsgolint/blob/main/internal/rules/await_thenable/await_thenable.go')
+  .example('# Add all rules from a repo (downloads .lintcn/ folder)')
+  .example('lintcn add https://github.com/someone/their-project')
   .action(async (url) => {
     await addRule(url)
   })
@@ -42,12 +45,17 @@ cli
 cli
   .command('lint', 'Build custom tsgolint binary and run it against the project')
   .option('--rebuild', 'Force rebuild even if cached binary exists')
+  .option('--fix', 'Automatically fix violations')
   .option('--tsconfig <path>', 'Path to tsconfig.json')
   .option('--list-files', 'List matched files')
+  .option('--all-warnings', 'Show warnings for all files, not just git-changed ones')
   .option('--tsgolint-version [version]', 'Override the pinned tsgolint version (tag or commit). For testing unreleased tsgolint versions.')
   .action(async (options) => {
     const tsgolintVersion = (options.tsgolintVersion as string) || DEFAULT_TSGOLINT_VERSION
     const passthroughArgs: string[] = []
+    if (options.fix) {
+      passthroughArgs.push('--fix')
+    }
     if (options.tsconfig) {
       passthroughArgs.push('--tsconfig', options.tsconfig as string)
     }
@@ -63,6 +71,7 @@ cli
       rebuild: !!options.rebuild,
       tsgolintVersion,
       passthroughArgs,
+      allWarnings: !!options.allWarnings,
     })
     process.exit(exitCode)
   })
@@ -77,6 +86,12 @@ cli
     console.log(binaryPath)
   })
 
+cli
+  .command('clean', 'Remove cached tsgolint source and compiled binaries to free disk space')
+  .action(() => {
+    clean()
+  })
+
 cli.help()
 cli.version(packageJson.version)
 cli.parse()

package/src/codegen.ts

@@ -129,10 +129,29 @@ go 1.26
   fs.writeFileSync(path.join(buildDir, 'wrapper', 'main.go'), mainGo)
 }
 
-/** Generate main.go that imports user rules and calls internal/runner.Run(). */
+/** Sanitize a package name into a valid Go identifier for use as an import alias.
+ *  Replaces hyphens/dots with underscores, prepends _ if starts with a digit. */
+function toGoAlias(pkg: string): string {
+  let alias = pkg.replace(/[^a-zA-Z0-9_]/g, '_')
+  if (/^[0-9]/.test(alias)) {
+    alias = '_' + alias
+  }
+  return alias
+}
+
+/** Generate main.go that imports user rules and calls internal/runner.Run().
+ *  Each rule subfolder is its own Go package, imported by package name. */
 function generateMainGo(rules: RuleMetadata[]): string {
+  // Deduplicate imports by package name (in case a subfolder has multiple rules)
+  const uniquePackages = [...new Set(rules.map((r) => { return r.packageName }))]
+  const imports = uniquePackages.map((pkg) => {
+    const alias = toGoAlias(pkg)
+    return `\t${alias} "${TSGOLINT_MODULE}/lintcn-rules/${pkg}"`
+  }).join('\n')
+
   const ruleEntries = rules.map((r) => {
-    return `\t\tlintcn.${r.varName},`
+    const alias = toGoAlias(r.packageName)
+    return `\t\t${alias}.${r.varName},`
   }).join('\n')
 
   return `// Code generated by lintcn. DO NOT EDIT.
@@ -143,7 +162,7 @@ import (
 
 \t"${TSGOLINT_MODULE}/internal/rule"
 \t"${TSGOLINT_MODULE}/internal/runner"
-\tlintcn "${TSGOLINT_MODULE}/lintcn-rules"
+${imports}
 )
 
 func main() {