@atlisp/lint 0.1.5 → 0.1.6

package/dist/checks/redundant-quotes.js

@@ -11,7 +11,7 @@ function checkRedundantQuotes(content, file) {
 function checkRedundantQuotesAst(ast, file) {
     const issues = [];
     // ''x → (quote (quote x)) — nested quote
-    const doubleQuotes = (0, parser_1.astFindAll)(ast, (n) => {
+    const doubleQuotes = (0, parser_1.astFindAll)(ast, n => {
         if (!(0, parser_1.astIsList)(n, 'quote'))
             return false;
         if (!n.children || n.children.length < 2)

package/dist/checks/redundant-setq.js

@@ -10,7 +10,7 @@ function checkRedundantSetq(content, file) {
 }
 function checkRedundantSetqAst(ast, file) {
     const issues = [];
-    const setqNodes = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, 'setq'));
+    const setqNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'setq'));
     for (const node of setqNodes) {
         if (!node.children)
             continue;

package/dist/checks/self-compare.js

@@ -12,7 +12,7 @@ function checkSelfCompare(content, file) {
 function checkSelfCompareAst(ast, file) {
     const issues = [];
     for (const fn of COMPARE_FUNCTIONS) {
-        const nodes = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, fn));
+        const nodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, fn));
         for (const node of nodes) {
             if (!node.children)
                 continue;

package/dist/checks/setq-multiple.d.ts

@@ -0,0 +1,3 @@
+import { Issue } from '../types';
+export declare function checkSetqMultiple(content: string, file: string): Issue[];
+//# sourceMappingURL=setq-multiple.d.ts.map

package/dist/checks/setq-multiple.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkSetqMultiple = checkSetqMultiple;
+const locale_1 = require("../locale");
+const utils_1 = require("../utils");
+function checkSetqMultiple(content, file) {
+    const issues = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const stripped = (0, utils_1.stripLine)(lines[i]);
+        if (/\(setq\s+\S+\s+[^\s)]+\)\s*\(setq\b/.test(stripped)) {
+            issues.push({ file, line: i + 1, severity: 'warn', rule: 'setq_multiple', message: (0, locale_1.t)('setq_multiple') });
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=setq-multiple.js.map

package/dist/checks/setq-single-arg.d.ts

@@ -0,0 +1,5 @@
+import { Issue } from '../types';
+import { AstNode } from '@atlisp/parser';
+export declare function checkSetqSingleArg(content: string, file: string): Issue[];
+export declare function checkSetqSingleArgAst(ast: AstNode, file: string): Issue[];
+//# sourceMappingURL=setq-single-arg.d.ts.map

package/dist/checks/setq-single-arg.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkSetqSingleArg = checkSetqSingleArg;
+exports.checkSetqSingleArgAst = checkSetqSingleArgAst;
+const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
+function checkSetqSingleArg(content, file) {
+    const ast = (0, parser_1.parseAst)(content);
+    return checkSetqSingleArgAst(ast, file);
+}
+function checkSetqSingleArgAst(ast, file) {
+    const issues = [];
+    const nodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'setq'));
+    for (const node of nodes) {
+        if (!node.children)
+            continue;
+        // (setq x) — 2 children: 'setq', x — missing value
+        if (node.children.length === 2) {
+            issues.push({
+                file,
+                line: node.pos.line,
+                severity: 'warn',
+                rule: 'setq_single_arg',
+                message: (0, locale_1.t)('setq_single_arg', node.children[1].name || ''),
+            });
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=setq-single-arg.js.map

package/dist/checks/shadow-builtin.d.ts

@@ -0,0 +1,3 @@
+import { Issue } from '../types';
+export declare function checkShadowBuiltin(content: string, file: string): Issue[];
+//# sourceMappingURL=shadow-builtin.d.ts.map

package/dist/checks/shadow-builtin.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkShadowBuiltin = checkShadowBuiltin;
+const locale_1 = require("../locale");
+const utils_1 = require("../utils");
+const BUILTINS = new Set([
+    'car',
+    'cdr',
+    'cons',
+    'list',
+    'append',
+    'length',
+    'member',
+    'assoc',
+    'subst',
+    'apply',
+    'mapcar',
+    'foreach',
+    'while',
+    'repeat',
+    'if',
+    'cond',
+    'progn',
+    'setq',
+    'set',
+    'quote',
+    'function',
+    'lambda',
+    'defun',
+    'princ',
+    'print',
+    'prompt',
+    'getint',
+    'getreal',
+    'getstring',
+    'getpoint',
+    'getvar',
+    'setvar',
+    'command',
+    'vlax-',
+    'vla-',
+    'vl-',
+    'ssget',
+    'ssname',
+    'sslength',
+    'entget',
+    'entmod',
+    'entmake',
+    'entdel',
+    'entlast',
+    'entsel',
+    'tblobjname',
+    'tblsearch',
+    'tblnext',
+    'regapp',
+    'startapp',
+    'vl-registry-write',
+    'vl-registry-read',
+    'vl-registry-delete',
+    'vl-catch-all-apply',
+    'vl-catch-all-error-p',
+    'vl-load-com',
+    'vlax-get-or-create-object',
+]);
+function checkShadowBuiltin(content, file) {
+    const issues = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const stripped = (0, utils_1.stripLine)(lines[i]);
+        const m = stripped.match(/\(defun\s+(\S+)\b/);
+        if (m && BUILTINS.has(m[1].toLowerCase())) {
+            issues.push({ file, line: i + 1, severity: 'warn', rule: 'shadow_builtin', message: (0, locale_1.t)('shadow_builtin', m[1]) });
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=shadow-builtin.js.map

package/dist/checks/single-arg-and-or.js

@@ -11,7 +11,7 @@ function checkSingleArgAndOr(content, file) {
 function checkSingleArgAndOrAst(ast, file) {
     const issues = [];
     for (const form of ['and', 'or']) {
-        const nodes = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, form));
+        const nodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, form));
         for (const node of nodes) {
             if (!node.children)
                 continue;

package/dist/checks/strcat-usage.d.ts

@@ -0,0 +1,3 @@
+import { Issue } from '../types';
+export declare function checkStrcatUsage(content: string, file: string): Issue[];
+//# sourceMappingURL=strcat-usage.d.ts.map

package/dist/checks/strcat-usage.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkStrcatUsage = checkStrcatUsage;
+const locale_1 = require("../locale");
+const utils_1 = require("../utils");
+function checkStrcatUsage(content, file) {
+    const issues = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const stripped = (0, utils_1.stripLineRaw)(lines[i]);
+        // Check for (+ "str" ...) pattern
+        const m = stripped.match(/\(\+\s+"[^"]*"/);
+        if (m) {
+            issues.push({
+                file,
+                line: i + 1,
+                severity: 'warn',
+                rule: 'strcat_usage',
+                message: (0, locale_1.t)('strcat_usage'),
+            });
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=strcat-usage.js.map

package/dist/checks/type-check.d.ts

@@ -0,0 +1,3 @@
+import { Issue } from '../types';
+export declare function checkTypeCheck(content: string, file: string): Issue[];
+//# sourceMappingURL=type-check.d.ts.map

package/dist/checks/type-check.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkTypeCheck = checkTypeCheck;
+const locale_1 = require("../locale");
+const utils_1 = require("../utils");
+function checkTypeCheck(content, file) {
+    const issues = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const stripped = (0, utils_1.stripLine)(lines[i]);
+        const m = stripped.match(/\(setq\s+\S+\s+\(getvar\b/);
+        if (m) {
+            const varName = m[0].match(/\(setq\s+(\S+)/)?.[1] || '';
+            if (!varName)
+                continue;
+            const body = lines.slice(i, i + 5).join('\n');
+            const typeChk = '(type ' + varName;
+            const eqTypeChk = '(= (type ' + varName;
+            if (!body.includes(typeChk) && !body.includes(eqTypeChk)) {
+                issues.push({ file, line: i + 1, severity: 'warn', rule: 'type_check', message: (0, locale_1.t)('type_check', varName) });
+            }
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=type-check.js.map

package/dist/checks/unused-let.js

@@ -10,7 +10,7 @@ function checkUnusedLetBinding(content, file) {
 }
 function checkUnusedLetBindingAst(ast, file) {
     const issues = [];
-    const letNodes = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, 'let'));
+    const letNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'let'));
     for (const node of letNodes) {
         if (!node.children || node.children.length < 2)
             continue;

package/dist/checks/unused-package-dep.js

@@ -41,7 +41,7 @@ function checkUnusedPackageDep(file) {
     const issues = [];
     const content = fs.readFileSync(file, 'utf-8');
     const ast = (0, parser_1.parseAst)(content);
-    const inPackageNodes = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, 'in-package'));
+    const inPackageNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'in-package'));
     if (inPackageNodes.length === 0)
         return issues;
     const allPackages = new Set();
@@ -51,7 +51,7 @@ function checkUnusedPackageDep(file) {
         }
     }
     const usedSymbols = new Set();
-    const allLists = (0, parser_1.astFindAll)(ast, (n) => n.type === 'list');
+    const allLists = (0, parser_1.astFindAll)(ast, n => n.type === 'list');
     for (const node of allLists) {
         if (!node.children || node.children.length === 0)
             continue;
@@ -78,7 +78,7 @@ function checkUnusedPackageDep(file) {
     allPackages.delete(mainPackage);
     for (const pkg of allPackages) {
         if (!usedSymbols.has(pkg)) {
-            const node = inPackageNodes.find((n) => n.children && n.children.length >= 2 && (0, parser_1.astIsSymbol)(n.children[1]) && n.children[1].name === pkg);
+            const node = inPackageNodes.find(n => n.children && n.children.length >= 2 && (0, parser_1.astIsSymbol)(n.children[1]) && n.children[1].name === pkg);
             issues.push({
                 file,
                 line: node ? node.pos.line : 1,

package/dist/checks/variable-shadow.js

@@ -10,7 +10,7 @@ function checkVariableShadow(content, file) {
 }
 function checkVariableShadowAst(ast, file) {
     const issues = [];
-    const letNodes = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, 'let'));
+    const letNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'let'));
     for (const node of letNodes) {
         if (!node.children || node.children.length < 2)
             continue;

package/dist/checks/while-constant.d.ts

@@ -0,0 +1,5 @@
+import { Issue } from '../types';
+import { AstNode } from '@atlisp/parser';
+export declare function checkWhileConstant(content: string, file: string): Issue[];
+export declare function checkWhileConstantAst(ast: AstNode, file: string): Issue[];
+//# sourceMappingURL=while-constant.d.ts.map

package/dist/checks/while-constant.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkWhileConstant = checkWhileConstant;
+exports.checkWhileConstantAst = checkWhileConstantAst;
+const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
+function checkWhileConstant(content, file) {
+    const ast = (0, parser_1.parseAst)(content);
+    return checkWhileConstantAst(ast, file);
+}
+function checkWhileConstantAst(ast, file) {
+    const issues = [];
+    const whileNodes = (0, parser_1.astFindAll)(ast, n => (0, parser_1.astIsList)(n, 'while'));
+    for (const node of whileNodes) {
+        if (!node.children || node.children.length < 2)
+            continue;
+        const cond = node.children[1];
+        // Check for constant conditions: nil, T, 1, 0, etc.
+        if (cond.type === 'symbol' && (cond.name === 'nil' || cond.name === 'T')) {
+            issues.push({
+                file,
+                line: node.pos.line,
+                severity: 'warn',
+                rule: 'while_constant',
+                message: (0, locale_1.t)('while_constant', cond.name),
+            });
+        }
+        else if (cond.type === 'number') {
+            issues.push({
+                file,
+                line: node.pos.line,
+                severity: 'warn',
+                rule: 'while_constant',
+                message: (0, locale_1.t)('while_constant', String(cond.value)),
+            });
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=while-constant.js.map

package/dist/config.d.ts

@@ -1,5 +1,6 @@
 import { LintConfig } from './types';
 export declare function loadConfig(configPath?: string): LintConfig;
+export declare function getCheckSeverity(config: LintConfig, rule: string): string;
 export declare function findOverrides(filepath: string): Partial<LintConfig> | null;
 export declare function mergeOverrides(base: LintConfig, overrides: Partial<LintConfig>): LintConfig;
 //# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -34,10 +34,12 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadConfig = loadConfig;
+exports.getCheckSeverity = getCheckSeverity;
 exports.findOverrides = findOverrides;
 exports.mergeOverrides = mergeOverrides;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const presets_1 = require("./presets");
 const DEFAULT_CONFIG = {
     locale: 'zh',
     source: {
@@ -56,14 +58,69 @@ const DEFAULT_CONFIG = {
         token_in_url: 'warn',
         open_without_close: 'warn',
         bare_function_names: 'warn',
-        trailing_whitespace: 'warn',
         line_length: 'warn',
         function_complexity: 'warn',
         parameter_naming: 'warn',
         unused_variable: 'warn',
         missing_doc: 'warn',
+        trailing_whitespace: 'warn',
         module_registration: 'off',
         namespace_header: 'off',
+        unused_parameter: 'warn',
+        constant_condition: 'warn',
+        redundant_progn: 'warn',
+        empty_branch: 'warn',
+        unused_let_binding: 'warn',
+        recursive_call: 'warn',
+        variable_shadow: 'warn',
+        redundant_cond: 'warn',
+        unused_local_fun: 'warn',
+        multiple_setq: 'warn',
+        redundant_quotes: 'warn',
+        trailing_paren: 'warn',
+        empty_comment: 'warn',
+        redundant_setq: 'warn',
+        redundant_nil_else: 'warn',
+        single_arg_and_or: 'warn',
+        redundant_let: 'warn',
+        self_compare: 'warn',
+        misplaced_else: 'warn',
+        quote_vs_function: 'warn',
+        commented_code: 'warn',
+        double_not: 'warn',
+        setq_single_arg: 'warn',
+        assoc_without_cdr: 'warn',
+        identical_branches: 'warn',
+        while_constant: 'warn',
+        cond_duplicate: 'warn',
+        duplicate_defun: 'warn',
+        dangling_defun: 'warn',
+        missing_export: 'warn',
+        unused_package_dep: 'warn',
+        error_handling: 'warn',
+        global_naming: 'warn',
+        extra_parens: 'warn',
+        arg_count: 'warn',
+        strcat_usage: 'warn',
+        cond_simplify: 'warn',
+        quote_style: 'warn',
+        eq_usage: 'warn',
+        lambda_syntax: 'warn',
+        comment_style: 'warn',
+        empty_catch: 'warn',
+        nth_usage: 'warn',
+        append_single: 'warn',
+        setq_multiple: 'warn',
+        function_order: 'off',
+        magic_number: 'off',
+        mixed_indent: 'warn',
+        long_function_call: 'warn',
+        no_return: 'warn',
+        shadow_builtin: 'warn',
+        dynamic_doc: 'warn',
+        loop_optimization: 'off',
+        type_check: 'off',
+        redundant_if: 'warn',
     },
     line_length: {
         max: 100,
@@ -111,9 +168,17 @@ function loadConfig(configPath) {
         }
         const raw = fs.readFileSync(absPath, 'utf-8');
         const user = JSON.parse(raw);
-        // Deep merge: start from default, overlay user values
+        // Start from default config
         const merged = JSON.parse(JSON.stringify(DEFAULT_CONFIG));
+        // Apply preset if specified (preset applies before user overrides)
+        const preset = user.preset;
+        if (preset && presets_1.PRESETS[preset]) {
+            deepMerge(merged, presets_1.PRESETS[preset]);
+        }
+        // Apply user overrides (user settings take precedence)
         deepMerge(merged, user);
+        // Remove non-config keys
+        delete merged.preset;
         return merged;
     }
     return JSON.parse(JSON.stringify(DEFAULT_CONFIG));
@@ -133,6 +198,9 @@ function deepMerge(target, source) {
         }
     }
 }
+function getCheckSeverity(config, rule) {
+    return config.checks[rule] || 'off';
+}
 function findOverrides(filepath) {
     const dir = path.dirname(filepath);
     const configPath = path.join(dir, '.atlisp-lint.json');

package/dist/disable.js

@@ -12,7 +12,7 @@ function parseDisableComments(content, fileLine) {
             continue;
         const rules = m[1]
             .split(',')
-            .map((r) => r.trim())
+            .map(r => r.trim())
             .filter(Boolean);
         let targetLine = i + 1;
         if (fileLine !== undefined)

package/dist/formatters.d.ts

@@ -1,4 +1,5 @@
 import { Issue } from './types';
 export declare function formatDefault(issues: Issue[], fileContents?: Map<string, string>): string;
+export declare function formatHtml(issues: Issue[], errorCount: number, warningCount: number): string;
 export declare function formatJson(issues: Issue[], errorCount?: number, warningCount?: number): string;
 //# sourceMappingURL=formatters.d.ts.map

package/dist/formatters.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatDefault = formatDefault;
+exports.formatHtml = formatHtml;
 exports.formatJson = formatJson;
 const locale_1 = require("./locale");
 const colors = {
@@ -68,11 +69,26 @@ function formatDefault(issues, fileContents) {
     }
     return lines.join('\n');
 }
+function formatHtml(issues, errorCount, warningCount) {
+    let html = `<!DOCTYPE html>
+<html lang="en">
+<head><meta charset="UTF-8"><title>@atlisp/lint Report</title></head>
+<body>
+<h1>@atlisp/lint Report</h1>
+<p>${errorCount} error(s), ${warningCount} warning(s)</p>
+<ul>
+`;
+    for (const iss of issues) {
+        html += `  <li>${iss.severity}: ${iss.file}:${iss.line} — ${iss.message}</li>\n`;
+    }
+    html += '</ul>\n</body>\n</html>';
+    return html;
+}
 function formatJson(issues, errorCount, warningCount) {
     return JSON.stringify({
         issues,
-        error_count: errorCount ?? issues.filter((i) => i.severity === 'error').length,
-        warning_count: warningCount ?? issues.filter((i) => i.severity === 'warn').length,
+        error_count: errorCount ?? issues.filter(i => i.severity === 'error').length,
+        warning_count: warningCount ?? issues.filter(i => i.severity === 'warn').length,
     }, null, 2);
 }
 //# sourceMappingURL=formatters.js.map

package/dist/index.js

@@ -44,6 +44,7 @@ const sbcl_1 = require("./sbcl");
 const formatters_1 = require("./formatters");
 const locale_1 = require("./locale");
 const cache_1 = require("./cache");
+const watch_1 = require("./watch");
 function parseArgs() {
     const argv = process.argv.slice(2);
     const opts = {
@@ -59,6 +60,7 @@ function parseArgs() {
         clearCache: false,
         parallel: false,
         project: false,
+        watch: false,
     };
     for (let i = 0; i < argv.length; i++) {
         switch (argv[i]) {
@@ -101,6 +103,9 @@ function parseArgs() {
             case '--project':
                 opts.project = true;
                 break;
+            case '--watch':
+                opts.watch = true;
+                break;
             default:
                 break;
         }
@@ -168,12 +173,12 @@ function collectFiles(rootDir, opts, config) {
             }
         }
     }
-    const excludePatterns = config.source.exclude.map((e) => {
+    const excludePatterns = config.source.exclude.map(e => {
         const str = e.replace(/\./g, '\\.').replace(/\*\*/g, '.*').replace(/\*/g, '[^/]*');
         return new RegExp(`^${str}$`);
     });
     return Array.from(files)
-        .filter((f) => {
+        .filter(f => {
         const rel = path.relative(rootDir, f).replace(/\\/g, '/');
         for (const re of excludePatterns) {
             if (re.test(rel))
@@ -190,10 +195,10 @@ function collectStagedFiles(rootDir) {
     });
     return output
         .split('\n')
-        .map((l) => l.trim())
-        .filter((l) => l.endsWith('.lsp'))
-        .map((l) => path.resolve(rootDir, l))
-        .filter((f) => fs.existsSync(f));
+        .map(l => l.trim())
+        .filter(l => l.endsWith('.lsp'))
+        .map(l => path.resolve(rootDir, l))
+        .filter(f => fs.existsSync(f));
 }
 function initConfig(rootDir) {
     const defaultPath = path.join(__dirname, '..', 'atlisp-lint.default.json');
@@ -249,6 +254,11 @@ async function main() {
             console.log((0, locale_1.t)('index.no_files'));
             return;
         }
+        // --watch mode
+        if (opts.watch) {
+            (0, watch_1.watchFiles)(files, { rootDir, format: opts.format, config });
+            return;
+        }
         // --fix mode: auto-fix before linting
         if (opts.fix) {
             for (const f of files) {
@@ -260,10 +270,20 @@ async function main() {
             if (!opts.staged)
                 return;
         }
-        // Filter cached files
+        // Filter cached files (pre-read content to avoid double I/O)
+        const contentCache = new Map();
         const filesToLint = opts.cache
-            ? files.filter((f) => {
-                const cached = (0, cache_1.isCached)(f, rootDir);
+            ? files.filter(f => {
+                let content;
+                try {
+                    content = fs.readFileSync(f, 'utf-8');
+                }
+                catch {
+                    /* ignore */
+                }
+                if (content !== undefined)
+                    contentCache.set(f, content);
+                const cached = (0, cache_1.isCached)(f, rootDir, content);
                 if (cached) {
                     console.log(`${(0, locale_1.t)('summary.tag_warn')}: ${path.relative(rootDir, f)} — ${(0, locale_1.t)('index.cached')}`);
                 }
@@ -283,10 +303,30 @@ async function main() {
             const projectIssues = (0, project_1.lintProject)(filesToLint, config, rootDir);
             issues.push(...projectIssues);
         }
-        // Mark as cached
+        // Apply rule-based fixes (after lint, when --fix is set)
+        if (opts.fix) {
+            for (const f of filesToLint) {
+                const relPath = path.relative(rootDir, f);
+                const fileIssues = issues.filter(i => i.file === relPath);
+                if (fileIssues.length > 0) {
+                    try {
+                        const content = fs.readFileSync(f, 'utf-8');
+                        const fixed = (0, runner_1.applyFixes)(fileIssues, content, relPath);
+                        if (fixed !== content) {
+                            fs.writeFileSync(f, fixed, 'utf-8');
+                            console.log(`${(0, locale_1.t)('summary.tag_fail')}: ${relPath} — ${(0, locale_1.t)('index.fixed')}`);
+                        }
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                }
+            }
+        }
+        // Mark as cached (reuse pre-read content if available)
         if (opts.cache) {
             for (const f of filesToLint) {
-                (0, cache_1.markCached)(f, rootDir);
+                (0, cache_1.markCached)(f, rootDir, contentCache.get(f));
             }
         }
         // Phase 2: SBCL syntax validation
@@ -319,8 +359,8 @@ async function main() {
             }
         }
         // Format & output
-        const errorCount = issues.filter((i) => i.severity === 'error').length;
-        const warningCount = issues.filter((i) => i.severity === 'warn').length;
+        const errorCount = issues.filter(i => i.severity === 'error').length;
+        const warningCount = issues.filter(i => i.severity === 'warn').length;
         if (opts.format === 'json') {
             console.log((0, formatters_1.formatJson)(issues, errorCount, warningCount));
         }