@atlisp/lint 0.1.5 → 0.1.8

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,70 @@ 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',
+        format_indent: 'off',
+        redundant_if: 'warn',
     },
     line_length: {
         max: 100,
@@ -111,9 +169,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 +199,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/formatter.d.ts

@@ -0,0 +1,2 @@
+export declare function formatCode(content: string, indentSize?: number): string;
+//# sourceMappingURL=formatter.d.ts.map

package/dist/formatter.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatCode = formatCode;
+const utils_1 = require("./utils");
+function v1Format(content, indentSize) {
+    const lines = content.split('\n');
+    const result = [];
+    let depth = 0;
+    for (const line of lines) {
+        const trimmedLine = line.trimEnd();
+        if (trimmedLine === '') {
+            result.push('');
+            continue;
+        }
+        const stripped = (0, utils_1.stripLine)(trimmedLine);
+        const trimmedStripped = stripped.trim();
+        if (trimmedStripped === '') {
+            const indent = ' '.repeat(depth * indentSize);
+            result.push(indent + trimmedLine.trimStart());
+            continue;
+        }
+        let openCount = 0;
+        let closeCount = 0;
+        for (const ch of trimmedStripped) {
+            if (ch === '(')
+                openCount++;
+            else if (ch === ')')
+                closeCount++;
+        }
+        let effectiveDepth = depth;
+        if (trimmedStripped.startsWith(')')) {
+            let leadingClose = 0;
+            for (const ch of trimmedStripped) {
+                if (ch === ')')
+                    leadingClose++;
+                else
+                    break;
+            }
+            effectiveDepth = Math.max(0, depth - leadingClose);
+        }
+        result.push(' '.repeat(effectiveDepth * indentSize) + trimmedLine.trimStart());
+        depth += openCount - closeCount;
+        if (depth < 0)
+            depth = 0;
+    }
+    return result;
+}
+function formatCode(content, indentSize = 2) {
+    return v1Format(content, indentSize).join('\n');
+}
+//# sourceMappingURL=formatter.js.map

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

@@ -42,8 +42,10 @@ const runner_1 = require("./runner");
 const project_1 = require("./project");
 const sbcl_1 = require("./sbcl");
 const formatters_1 = require("./formatters");
+const formatter_1 = require("./formatter");
 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 +61,12 @@ function parseArgs() {
         clearCache: false,
         parallel: false,
         project: false,
+        watch: false,
+        help: false,
+        version: false,
+        formatCode: false,
+        formatCheck: false,
+        sbcl: false,
     };
     for (let i = 0; i < argv.length; i++) {
         switch (argv[i]) {
@@ -101,6 +109,24 @@ function parseArgs() {
             case '--project':
                 opts.project = true;
                 break;
+            case '--watch':
+                opts.watch = true;
+                break;
+            case '--help':
+                opts.help = true;
+                break;
+            case '--version':
+                opts.version = true;
+                break;
+            case '--format-code':
+                opts.formatCode = true;
+                break;
+            case '--format-check':
+                opts.formatCheck = true;
+                break;
+            case '--sbcl':
+                opts.sbcl = true;
+                break;
             default:
                 break;
         }
@@ -168,12 +194,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 +216,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');
@@ -222,10 +248,27 @@ npx @atlisp/lint ${args} || exit 1
     fs.chmodSync(hookPath, 0o755);
     console.log((0, locale_1.t)('index.hook_installed', hookPath));
 }
+function printHelp() {
+    console.log((0, locale_1.t)('help.text'));
+}
 async function main() {
     try {
         const opts = parseArgs();
         const rootDir = process.cwd();
+        // Load config early so locale is available for --help and other commands
+        const configPath = opts.config || path.join(rootDir, 'atlisp-lint.json');
+        const config = (0, config_1.loadConfig)(fs.existsSync(configPath) ? configPath : undefined);
+        (0, locale_1.setLocale)(config.locale || 'zh');
+        if (opts.help) {
+            printHelp();
+            return;
+        }
+        if (opts.version) {
+            const pkgPath = path.join(__dirname, '..', 'package.json');
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+            console.log(pkg.version);
+            return;
+        }
         if (opts.init) {
             initConfig(rootDir);
             return;
@@ -239,16 +282,45 @@ async function main() {
             console.log((0, locale_1.t)('index.cache_cleared'));
             return;
         }
-        // Load config
-        const configPath = opts.config || path.join(rootDir, 'atlisp-lint.json');
-        const config = (0, config_1.loadConfig)(fs.existsSync(configPath) ? configPath : undefined);
-        (0, locale_1.setLocale)(config.locale || 'zh');
         // Collect files
         const files = opts.staged ? collectStagedFiles(rootDir) : collectFiles(rootDir, opts, config);
         if (files.length === 0) {
             console.log((0, locale_1.t)('index.no_files'));
             return;
         }
+        // --format-code mode: format files in place
+        if (opts.formatCode || opts.formatCheck) {
+            let needsFormat = false;
+            for (const f of files) {
+                const content = fs.readFileSync(f, 'utf-8');
+                const formatted = (0, formatter_1.formatCode)(content);
+                if (content !== formatted) {
+                    if (opts.formatCheck) {
+                        console.log(`${path.relative(rootDir, f)} — needs formatting`);
+                        needsFormat = true;
+                    }
+                    else {
+                        fs.writeFileSync(f, formatted, 'utf-8');
+                        console.log(`${(0, locale_1.t)('summary.tag_fail')}: ${path.relative(rootDir, f)} — ${(0, locale_1.t)('index.fixed', 'format')}`);
+                    }
+                }
+                // Idempotency check: format again to verify stability
+                if (!opts.formatCheck) {
+                    const reFormatted = (0, formatter_1.formatCode)(fs.readFileSync(f, 'utf-8'));
+                    if (reFormatted !== fs.readFileSync(f, 'utf-8')) {
+                        console.log(`${(0, locale_1.t)('summary.tag_warn')}: ${path.relative(rootDir, f)} — ${(0, locale_1.t)('index.format_unstable')}`);
+                    }
+                }
+            }
+            if (opts.formatCheck && needsFormat)
+                process.exit(1);
+            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) {
@@ -257,13 +329,39 @@ async function main() {
                     console.log(`${(0, locale_1.t)('summary.tag_fail')}: ${path.relative(rootDir, f)} — ${(0, locale_1.t)('index.fixed', rule)}`);
                 }
             }
+            // format_indent fix for non-staged mode (no lint results available yet)
+            if (config.checks['format_indent'] !== 'off') {
+                for (const f of files) {
+                    try {
+                        const content = fs.readFileSync(f, 'utf-8');
+                        const formatted = (0, formatter_1.formatCode)(content);
+                        if (formatted !== content) {
+                            fs.writeFileSync(f, formatted, 'utf-8');
+                            console.log(`${(0, locale_1.t)('summary.tag_fail')}: ${path.relative(rootDir, f)} — ${(0, locale_1.t)('index.fixed', 'format_indent')}`);
+                        }
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                }
+            }
             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,27 +381,69 @@ async function main() {
             const projectIssues = (0, project_1.lintProject)(filesToLint, config, rootDir);
             issues.push(...projectIssues);
         }
-        // Mark as cached
-        if (opts.cache) {
+        // Apply rule-based fixes (after lint, when --fix is set)
+        if (opts.fix) {
             for (const f of filesToLint) {
-                (0, cache_1.markCached)(f, rootDir);
+                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 */
+                    }
+                }
+            }
+            // format_indent fix: apply formatCode to files with format_indent issues
+            if (config.checks['format_indent'] !== 'off') {
+                for (const f of filesToLint) {
+                    const relPath = path.relative(rootDir, f);
+                    const hasFormatIssue = issues.some(i => i.file === relPath && i.rule === 'format_indent');
+                    if (hasFormatIssue) {
+                        try {
+                            const content = fs.readFileSync(f, 'utf-8');
+                            const formatted = (0, formatter_1.formatCode)(content);
+                            if (formatted !== content) {
+                                fs.writeFileSync(f, formatted, 'utf-8');
+                                console.log(`${(0, locale_1.t)('summary.tag_fail')}: ${relPath} — ${(0, locale_1.t)('index.fixed', 'format_indent')}`);
+                            }
+                        }
+                        catch {
+                            /* ignore */
+                        }
+                    }
+                }
             }
         }
-        // Phase 2: SBCL syntax validation
-        const stubPkgPath = path.join(__dirname, '..', 'stub-packages.json');
-        try {
-            const sbclIssues = (0, sbcl_1.runSbclLint)(rootDir, config.sbcl, stubPkgPath);
-            issues.push(...sbclIssues);
+        // Mark as cached (reuse pre-read content if available)
+        if (opts.cache) {
+            for (const f of filesToLint) {
+                (0, cache_1.markCached)(f, rootDir, contentCache.get(f));
+            }
         }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            issues.push({
-                file: 'sbcl',
-                line: 1,
-                severity: 'error',
-                rule: 'sbcl',
-                message: msg,
-            });
+        // Phase 2: SBCL syntax validation (only when --sbcl is specified)
+        if (opts.sbcl) {
+            const stubPkgPath = path.join(__dirname, '..', 'stub-packages.json');
+            try {
+                const sbclIssues = (0, sbcl_1.runSbclLint)(rootDir, config.sbcl, stubPkgPath);
+                issues.push(...sbclIssues);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                issues.push({
+                    file: 'sbcl',
+                    line: 1,
+                    severity: 'error',
+                    rule: 'sbcl',
+                    message: msg,
+                });
+            }
         }
         // Build file content map for code line display
         const fileContents = new Map();
@@ -319,8 +459,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));
         }

package/dist/lib/lint-sbcl.lisp

@@ -0,0 +1,161 @@
+;; @lisp SBCL Lint — syntax validation via SBCL
+;; Usage: sbcl --script lint-sbcl.lisp <src-dir> <stub-packages.json> <walk-exclude-json> <defmacro-allow-files-json> <locale>
+
+(require :uiop)
+
+(defparameter *errors* 0)
+(defparameter *warnings* 0)
+(defparameter *checked* 0)
+(defparameter *locale* "zh")
+
+;; ── i18n ──────────────────────────────────────────────────────────────
+(defun i18n (key)
+  (cdr (assoc key
+    (if (string= *locale* "zh")
+      '((:not-found . "not found symbol")
+        (:syntax-error . "syntax error")
+        (:vec-syntax . "#( vector syntax")
+        (:char-syntax . "# backslash char literal")
+        (:eval-syntax . "#. read-time eval")
+        (:defmacro . "defmacro")
+        (:trailing-ws . "trailing whitespace")
+        (:ok . "OK")
+        (:fail . "FAIL")
+        (:header . "  @lisp SBCL Lint")
+        (:source . "  Source")
+        (:found . "  Found ~d .lsp files")
+        (:scanned . "  Scanned")
+        (:errors . "  Errors")
+        (:warnings . "  Warnings"))
+      '((:not-found . "not found symbol")
+        (:syntax-error . "syntax error")
+        (:vec-syntax . "#( vector syntax")
+        (:char-syntax . "# backslash char literal")
+        (:eval-syntax . "#. read-time eval")
+        (:defmacro . "defmacro")
+        (:trailing-ws . "trailing whitespace")
+        (:ok . "OK")
+        (:fail . "FAIL")
+        (:header . "  @lisp SBCL Lint")
+        (:source . "  Source")
+        (:found . "  Found ~d .lsp files")
+        (:scanned . "  Scanned")
+        (:errors . "  Errors")
+        (:warnings . "  Warnings"))))))
+
+;; ── Stub packages from external file ──────────────────────────────────
+(defun load-stub-packages (file-path)
+  (flet ((ensure-pkg (name &optional use-list)
+           (unless (find-package name)
+             (make-package name :use (or use-list '())))))
+    (with-open-file (s file-path :direction :input)
+      (let ((packages (read s)))
+        (dolist (pkg packages)
+          (ensure-pkg (first pkg) (second pkg)))))))
+
+;; ── File walking ──────────────────────────────────────────────────────
+(defun source-files (dir)
+  (sort
+    (remove-if-not
+      (lambda (p)
+        (let ((n (pathname-type p)))
+          (and n (string-equal n "lsp"))))
+      (uiop:directory-files dir))
+    'string< :key #'namestring))
+
+(defun walk-tree (dir exclude-dirs)
+  (let ((result (source-files dir)))
+    (dolist (sub (uiop:subdirectories dir))
+      (let ((name (car (last (pathname-directory sub)))))
+        (unless (find name exclude-dirs :test 'string=)
+          (setf result (append result (walk-tree sub exclude-dirs))))))
+    result))
+
+;; ── Per-file check ────────────────────────────────────────────────────
+(defun check-file (path src-dir defmacro-allow-files)
+  (incf *checked*)
+  (let* ((rel (enough-namestring path src-dir))
+         (fullname (format nil "~a.~a" (pathname-name path) (pathname-type path))))
+    (format t "  ~a ... " rel)
+    (force-output)
+    ;; Syntax check via READ
+    (handler-case
+        (with-open-file (s path :direction :input)
+          (loop for form = (read s nil :eof)
+                until (eq form :eof)))
+      (error (e)
+        (let ((msg (princ-to-string e)))
+          (cond
+            ((search "not found" msg)
+             (format t "~%  [NOTE] ~a: ~a~%" rel (i18n :not-found))
+             (incf *warnings*))
+            (t
+             (format t "~a~%  [ERROR] ~a: ~a~%" (i18n :fail) rel (i18n :syntax-error))
+             (incf *errors*)
+             (return-from check-file))))))
+    ;; Trailing whitespace
+    (with-open-file (s path :direction :input)
+      (loop for line = (read-line s nil nil)
+            for lineno from 1
+            while line
+            when (and (> (length line) 0)
+                      (find (char line (1- (length line))) '(#\Space #\Tab)))
+              do (progn
+                   (format t "~%  [WARN] ~a line ~d: ~a~%" rel lineno (i18n :trailing-ws))
+                   (incf *warnings*))))
+    ;; CL-ism checks: raw content scan
+    (with-open-file (s path :direction :input)
+      (let ((content (make-string (file-length s))))
+        (file-position s 0)
+        (read-sequence content s)
+        (when (search "#(" content)
+          (format t "~%  [WARN] ~a: ~a~%" rel (i18n :vec-syntax))
+          (incf *warnings*))
+        (when (search "#\\" content)
+          (format t "~%  [WARN] ~a: ~a~%" rel (i18n :char-syntax))
+          (incf *warnings*))
+        (when (search "#." content)
+          (format t "~%  [WARN] ~a: ~a~%" rel (i18n :eval-syntax))
+          (incf *warnings*))
+        (when (and (search "defmacro" content)
+                   (not (some (lambda (s) (search s fullname)) defmacro-allow-files)))
+          (format t "~%  [WARN] ~a: ~a~%" rel (i18n :defmacro))
+          (incf *warnings*))))
+    (format t "~a~%" (i18n :ok))))
+
+;; ── Main ──────────────────────────────────────────────────────────────
+(defun main ()
+  (let* ((args (uiop:command-line-arguments))
+         (src-dir (first args))
+         (stub-file (second args))
+         (walk-exclude (if (third args)
+                          (read-from-string (third args))
+                          '(".vscode" "test" "experiment" "tools" ".git")))
+         (defmacro-allow (if (fourth args)
+                            (read-from-string (fourth args))
+                            '("compat-cl")))
+         (locale (fifth args)))
+    (when locale (setf *locale* locale))
+    (load-stub-packages stub-file)
+
+    (format t "~%==================================================~%")
+    (format t "~a~%" (i18n :header))
+    (format t "~a: ~a~%" (i18n :source) (namestring (pathname src-dir)))
+    (format t "==================================================~%~%")
+    (setf *errors* 0 *warnings* 0 *checked* 0)
+
+    (let ((files (walk-tree src-dir walk-exclude)))
+      (format t "~a~%~%" (format nil (i18n :found) (length files)))
+      (dolist (f files)
+        (check-file f src-dir defmacro-allow)))
+
+    (format t "~%==================================================~%")
+    (format t "~a: ~d~%" (i18n :scanned) *checked*)
+    (format t "~a: ~d~%" (i18n :errors) *errors*)
+    (format t "~a: ~d~%" (i18n :warnings) *warnings*)
+    (format t "==================================================~%~%")
+    (if (> *errors* 0)
+        (uiop:quit 1)
+        (uiop:quit 0))))
+
+(main)