@atlisp/lint 0.2.16 → 0.2.18

package/dist/formatter.d.ts

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

package/dist/formatter.js

@@ -1,15 +1,109 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatCode = formatCode;
-exports.formatCodeStable = formatCodeStable;
 const utils_1 = require("./utils");
+const parser_1 = require("@atlisp/parser");
 function isCommentLine(line) {
     const trimmed = line.trim();
     return trimmed.startsWith(';') || trimmed.startsWith(';|');
 }
+function findMultiPairSetq(content) {
+    try {
+        const ast = (0, parser_1.parseAst)(content, { errorRecovery: true });
+        if (!ast)
+            return [];
+        const ranges = [];
+        for (const node of (0, parser_1.astWalk)(ast)) {
+            if (!(0, parser_1.astIsList)(node))
+                continue;
+            const children = node.children;
+            if (children.length < 6)
+                continue;
+            const first = children[0];
+            if (!(0, parser_1.astIsSymbol)(first) || first.name.toLowerCase() !== 'setq')
+                continue;
+            const start = node.pos.offset;
+            const end = node.end?.offset ?? start;
+            const startLine = content.substring(0, start).split('\n').length - 1;
+            const endLine = content.substring(0, end).split('\n').length - 1;
+            ranges.push({ startLine, endLine, startOffset: start, endOffset: end });
+        }
+        return ranges;
+    }
+    catch {
+        return [];
+    }
+}
+function formatSetqFromNode(node, depth, indentSize, content) {
+    const children = node.children;
+    const pairs = [];
+    for (let i = 1; i + 1 < children.length; i += 2) {
+        const varNode = children[i];
+        const valNode = children[i + 1];
+        let varText;
+        if ((0, parser_1.astIsSymbol)(varNode)) {
+            varText = varNode.name;
+        }
+        else {
+            const vs = varNode.pos.offset;
+            const ve = varNode.end?.offset ?? vs;
+            varText = content.slice(vs, ve);
+        }
+        const vs = valNode.pos.offset;
+        const ve = valNode.end?.offset ?? vs;
+        const valText = content.slice(vs, ve);
+        pairs.push({ varText, valText });
+    }
+    if (pairs.length < 2) {
+        const indent = ' '.repeat(depth * indentSize);
+        return [indent + '(setq ' + pairs.map(p => p.varText + ' ' + p.valText).join(' ') + ')'];
+    }
+    const maxVarLen = Math.max(...pairs.map(p => p.varText.length));
+    const baseIndent = ' '.repeat(depth * indentSize);
+    const setqPrefix = '(setq ';
+    const varColumn = depth * indentSize + setqPrefix.length;
+    const lines = [];
+    lines.push(baseIndent + setqPrefix + pairs[0].varText + ' ' + pairs[0].valText);
+    const continuationIndent = ' '.repeat(varColumn);
+    for (let i = 1; i < pairs.length; i++) {
+        const padding = maxVarLen - pairs[i].varText.length;
+        const isLast = i === pairs.length - 1;
+        lines.push(continuationIndent + pairs[i].varText + ' '.repeat(padding + 1) + pairs[i].valText + (isLast ? ')' : ''));
+    }
+    return lines;
+}
+function runStandardFormat(lines, lineIdx, depth, _indentSize, rawLine, trimmed) {
+    const isComment = isCommentLine(trimmed);
+    const stripped = (0, utils_1.stripLine)(trimmed);
+    const trimmedStripped = stripped.trim();
+    if (trimmedStripped === '') {
+        return {
+            formattedLines: [' '.repeat(depth * _indentSize) + trimmed.trimStart()],
+            newDepth: depth
+        };
+    }
+    const opens = (trimmedStripped.match(/\(/g) || []).length;
+    const closes = (trimmedStripped.match(/\)/g) || []).length;
+    let leadingCloseCount = 0;
+    for (const ch of trimmedStripped) {
+        if (ch === ')')
+            leadingCloseCount++;
+        else
+            break;
+    }
+    let effectiveDepth = depth;
+    if (leadingCloseCount > 0) {
+        effectiveDepth = Math.max(0, depth - leadingCloseCount);
+    }
+    return {
+        formattedLines: [' '.repeat(effectiveDepth * _indentSize) + trimmed.trimStart()],
+        newDepth: depth + opens - closes
+    };
+}
 function formatCode(content, indentSize = 2) {
     if (content === '' || content === '\n')
         return content;
+    const setqRanges = findMultiPairSetq(content);
     const lines = content.split('\n');
     const result = [];
     let depth = 0;
@@ -20,33 +114,54 @@ function formatCode(content, indentSize = 2) {
             result.push('');
             continue;
         }
-        const isComment = isCommentLine(trimmed);
-        const stripped = (0, utils_1.stripLine)(trimmed);
-        const trimmedStripped = stripped.trim();
-        if (trimmedStripped === '' && isComment) {
-            result.push(' '.repeat(depth * indentSize) + trimmed.trimStart());
+        const sqRange = setqRanges.find(sq => sq.startLine === lineIdx);
+        if (sqRange) {
+            const setqText = content.slice(sqRange.startOffset, sqRange.endOffset);
+            const ast = (0, parser_1.parseAst)(setqText, { errorRecovery: true });
+            let sqNode;
+            if (ast) {
+                for (const n of (0, parser_1.astWalk)(ast)) {
+                    if ((0, parser_1.astIsList)(n)) {
+                        const f = n.children[0];
+                        if ((0, parser_1.astIsSymbol)(f) && f.name.toLowerCase() === 'setq') {
+                            sqNode = n;
+                            break;
+                        }
+                    }
+                }
+            }
+            if (sqNode && (0, parser_1.astIsList)(sqNode)) {
+                const formattedLines = formatSetqFromNode(sqNode, depth, indentSize, setqText);
+                result.push(...formattedLines);
+            }
+            else {
+                const indent = ' '.repeat(depth * indentSize);
+                result.push(indent + trimmed.trimStart());
+            }
+            // Emit any trailing content after setq's end on the same line (e.g., extra ))
+            const afterSetqText = content.slice(sqRange.endOffset);
+            const afterSetqLine = afterSetqText.split('\n')[0];
+            if (afterSetqLine.trim()) {
+                const sAfter = (0, utils_1.stripLine)(afterSetqLine);
+                const tAfter = sAfter.trim();
+                if (tAfter) {
+                    const opensAfter = (tAfter.match(/\(/g) || []).length;
+                    const closesAfter = (tAfter.match(/\)/g) || []).length;
+                    depth += opensAfter - closesAfter;
+                    if (depth < 0)
+                        depth = 0;
+                    const leadingCloseCount = (tAfter.match(/^\)+/g) || [''])[0].length;
+                    const outdent = depth - leadingCloseCount + (opensAfter - closesAfter);
+                    const effectiveDepth = Math.max(0, depth - leadingCloseCount + (opensAfter - closesAfter));
+                    result.push(' '.repeat(effectiveDepth * indentSize) + afterSetqLine.trim());
+                }
+            }
+            lineIdx = sqRange.endLine;
             continue;
         }
-        if (trimmedStripped === '') {
-            result.push(' '.repeat(depth * indentSize) + trimmed.trimStart());
-            continue;
-        }
-        const opens = (trimmedStripped.match(/\(/g) || []).length;
-        const closes = (trimmedStripped.match(/\)/g) || []).length;
-        let leadingCloseCount = 0;
-        for (const ch of trimmedStripped) {
-            if (ch === ')')
-                leadingCloseCount++;
-            else
-                break;
-        }
-        let effectiveDepth = depth;
-        if (leadingCloseCount > 0) {
-            effectiveDepth = Math.max(0, depth - leadingCloseCount);
-        }
-        const indent = ' '.repeat(effectiveDepth * indentSize);
-        result.push(indent + trimmed.trimStart());
-        depth += opens - closes;
+        const { formattedLines, newDepth } = runStandardFormat(lines, lineIdx, depth, indentSize, rawLine, trimmed);
+        result.push(...formattedLines);
+        depth = newDepth;
         if (depth < 0)
             depth = 0;
     }
@@ -56,9 +171,4 @@ function formatCode(content, indentSize = 2) {
     }
     return output;
 }
-function formatCodeStable(content, indentSize = 2) {
-    const first = formatCode(content, indentSize);
-    const second = formatCode(first, indentSize);
-    return second;
-}
 //# sourceMappingURL=formatter.js.map

package/dist/index.js

@@ -215,7 +215,7 @@ async function main() {
             if (!opts.staged)
                 return;
         }
-        // Filter cached files (pre-read content to avoid double I/O)
+        // Filter cached files (pre-read content to avoid double I/O for linting and display)
         const contentCache = new Map();
         const filesToLint = opts.cache
             ? files.filter(f => {
@@ -234,70 +234,67 @@ async function main() {
                 }
                 return !cached;
             })
-            : files;
+            : files.filter(f => {
+                try {
+                    const content = fs.readFileSync(f, 'utf-8');
+                    contentCache.set(f, content);
+                }
+                catch {
+                    /* ignore */
+                }
+                return true;
+            });
         if (filesToLint.length === 0) {
             console.log((0, locale_1.t)('index.all_cached'));
             return;
         }
         // Phase 1: Static checks (parallel or sequential)
-        const contentArg = opts.cache && contentCache.size > 0 ? contentCache : undefined;
+        const contentArg = contentCache.size > 0 ? contentCache : undefined;
         const issues = opts.parallel
-            ? await (0, runner_1.lintFilesParallel)(filesToLint, config, rootDir)
+            ? await (0, runner_1.lintFilesParallel)(filesToLint, config, rootDir, contentArg)
             : (0, runner_1.lintFiles)(filesToLint, config, rootDir, contentArg);
         // Phase 1b: Project-level cross-file checks
         if (opts.project) {
-            const projectIssues = (0, project_1.lintProject)(filesToLint, config, rootDir);
+            const projectIssues = await (0, project_1.lintProject)(filesToLint, config, rootDir);
             issues.push(...projectIssues);
         }
-        // Apply rule-based fixes (after lint, when --fix is set)
+        // Apply rule-based fixes + format_indent (merged single pass, when --fix is set)
         if (opts.fix) {
+            const indentSize = config.line_length.tab_width;
+            const formatEnabled = config.checks['format_indent'] !== 'off';
             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) {
-                            if (opts.dryRun) {
-                                console.log(`${(0, locale_1.t)('summary.tag_info')}: ${relPath} — would apply ${fileIssues.length} fix(es)`);
-                            }
-                            else {
-                                fs.writeFileSync(f, fixed, 'utf-8');
-                                console.log(`${(0, locale_1.t)('summary.tag_fail')}: ${relPath} — ${(0, locale_1.t)('index.fixed')}`);
-                            }
-                        }
-                    }
-                    catch (e) {
-                        console.warn(`[lint] applyFixes failed for ${relPath}: ${e instanceof Error ? e.message : String(e)}`);
+                const hasFormatIssue = formatEnabled && issues.some(i => i.file === relPath && i.rule === 'format_indent');
+                if (fileIssues.length === 0 && !hasFormatIssue)
+                    continue;
+                try {
+                    const content = fs.readFileSync(f, 'utf-8');
+                    let changed = content;
+                    if (fileIssues.length > 0) {
+                        changed = (0, runner_1.applyFixes)(fileIssues, changed, relPath);
                     }
-                }
-            }
-            // format_indent fix: apply formatCode to files with format_indent issues
-            if (config.checks['format_indent'] !== 'off') {
-                const indentSize = config.line_length.tab_width;
-                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, indentSize);
-                            if (formatted !== content) {
-                                if (opts.dryRun) {
-                                    console.log(`${(0, locale_1.t)('summary.tag_info')}: ${relPath} — would fix format_indent`);
-                                }
-                                else {
-                                    fs.writeFileSync(f, formatted, 'utf-8');
-                                    console.log(`${(0, locale_1.t)('summary.tag_fail')}: ${relPath} — ${(0, locale_1.t)('index.fixed', 'format_indent')}`);
-                                }
-                            }
+                        changed = (0, formatter_1.formatCode)(changed, indentSize);
+                    }
+                    if (changed !== content) {
+                        if (opts.dryRun) {
+                            const parts = [];
+                            if (fileIssues.length > 0)
+                                parts.push(`would apply ${fileIssues.length} fix(es)`);
+                            if (hasFormatIssue)
+                                parts.push('would fix format_indent');
+                            console.log(`${(0, locale_1.t)('summary.tag_info')}: ${relPath} — ${parts.join('; ')}`);
                         }
-                        catch (e) {
-                            console.warn(`[lint] format_indent fix failed for ${relPath}: ${e instanceof Error ? e.message : String(e)}`);
+                        else {
+                            fs.writeFileSync(f, changed, 'utf-8');
+                            console.log(`${(0, locale_1.t)('summary.tag_fail')}: ${relPath} — ${(0, locale_1.t)('index.fixed')}`);
                         }
                     }
                 }
+                catch (e) {
+                    console.warn(`[lint] fix failed for ${relPath}: ${e instanceof Error ? e.message : String(e)}`);
+                }
             }
         }
         // Mark as cached
@@ -324,22 +321,33 @@ async function main() {
                 });
             }
         }
-        // Build file content map for code line display
+        // Build file content map for code line display (reuse pre-read content)
         const fileContents = new Map();
         for (const iss of issues) {
             if (!fileContents.has(iss.file)) {
                 const fp = path.resolve(rootDir, iss.file);
-                try {
-                    fileContents.set(iss.file, fs.readFileSync(fp, 'utf-8'));
+                const cached = contentCache.get(fp);
+                if (cached !== undefined) {
+                    fileContents.set(iss.file, cached);
                 }
-                catch (e) {
-                    console.warn(`[lint] failed to read ${fp} for display: ${e instanceof Error ? e.message : String(e)}`);
+                else {
+                    try {
+                        fileContents.set(iss.file, fs.readFileSync(fp, 'utf-8'));
+                    }
+                    catch (e) {
+                        console.warn(`[lint] failed to read ${fp} for display: ${e instanceof Error ? e.message : String(e)}`);
+                    }
                 }
             }
         }
         // Format & output
-        const errorCount = issues.filter(i => i.severity === 'error').length;
-        const warningCount = issues.filter(i => i.severity === 'warn').length;
+        let errorCount = 0, warningCount = 0;
+        for (const i of issues) {
+            if (i.severity === 'error')
+                errorCount++;
+            else if (i.severity === 'warn')
+                warningCount++;
+        }
         if (opts.format === 'json') {
             console.log((0, formatters_1.formatJson)(issues, errorCount, warningCount));
         }

package/dist/project.d.ts

@@ -1,3 +1,3 @@
 import { Issue, LintConfig } from './types';
-export declare function lintProject(files: string[], config: LintConfig, rootDir: string): Issue[];
+export declare function lintProject(files: string[], config: LintConfig, rootDir: string): Promise<Issue[]>;
 //# sourceMappingURL=project.d.ts.map