lintcn 0.5.0 → 0.6.0

package/CHANGELOG.md

@@ -1,3 +1,55 @@
+## 0.6.0
+
+1. **Rules now live in subfolders** — each rule is its own Go package under `.lintcn/{rule_name}/`, replacing the old flat `.lintcn/*.go` layout. This eliminates the need to rename `options.go` and `schema.json` companions — they stay in the subfolder with their original names, and the Go package name matches the folder. `lintcn add` now fetches the entire rule folder automatically.
+
+   ```
+   .lintcn/
+       no_floating_promises/
+           no_floating_promises.go
+           no_floating_promises_test.go
+           options.go      ← original name, no renaming
+           schema.json
+       my_custom_rule/
+           my_custom_rule.go
+   ```
+
+2. **`lintcn add` fetches whole folders** — both folder URLs (`/tree/`) and file URLs (`/blob/`) now fetch every `.go` and `.json` file in the rule's directory. Passing a file URL auto-detects the parent folder:
+
+   ```bash
+   # folder URL
+   lintcn add https://github.com/oxc-project/tsgolint/tree/main/internal/rules/no_floating_promises
+
+   # file URL — auto-fetches the whole folder
+   lintcn add https://github.com/oxc-project/tsgolint/blob/main/internal/rules/await_thenable/await_thenable.go
+   ```
+
+3. **Error for flat `.go` files in `.lintcn/`** — if leftover flat files from older versions are detected, lintcn now prints a clear migration error with instructions instead of silently ignoring them.
+
+4. **Reproducible builds with `-trimpath`** — the Go binary is now built with `-trimpath`, stripping absolute paths from the output. Binaries are identical across machines for the same rule content + tsgolint version + platform.
+
+5. **Faster cache hits** — Go version removed from the content hash. The compiled binary is a standalone executable with no Go runtime dependency, so the Go version used to build it doesn't affect correctness. Also excludes `_test.go` files from the hash since tests don't affect the binary.
+
+6. **Go compilation output is live** — `go build` now inherits stdio, so compilation progress and errors stream directly to the terminal instead of being silently captured.
+
+7. **First-build guidance** — on first compile (cold Go cache), lintcn explains the one-time 30s cost and shows which directories to cache in CI:
+   ```
+   Compiling custom tsgolint binary (first build — may take 30s+ to compile dependencies)...
+   Subsequent builds will be fast (~1s). In CI, cache ~/.cache/lintcn/ and GOCACHE (run `go env GOCACHE`).
+   ```
+
+8. **GitHub Actions example** — README now includes a copy-paste workflow that caches the compiled binary. Subsequent CI runs take ~12s (vs ~4min cold):
+
+   ```yaml
+   - name: Cache lintcn binary + Go build cache
+     uses: actions/cache@v4
+     with:
+       path: |
+         ~/.cache/lintcn
+         ~/go/pkg
+       key: lintcn-${{ runner.os }}-${{ runner.arch }}-${{ hashFiles('.lintcn/**/*.go') }}
+       restore-keys: lintcn-${{ runner.os }}-${{ runner.arch }}-
+   ```
+
 ## 0.5.0
 
 1. **Security fix — path traversal in `--tsgolint-version`** — the version flag is now validated against a strict pattern. Previously a value like `../../etc` could escape the cache directory.

package/README.md

@@ -13,8 +13,11 @@ npm install -D lintcn
 ## Usage
 
 ```bash
-# Add a rule by URL
-npx lintcn add https://github.com/user/repo/blob/main/rules/no_unhandled_error.go
+# Add a rule folder from tsgolint
+npx lintcn add https://github.com/oxc-project/tsgolint/tree/main/internal/rules/no_floating_promises
+
+# Add by file URL (auto-fetches the whole folder)
+npx lintcn add https://github.com/oxc-project/tsgolint/blob/main/internal/rules/await_thenable/await_thenable.go
 
 # Lint your project
 npx lintcn lint
@@ -26,21 +29,33 @@ npx lintcn lint --tsconfig tsconfig.build.json
 npx lintcn list
 
 # Remove a rule
-npx lintcn remove no-unhandled-error
+npx lintcn remove no-floating-promises
+
+# Clean cached tsgolint source + binaries
+npx lintcn clean
 ```
 
+Browse all 50+ available built-in rules in the [tsgolint rules directory](https://github.com/oxc-project/tsgolint/tree/main/internal/rules).
+
 ## How it works
 
-Rules live as `.go` files in `.lintcn/` at your project root. You own the source — edit, customize, delete.
+Each rule lives in its own subfolder under `.lintcn/`. You own the source — edit, customize, delete.
 
 ```
 my-project/
 ├── .lintcn/
-│   ├── .gitignore                      ← ignores generated Go files
-│   ├── no_unhandled_error.go           ← your rule (committed)
-│   └── no_unhandled_error_test.go      ← its tests (committed)
+│   ├── .gitignore                          ← ignores generated Go files
+│   ├── no_floating_promises/
+│   │   ├── no_floating_promises.go         ← rule source (committed)
+│   │   ├── no_floating_promises_test.go    ← tests (committed)
+│   │   ├── options.go                      ← rule options struct
+│   │   └── schema.json                     ← options schema
+│   ├── await_thenable/
+│   │   ├── await_thenable.go
+│   │   └── await_thenable_test.go
+│   └── my_custom_rule/
+│       └── my_custom_rule.go
 ├── src/
-│   ├── index.ts
 │   └── ...
 ├── tsconfig.json
 └── package.json
@@ -48,24 +63,32 @@ my-project/
 
 When you run `npx lintcn lint`, the CLI:
 
-1. Scans `.lintcn/*.go` for rule definitions
+1. Scans `.lintcn/*/` subfolders for rule definitions
 2. Generates a Go workspace with your custom rules
 3. Compiles a custom binary (cached — rebuilds only when rules change)
 4. Runs the binary against your project
 
 You can run `lintcn lint` from any subdirectory — it walks up to find `.lintcn/` and lints the cwd project.
 
-## Writing a rule
+## Writing custom rules
 
-Every rule is a Go file with `package lintcn` that exports a `rule.Rule` variable.
+To help AI agents write and modify rules, install the lintcn skill:
+
+```bash
+npx skills add remorses/lintcn
+```
 
-Here's a rule that errors when you discard the return value of a function that returns `Error | T` — enforcing the [errore](https://errore.org) pattern:
+This gives your AI agent the full tsgolint rule API reference — AST visitors, type checker, reporting, fixes, and testing patterns.
+
+Every rule lives in a subfolder under `.lintcn/` with the package name matching the folder:
 
 ```go
+// .lintcn/no_unhandled_error/no_unhandled_error.go
+
 // lintcn:name no-unhandled-error
 // lintcn:description Disallow discarding Error-typed return values
 
-package lintcn
+package no_unhandled_error
 
 import (
     "github.com/microsoft/typescript-go/shim/ast"
@@ -136,7 +159,7 @@ void getUser("id")
 ```json
 {
   "devDependencies": {
-    "lintcn": "0.4.0"
+    "lintcn": "0.5.0"
   }
 }
 ```
@@ -147,12 +170,41 @@ Each lintcn release bundles a specific tsgolint version. Updating lintcn can cha
 2. Run `npx lintcn build` after updating to verify your rules still compile
 3. Fix any compilation errors before committing
 
-You can test against an unreleased tsgolint version without updating lintcn:
-
-```bash
-npx lintcn lint --tsgolint-version v0.10.0
+## CI Setup
+
+The first `lintcn lint` compiles a custom Go binary (~30s). Subsequent runs use the cached binary (<1s). Cache `~/.cache/lintcn/` and Go's build cache to keep CI fast.
+
+```yaml
+# .github/workflows/lint.yml
+name: Lint
+on: [push, pull_request]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+
+      - name: Cache lintcn binary + Go build cache
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cache/lintcn
+            ~/go/pkg
+          key: lintcn-${{ runner.os }}-${{ runner.arch }}-${{ hashFiles('.lintcn/**/*.go') }}
+          restore-keys: |
+            lintcn-${{ runner.os }}-${{ runner.arch }}-
+
+      - run: npm ci
+      - run: npx lintcn lint
 ```
 
+The cache key includes a hash of your rule files — when rules change, the binary is recompiled. The `restore-keys` fallback ensures Go's build cache is still used even when rules change, so recompilation takes ~1s instead of 30s.
+
 ## Prerequisites
 
 - **Node.js** — for the CLI

package/dist/cli.js

@@ -7,16 +7,17 @@ import { addRule } from "./commands/add.js";
 import { lint, buildBinary } from "./commands/lint.js";
 import { listRules } from "./commands/list.js";
 import { removeRule } from "./commands/remove.js";
+import { clean } from "./commands/clean.js";
 import { DEFAULT_TSGOLINT_VERSION } from "./cache.js";
 const require = createRequire(import.meta.url);
 const packageJson = require('../package.json');
 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 a rule by GitHub URL. Fetches the whole folder into .lintcn/{rule}/')
+    .example('# Add a 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')
     .action(async (url) => {
     await addRule(url);
 });
@@ -67,6 +68,11 @@ cli
     const binaryPath = await buildBinary({ rebuild: !!options.rebuild, tsgolintVersion });
     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/dist/codegen.js

@@ -102,10 +102,27 @@ go 1.26
     const mainGo = generateMainGo(rules);
     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) {
+    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) {
+    // 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.
 package main
@@ -115,7 +132,7 @@ import (
 
 \t"${TSGOLINT_MODULE}/internal/rule"
 \t"${TSGOLINT_MODULE}/internal/runner"
-\tlintcn "${TSGOLINT_MODULE}/lintcn-rules"
+${imports}
 )
 
 func main() {

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

@@ -1 +1 @@
-{"version":3,"file":"add.d.ts","sourceRoot":"","sources":["../../src/commands/add.ts"],"names":[],"mappings":"AA+EA,wBAAsB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA2DxD"}
+{"version":3,"file":"add.d.ts","sourceRoot":"","sources":["../../src/commands/add.ts"],"names":[],"mappings":"AAwHA,wBAAsB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA4ExD"}

package/dist/commands/add.js

@@ -1,34 +1,70 @@
-// 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 GitHub blob/tree/raw URLs into components.
+ *  Ref is assumed to be the first path component after blob/tree —
+ *  branch names with slashes (e.g. feature/foo) are not supported. */
+function parseGitHubUrl(url) {
+    // GitHub blob URLs: github.com/owner/repo/blob/ref/path/to/file.go
+    let match = url.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/blob\/([^/]+)\/(.+)$/);
+    if (match) {
+        const [, owner, repo, ref, filePath] = match;
+        return { owner, repo, ref, dirPath: path.posix.dirname(filePath), fileName: path.posix.basename(filePath) };
+    }
+    // GitHub tree URLs: github.com/owner/repo/tree/ref/path/to/folder
+    match = url.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)\/(.+)$/);
+    if (match) {
+        const [, owner, repo, ref, dirPath] = match;
+        return { owner, repo, ref, dirPath };
+    }
+    // raw.githubusercontent.com URLs
+    match = url.match(/^https?:\/\/raw\.githubusercontent\.com\/([^/]+)\/([^/]+)\/([^/]+)\/(.+)$/);
+    if (match) {
+        const [, owner, repo, ref, filePath] = match;
+        return { owner, repo, ref, dirPath: path.posix.dirname(filePath), fileName: path.posix.basename(filePath) };
+    }
+    return null;
+}
+/** 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;
+    }
 }
-function deriveTestUrl(rawUrl) {
-    return rawUrl.replace(/\.go$/, '_test.go');
+/** 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}`;
+    }
+    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;
 }
 async function fetchFile(url) {
     const response = await fetch(url);
@@ -37,24 +73,11 @@ async function fetchFile(url) {
     }
     return response.text();
 }
-async function tryFetchFile(url) {
-    try {
-        return await fetchFile(url);
-    }
-    catch {
-        return null;
-    }
-}
-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');
-}
 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++) {
@@ -69,51 +92,59 @@ function ensureSourceComment(content, 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}`);
+    const parsed = parseGitHubUrl(url);
+    if (!parsed) {
+        throw new Error('Only GitHub URLs are supported. Pass a /blob/ (file) or /tree/ (folder) URL.\n' +
+            'Example: lintcn add https://github.com/oxc-project/tsgolint/tree/main/internal/rules/no_floating_promises');
+    }
+    const { owner, repo, ref, dirPath } = parsed;
+    const folderName = path.posix.basename(dirPath);
+    console.log(`Fetching ${owner}/${repo}/${dirPath}...`);
+    const items = await listGitHubFolder(owner, repo, dirPath, ref);
+    // Filter for .go and .json files
+    const filesToFetch = items.filter((item) => {
+        return item.type === 'file' && item.download_url && (item.name.endsWith('.go') || item.name.endsWith('.json'));
+    });
+    if (filesToFetch.length === 0) {
+        throw new Error(`No .go files found in ${dirPath}. Is this a rule folder?`);
+    }
+    // Warn if this doesn't look like a single-rule folder (too many main .go files)
+    const mainGoFiles = filesToFetch.filter((f) => {
+        return 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 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);
+    // Clean existing rule folder if it exists
+    if (fs.existsSync(ruleDir)) {
+        fs.rmSync(ruleDir, { recursive: true });
+        console.log(`Overwriting existing ${folderName}/`);
+    }
+    fs.mkdirSync(ruleDir, { recursive: true });
+    // Fetch and write all files
+    for (const item of filesToFetch) {
+        let content = await fetchFile(item.download_url);
+        // Add lintcn:source comment to the main rule file (same name as folder)
+        if (item.name === `${folderName}.go`) {
+            content = ensureSourceComment(content, url);
+        }
+        fs.writeFileSync(path.join(ruleDir, item.name), content);
+        console.log(`  ${item.name}`);
+    }
+    console.log(`Added ${folderName}/ (${filesToFetch.length} files)`);
+    // Ensure tsgolint source is available
     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)
+    // Create/refresh .tsgolint symlink for gopls
     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);

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.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":"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,CAkElB;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"}

package/dist/commands/lint.js

@@ -4,7 +4,7 @@ import fs from 'node:fs';
 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 +29,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 +38,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,10 +53,23 @@ 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;
 }

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"}