@atlisp/lint 0.1.5 → 0.1.6

package/dist/validate.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConfig = validateConfig;
+const VALID_RULES = [
+    'append_single',
+    'arg_count',
+    'assoc_without_cdr',
+    'bare_function_names',
+    'cl_syntax',
+    'command_shell',
+    'comment_style',
+    'commented_code',
+    'cond_simplify',
+    'cond_duplicate',
+    'constant_condition',
+    'dangling_defun',
+    'double_not',
+    'duplicate_defun',
+    'dynamic_doc',
+    'empty_branch',
+    'empty_catch',
+    'empty_comment',
+    'encoding',
+    'eq_usage',
+    'error_handling',
+    'extra_parens',
+    'function_complexity',
+    'function_order',
+    'global_naming',
+    'identical_branches',
+    'lambda_syntax',
+    'line_length',
+    'long_function_call',
+    'loop_optimization',
+    'magic_number',
+    'misplaced_else',
+    'missing_doc',
+    'missing_export',
+    'mixed_indent',
+    'module_registration',
+    'multiple_setq',
+    'namespace_header',
+    'no_return',
+    'nth_usage',
+    'open_without_close',
+    'parameter_naming',
+    'parens',
+    'quit_exit',
+    'quote_style',
+    'quote_vs_function',
+    'recursive_call',
+    'redundant_cond',
+    'redundant_if',
+    'redundant_let',
+    'redundant_nil_else',
+    'redundant_progn',
+    'redundant_quotes',
+    'redundant_setq',
+    'self_compare',
+    'setq_multiple',
+    'setq_single_arg',
+    'shadow_builtin',
+    'single_arg_and_or',
+    'startapp',
+    'strcat_usage',
+    'token_in_url',
+    'trailing_paren',
+    'trailing_whitespace',
+    'type_check',
+    'unused_let_binding',
+    'unused_local_fun',
+    'unused_package_dep',
+    'unused_parameter',
+    'unused_variable',
+    'variable_shadow',
+    'while_constant',
+    'vl_registry_write',
+    'vlax_without_loading',
+];
+const VALID_SEVERITIES = ['off', 'warn', 'error'];
+function validateConfig(config) {
+    const errors = [];
+    if (config.locale && config.locale !== 'zh' && config.locale !== 'en') {
+        errors.push({ path: 'locale', message: `Invalid locale '${config.locale}', expected 'zh' or 'en'` });
+    }
+    if (config.checks) {
+        for (const [rule, sev] of Object.entries(config.checks)) {
+            if (!VALID_RULES.includes(rule)) {
+                errors.push({ path: `checks.${rule}`, message: `Unknown rule '${rule}'` });
+            }
+            if (!VALID_SEVERITIES.includes(sev)) {
+                errors.push({
+                    path: `checks.${rule}`,
+                    message: `Invalid severity '${sev}', expected 'off', 'warn', or 'error'`,
+                });
+            }
+        }
+    }
+    if (config.source) {
+        if (!Array.isArray(config.source.globs)) {
+            errors.push({ path: 'source.globs', message: 'Must be an array of glob patterns' });
+        }
+        if (!Array.isArray(config.source.exclude)) {
+            errors.push({ path: 'source.exclude', message: 'Must be an array of glob patterns' });
+        }
+    }
+    if (config.line_length) {
+        if (typeof config.line_length.max !== 'number' || config.line_length.max < 1) {
+            errors.push({ path: 'line_length.max', message: 'Must be a positive number' });
+        }
+        if (typeof config.line_length.tab_width !== 'number' || config.line_length.tab_width < 1) {
+            errors.push({ path: 'line_length.tab_width', message: 'Must be a positive number' });
+        }
+    }
+    if (config.function_complexity) {
+        if (typeof config.function_complexity.max_lines !== 'number' || config.function_complexity.max_lines < 1) {
+            errors.push({ path: 'function_complexity.max_lines', message: 'Must be a positive number' });
+        }
+        if (typeof config.function_complexity.max_nesting !== 'number' || config.function_complexity.max_nesting < 1) {
+            errors.push({ path: 'function_complexity.max_nesting', message: 'Must be a positive number' });
+        }
+    }
+    return errors;
+}
+//# sourceMappingURL=validate.js.map

package/dist/watch.d.ts

@@ -0,0 +1,9 @@
+import { LintConfig } from './types';
+interface WatchOptions {
+    rootDir: string;
+    format: 'default' | 'json';
+    config: LintConfig;
+}
+export declare function watchFiles(files: string[], options: WatchOptions): void;
+export {};
+//# sourceMappingURL=watch.d.ts.map

package/dist/watch.js

@@ -0,0 +1,113 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watchFiles = watchFiles;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runner_1 = require("./runner");
+const formatters_1 = require("./formatters");
+const locale_1 = require("./locale");
+function watchFiles(files, options) {
+    const { rootDir, format, config } = options;
+    (0, locale_1.setLocale)(config.locale || 'zh');
+    // Initial lint
+    runLint(files, rootDir, format, config);
+    // Watch all files for changes
+    const watchers = [];
+    const watchedDirs = new Set();
+    for (const f of files) {
+        const dir = path.dirname(f);
+        if (!watchedDirs.has(dir)) {
+            watchedDirs.add(dir);
+            try {
+                const watcher = fs.watch(dir, (eventType, filename) => {
+                    if (!filename)
+                        return;
+                    const fullPath = path.join(dir, filename);
+                    if (files.includes(fullPath)) {
+                        // Debounce: wait a bit for the file to finish writing
+                        setTimeout(() => {
+                            runLint(files, rootDir, format, config);
+                        }, 200);
+                    }
+                });
+                watchers.push(watcher);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    }
+    console.log(`\n${(0, locale_1.t)('index.watching')} (${files.length} files)`);
+    console.log((0, locale_1.t)('index.watch_hint'));
+    // Cleanup on exit
+    process.on('SIGINT', () => {
+        for (const w of watchers)
+            w.close();
+        process.exit(0);
+    });
+    process.on('SIGTERM', () => {
+        for (const w of watchers)
+            w.close();
+        process.exit(0);
+    });
+}
+function runLint(files, rootDir, format, config) {
+    // Clear console
+    process.stdout.write('\x1Bc');
+    const issues = (0, runner_1.lintFiles)(files, config, rootDir);
+    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'));
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    }
+    if (format === 'json') {
+        console.log((0, formatters_1.formatJson)(issues));
+    }
+    else {
+        console.log((0, formatters_1.formatDefault)(issues, fileContents));
+    }
+    const errorCount = issues.filter(i => i.severity === 'error').length;
+    const warningCount = issues.filter(i => i.severity === 'warn').length;
+    console.log(`\n[${new Date().toLocaleTimeString()}] ${(0, locale_1.t)('index.watch_status', files.length, errorCount, warningCount)}`);
+}
+//# sourceMappingURL=watch.js.map

package/package.json

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