@atlisp/lint 0.1.6 → 0.1.8

package/README.md

@@ -27,6 +27,12 @@ npx @atlisp/lint --fix
 
 # 监听文件变化自动重检
 npx @atlisp/lint --watch
+
+# 自动格式化代码缩进
+npx @atlisp/lint --format-code
+
+# 检查代码格式（不修改文件）
+npx @atlisp/lint --format-check
 ```
 
 ## CLI 选项
@@ -39,13 +45,17 @@ npx @atlisp/lint --watch
 --format <format>      输出格式：default（默认）| json
 --init                 在当前目录生成 atlisp-lint.json
 --install-hook         安装 git pre-commit hook
---fix                  自动修复尾部空格、UTF-8 BOM、多余括号等问题
+--fix                  自动修复尾部空格、BOM、多余括号、冗余 progn/let、引号风格等问题
 --cache                启用文件哈希缓存，跳过未变更的文件
 --clear-cache          清除缓存目录
 --parallel             开启多线程并行检查（使用 Worker Threads）
 --project              启用跨文件分析（Phase 1b）
 --watch                监听模式，文件变动自动重新检查
 --hook-args <args>     自定义 pre-commit hook 参数（配合 --install-hook）
+--help                 显示帮助信息
+--version              显示版本号
+--format-code          自动格式化代码缩进（基于括号深度 + AST 对齐）
+--format-check         只检查代码缩进格式（不修改文件，不符合则退出码 1）
 ```
 
 ## 架构：三相检测
@@ -120,6 +130,7 @@ npx @atlisp/lint --watch
 | `cond_simplify` | warn | 风格 | 单分支 cond 可简化为 if |
 | `arg_count` | warn | 最佳实践 | 参数数量不匹配 |
 | `bare_function_names` | off | 风格 | defun 缺少命名空间前缀 |
+| `format_indent` | off | 风格 | 代码缩进不符合格式化规范 |
 | `function_order` | off | 最佳实践 | 定义在使用之后 |
 | `magic_number` | off | 风格 | 硬编码魔法数字 |
 | `module_registration` | off | 架构 | 模块文件未注册到 \*modules\* |
@@ -148,6 +159,26 @@ npx @atlisp/lint --watch
 - CL-ism — `#(`、`#\`、`#.` 等 AutoLISP 无效语法
 - defmacro — 默认不允许，除非文件在允许列表中
 
+## --format-code 代码格式化
+
+基于括号深度自动调整代码缩进，规则：
+
+- 每层嵌套增加 2 空格缩进
+- `)` 单独一行时自动回到对应层级的缩进
+- 注释行按当前嵌套深度缩进
+- 字符串中的括号不影响缩进计算
+- 自动删除行尾多余空格
+- 空行保持不变
+- 格式化后进行幂等性检查，若再次格式化结果不一致则输出警告
+
+```bash
+# 格式化所有 .lsp 文件
+npx @atlisp/lint --format-code
+
+# 仅检查格式（不修改文件），不符合则退出码 1
+npx @atlisp/lint --format-check
+```
+
 ## --fix 自动修复
 
 ### 预扫描修复（fixFile）
@@ -168,6 +199,12 @@ npx @atlisp/lint --watch
 | `redundant_nil_else` | (if cond x nil) → (if cond x) |
 | `single_arg_and_or` | (and x) → x |
 | `redundant_setq` | 删除 (setq x x) 行 |
+| `redundant_progn` | 移除分支中多余的 (progn ...) 包装 |
+| `redundant_let` | (let () ...) → (progn ...) |
+| `quote_style` | (quote x) → 'x |
+| `redundant_if` | 移除 if/when 分支中冗余 progn |
+| `misplaced_else` | (if (not x) a b) → (if x b a) |
+| `format_indent` | 对整个文件应用 `formatCode()` 修复缩进 |
 
 ## 行内忽略
 

package/atlisp-lint.default.json

@@ -69,6 +69,7 @@
     "nth_usage": "warn",
     "append_single": "warn",
     "setq_multiple": "warn",
+    "format_indent": "off",
     "function_order": "off",
     "magic_number": "off",
     "mixed_indent": "warn",

package/dist/checks/format-indent.d.ts

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

package/dist/checks/format-indent.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkFormatIndent = checkFormatIndent;
+const formatter_1 = require("../formatter");
+function checkFormatIndent(content, file) {
+    const formatted = (0, formatter_1.formatCode)(content);
+    if (content === formatted)
+        return [];
+    // Find first line that differs for better error location
+    const originalLines = content.split('\n');
+    const formattedLines = formatted.split('\n');
+    let firstDiffLine = 1;
+    for (let i = 0; i < Math.max(originalLines.length, formattedLines.length); i++) {
+        if (originalLines[i] !== formattedLines[i]) {
+            firstDiffLine = i + 1;
+            break;
+        }
+    }
+    return [
+        {
+            file,
+            line: firstDiffLine,
+            severity: 'warn',
+            rule: 'format_indent',
+            message: 'Code indentation does not match expected format',
+        },
+    ];
+}
+//# sourceMappingURL=format-indent.js.map

package/dist/config.js

@@ -120,6 +120,7 @@ const DEFAULT_CONFIG = {
         dynamic_doc: 'warn',
         loop_optimization: 'off',
         type_check: 'off',
+        format_indent: 'off',
         redundant_if: 'warn',
     },
     line_length: {

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/index.js

@@ -42,6 +42,7 @@ 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");
@@ -61,6 +62,11 @@ function parseArgs() {
         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]) {
@@ -106,6 +112,21 @@ function parseArgs() {
             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;
         }
@@ -227,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;
@@ -244,16 +282,40 @@ 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 });
@@ -267,6 +329,22 @@ 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;
         }
@@ -322,6 +400,26 @@ async function main() {
                     }
                 }
             }
+            // 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 */
+                        }
+                    }
+                }
+            }
         }
         // Mark as cached (reuse pre-read content if available)
         if (opts.cache) {
@@ -329,21 +427,23 @@ async function main() {
                 (0, cache_1.markCached)(f, rootDir, contentCache.get(f));
             }
         }
-        // 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);
-        }
-        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();

package/dist/locale.js

@@ -55,6 +55,7 @@ const messages = {
         error_handling: "Functions using command but missing *error*: '{0}'",
         global_naming: "Global variable '{0}' should use *...* naming convention",
         extra_parens: 'Suspicious excessive closing parenthesis: {0} extra )',
+        format_indent: 'Code indentation does not match expected format',
         setq_single_arg: "Variable '{0}' is setq'd with no value — likely a typo",
         assoc_without_cdr: 'assoc result is not used — wrap with cdr to extract the value',
         identical_branches: 'if has identical then and else branches — possible copy-paste error',
@@ -86,6 +87,31 @@ const messages = {
         'index.watching': 'Watching',
         'index.watch_hint': 'Press Ctrl+C to stop',
         'index.watch_status': '{0} files checked: {1} error(s), {2} warning(s)',
+        'index.format_unstable': 'Formatting is not idempotent — re-running formatCode produces different output',
+        'help.text': `@atlisp/lint - AutoLISP static analysis tool
+
+Usage: atlisp-lint [options]
+
+Options:
+  --src <dir>            Specify source directory (may be repeated)
+  --test <dir>           Specify test directory (may be repeated)
+  --config <path>        Path to config file
+  --staged               Only check git staged .lsp files
+  --format <format>      Output format: default | json
+  --init                 Generate atlisp-lint.json in current directory
+  --install-hook         Install git pre-commit hook
+  --fix                  Auto-fix trailing whitespace, BOM, trailing parens, etc.
+  --cache                Enable file hash caching, skip unchanged files
+  --clear-cache          Clear cache directory
+  --parallel             Enable multi-threaded parallel checking
+  --project              Enable cross-file analysis (Phase 1b)
+  --sbcl                 Enable SBCL syntax validation (Phase 2)
+  --watch                Watch mode: re-check on file changes
+  --hook-args <args>     Custom pre-commit hook arguments (with --install-hook)
+  --help                 Show this help message
+  --version              Show version number
+  --format-code          Auto-format code indentation
+  --format-check         Check if files are formatted (exit 1 if not)`,
     },
     zh: {
         'parens.mismatch': "括号不匹配：{0} 个 '(' vs {1} 个 ')'（{2}）",
@@ -138,6 +164,7 @@ const messages = {
         error_handling: "使用 command 但缺少 *error* 的函数: '{0}'",
         global_naming: "全局变量 '{0}' 应使用 *...* 命名约定",
         extra_parens: '可疑的过多闭合括号：多余 {0} 个 )',
+        format_indent: '代码缩进不符合格式化规范',
         setq_single_arg: "变量 '{0}' 被 setq 但未赋值——可能是笔误",
         assoc_without_cdr: 'assoc 的结果未被使用——应使用 cdr 获取值',
         identical_branches: 'if 的 then 和 else 分支完全相同——可能是复制粘贴错误',
@@ -169,6 +196,31 @@ const messages = {
         'index.watching': '监听中',
         'index.watch_hint': '按 Ctrl+C 停止',
         'index.watch_status': '已检查 {0} 个文件: {1} 个错误, {2} 个警告',
+        'index.format_unstable': '格式化结果不稳定——再次格式化后输出不同',
+        'help.text': `@atlisp/lint - AutoLISP 静态分析工具
+
+用法: atlisp-lint [选项]
+
+选项:
+  --src <目录>            指定源代码目录（可重复）
+  --test <目录>           指定测试目录（可重复）
+  --config <路径>         配置文件路径
+  --staged                仅检查 git 暂存区的 .lsp 文件
+  --format <格式>         输出格式：default | json
+  --init                  在当前目录生成 atlisp-lint.json
+  --install-hook          安装 git pre-commit 钩子
+  --fix                   自动修复尾部空格、BOM、尾部括号等
+  --cache                 启用文件哈希缓存，跳过未变更的文件
+  --clear-cache           清除缓存目录
+  --parallel              启用多线程并行检查
+  --project               启用跨文件分析（Phase 1b）
+  --sbcl                  启用 SBCL 语法验证（Phase 2）
+  --watch                 监视模式：文件变更时重新检查
+  --hook-args <参数>      自定义 pre-commit 钩子参数（与 --install-hook 配合使用）
+  --help                  显示此帮助信息
+  --version               显示版本号
+  --format-code           自动格式化代码缩进
+  --format-check          检查文件是否已格式化（未格式化则退出码为 1）`,
     },
 };
 let currentLocale = 'zh';

package/dist/presets.js

@@ -141,6 +141,7 @@ exports.PRESETS = {
             dynamic_doc: 'error',
             loop_optimization: 'warn',
             type_check: 'warn',
+            format_indent: 'warn',
             redundant_if: 'error',
             module_registration: 'error',
             namespace_header: 'error',

package/dist/rules.js

@@ -82,6 +82,7 @@ exports.RULES = [
         category: '复杂度',
     },
     { name: 'function_order', defaultSeverity: 'off', description: '检测函数定义在使用之后', category: '风格' },
+    { name: 'format_indent', defaultSeverity: 'off', description: '检测代码缩进是否符合格式化规范', category: '风格' },
     {
         name: 'identical_branches',
         defaultSeverity: 'warn',

package/dist/runner.js

@@ -111,6 +111,7 @@ const dynamic_doc_1 = require("./checks/dynamic-doc");
 const loop_optimization_1 = require("./checks/loop-optimization");
 const type_check_1 = require("./checks/type-check");
 const redundant_if_1 = require("./checks/redundant-if");
+const format_indent_1 = require("./checks/format-indent");
 const config_1 = require("./config");
 const locale_1 = require("./locale");
 const disable_1 = require("./disable");
@@ -158,7 +159,7 @@ function runChecks(content, file, config) {
     }
     function addIfEnabled(rule, fn) {
         const severity = config.checks[rule];
-        if (severity === 'off')
+        if (!severity || severity === 'off')
             return;
         const results = fn();
         for (const r of results) {
@@ -234,6 +235,7 @@ function runChecks(content, file, config) {
     addIfEnabled('loop_optimization', () => (0, loop_optimization_1.checkLoopOptimization)(content, file));
     addIfEnabled('type_check', () => (0, type_check_1.checkTypeCheck)(content, file));
     addIfEnabled('redundant_if', () => (0, redundant_if_1.checkRedundantIf)(content, file));
+    addIfEnabled('format_indent', () => (0, format_indent_1.checkFormatIndent)(content, file));
     return issues;
 }
 /** Single-pass visitor-based runChecks using AstVisitor */
@@ -413,6 +415,47 @@ function lintFilesParallel(files, config, rootDir) {
             resolve([]);
     });
 }
+/** Find the matching close paren for the first complete form starting at `start` */
+function findMatchingParen(s, start) {
+    if (s[start] !== '(')
+        return start;
+    let depth = 0;
+    for (let i = start; i < s.length; i++) {
+        if (s[i] === '"') {
+            i++;
+            while (i < s.length && s[i] !== '"') {
+                if (s[i] === '\\')
+                    i++;
+                i++;
+            }
+            continue;
+        }
+        if (s[i] === '(')
+            depth++;
+        else if (s[i] === ')') {
+            depth--;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return s.length - 1;
+}
+/** Extract the next top-level form(s) from a string starting at `start`. Returns [form, endIdx]. */
+function extractForm(s, start) {
+    let i = start;
+    while (i < s.length && s[i] === ' ')
+        i++;
+    if (i >= s.length)
+        return ['', i];
+    if (s[i] !== '(') {
+        const m = s.slice(i).match(/^\S+/);
+        if (m)
+            return [m[0], i + m[0].length];
+        return ['', i];
+    }
+    const end = findMatchingParen(s, i);
+    return [s.slice(i, end + 1), end + 1];
+}
 function applyFixes(issues, content, filepath) {
     const lines = content.split('\n');
     const fixesByRule = new Map();
@@ -430,6 +473,11 @@ function applyFixes(issues, content, filepath) {
         'redundant_nil_else',
         'single_arg_and_or',
         'redundant_setq',
+        'redundant_progn',
+        'redundant_let',
+        'quote_style',
+        'redundant_if',
+        'misplaced_else',
     ]);
     let result = content;
     for (const [rule, lineSet] of fixesByRule) {
@@ -474,6 +522,88 @@ function applyFixes(issues, content, filepath) {
                     }
                     break;
                 }
+                case 'redundant_progn': {
+                    // (progn <single-form>) → <single-form>
+                    const proIdx = lineContent.indexOf('(progn ');
+                    if (proIdx !== -1) {
+                        const beforePro = lineContent.slice(0, proIdx);
+                        const close = findMatchingParen(lineContent, proIdx);
+                        if (close > proIdx) {
+                            const inner = lineContent.slice(proIdx + 7, close);
+                            const rest = lineContent.slice(close + 1);
+                            const fixed = beforePro + inner + rest;
+                            if (fixed !== lineContent)
+                                result = replaceLine(result, idx, fixed);
+                        }
+                    }
+                    break;
+                }
+                case 'redundant_let': {
+                    // (let () body...) → (progn body...)
+                    const fixed = lineContent.replace(/\(let\s+\(\)\s*/, '(progn ');
+                    if (fixed !== lineContent)
+                        result = replaceLine(result, idx, fixed);
+                    break;
+                }
+                case 'quote_style': {
+                    // (quote x) → 'x
+                    const qIdx = lineContent.indexOf('(quote ');
+                    if (qIdx !== -1) {
+                        const beforeQ = lineContent.slice(0, qIdx);
+                        const close = findMatchingParen(lineContent, qIdx);
+                        if (close > qIdx) {
+                            const quoted = lineContent.slice(qIdx + 7, close);
+                            const rest = lineContent.slice(close + 1);
+                            const fixed = beforeQ + "'" + quoted + rest;
+                            if (fixed !== lineContent)
+                                result = replaceLine(result, idx, fixed);
+                        }
+                    }
+                    break;
+                }
+                case 'redundant_if': {
+                    // (if/when/unless (progn ...) ...) → remove inner progn
+                    const pIdx = lineContent.indexOf('(progn ');
+                    if (pIdx !== -1) {
+                        const beforeP = lineContent.slice(0, pIdx);
+                        const close = findMatchingParen(lineContent, pIdx);
+                        if (close > pIdx) {
+                            const inner = lineContent.slice(pIdx + 7, close);
+                            const rest = lineContent.slice(close + 1);
+                            const fixed = beforeP + inner + rest;
+                            if (fixed !== lineContent)
+                                result = replaceLine(result, idx, fixed);
+                        }
+                    }
+                    break;
+                }
+                case 'misplaced_else': {
+                    // (if (not x) then else) → (if x else then)
+                    const ifStart = lineContent.indexOf('(if (not ');
+                    if (ifStart !== -1) {
+                        const notIdx = lineContent.indexOf('(not ', ifStart);
+                        if (notIdx === -1)
+                            break;
+                        const notClose = findMatchingParen(lineContent, notIdx);
+                        if (notClose <= notIdx)
+                            break;
+                        const ifClose = findMatchingParen(lineContent, ifStart);
+                        if (ifClose <= ifStart)
+                            break;
+                        const indent = lineContent.slice(0, ifStart);
+                        const condVar = lineContent.slice(notIdx + 5, notClose);
+                        const branchContent = lineContent.slice(notClose + 1, ifClose).trim();
+                        const [thenForm, thenEnd] = extractForm(branchContent, 0);
+                        const elseForm = branchContent.slice(thenEnd).trim();
+                        if (thenForm && elseForm) {
+                            const rest = lineContent.slice(ifClose + 1);
+                            const fixed = indent + '(if ' + condVar + ' ' + elseForm + ' ' + thenForm + ')' + rest;
+                            if (fixed !== lineContent)
+                                result = replaceLine(result, idx, fixed);
+                        }
+                    }
+                    break;
+                }
                 case 'redundant_setq': {
                     // Remove (setq x x) lines
                     const allLines = result.split('\n');

package/dist/validate.js

@@ -24,6 +24,7 @@ const VALID_RULES = [
     'eq_usage',
     'error_handling',
     'extra_parens',
+    'format_indent',
     'function_complexity',
     'function_order',
     'global_naming',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlisp/lint",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "AutoLISP static analysis tool — parens, security, conventions, SBCL syntax validation",
   "keywords": [
     "CAD",