@emeryld/manager 1.4.14 → 1.5.0

package/dist/eslint-plugin-format-checker/index.js

@@ -0,0 +1,150 @@
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { DEFAULT_LIMITS } from '../format-checker/config.js';
+import { analyzeFileContent } from '../format-checker/scan/index.js';
+import { collectDuplicateViolations } from '../format-checker/scan/duplicates.js';
+function asPositiveInt(value, fallback) {
+    const num = Number(value);
+    if (!Number.isFinite(num))
+        return fallback;
+    const floored = Math.floor(num);
+    return floored <= 0 ? fallback : floored;
+}
+function asNonNegativeInt(value, fallback) {
+    const num = Number(value);
+    if (!Number.isFinite(num))
+        return fallback;
+    const floored = Math.floor(num);
+    return floored < 0 ? fallback : floored;
+}
+function buildLimits(rawOptions) {
+    const options = rawOptions && typeof rawOptions === 'object' ? rawOptions : {};
+    return {
+        ...BASE_LIMITS,
+        maxFunctionLength: asPositiveInt(options.maxFunctionLength, BASE_LIMITS.maxFunctionLength),
+        maxMethodLength: asPositiveInt(options.maxMethodLength, BASE_LIMITS.maxMethodLength),
+        maxIndentationDepth: asPositiveInt(options.maxIndentationDepth, BASE_LIMITS.maxIndentationDepth),
+        maxFunctionsPerFile: asPositiveInt(options.maxFunctionsPerFile, BASE_LIMITS.maxFunctionsPerFile),
+        maxComponentsPerFile: asPositiveInt(options.maxComponentsPerFile, BASE_LIMITS.maxComponentsPerFile),
+        maxFileLength: asPositiveInt(options.maxFileLength, BASE_LIMITS.maxFileLength),
+        maxDuplicateLineOccurrences: asPositiveInt(options.maxDuplicateLineOccurrences, BASE_LIMITS.maxDuplicateLineOccurrences),
+        minDuplicateLines: asNonNegativeInt(options.minDuplicateLines, BASE_LIMITS.minDuplicateLines),
+        exportOnly: typeof options.exportOnly === 'boolean'
+            ? options.exportOnly
+            : BASE_LIMITS.exportOnly,
+        indentationWidth: asPositiveInt(options.indentationWidth, BASE_LIMITS.indentationWidth),
+        reportingMode: BASE_LIMITS.reportingMode,
+    };
+}
+function loadWorkspaceDefaults() {
+    const settingsPath = path.join(process.cwd(), '.vscode', 'settings.json');
+    if (!existsSync(settingsPath))
+        return DEFAULT_LIMITS;
+    try {
+        const raw = readFileSync(settingsPath, 'utf-8');
+        const json = JSON.parse(raw);
+        const settings = json?.['manager.formatChecker'];
+        if (!settings || typeof settings !== 'object')
+            return DEFAULT_LIMITS;
+        return {
+            ...DEFAULT_LIMITS,
+            maxFunctionLength: asPositiveInt(settings.maxFunctionLength, DEFAULT_LIMITS.maxFunctionLength),
+            maxMethodLength: asPositiveInt(settings.maxMethodLength, DEFAULT_LIMITS.maxMethodLength),
+            maxIndentationDepth: asPositiveInt(settings.maxIndentationDepth, DEFAULT_LIMITS.maxIndentationDepth),
+            maxFunctionsPerFile: asPositiveInt(settings.maxFunctionsPerFile, DEFAULT_LIMITS.maxFunctionsPerFile),
+            maxComponentsPerFile: asPositiveInt(settings.maxComponentsPerFile, DEFAULT_LIMITS.maxComponentsPerFile),
+            maxFileLength: asPositiveInt(settings.maxFileLength, DEFAULT_LIMITS.maxFileLength),
+            maxDuplicateLineOccurrences: asPositiveInt(settings.maxDuplicateLineOccurrences, DEFAULT_LIMITS.maxDuplicateLineOccurrences),
+            minDuplicateLines: asNonNegativeInt(settings.minDuplicateLines, DEFAULT_LIMITS.minDuplicateLines),
+            exportOnly: typeof settings.exportOnly === 'boolean'
+                ? settings.exportOnly
+                : DEFAULT_LIMITS.exportOnly,
+            indentationWidth: asPositiveInt(settings.indentationWidth, DEFAULT_LIMITS.indentationWidth),
+        };
+    }
+    catch {
+        return DEFAULT_LIMITS;
+    }
+}
+const BASE_LIMITS = loadWorkspaceDefaults();
+function parseDetailRange(detail) {
+    if (typeof detail !== 'string')
+        return undefined;
+    const match = /^(\d+):(\d+)\/(\d+):(\d+)$/.exec(detail);
+    if (!match)
+        return undefined;
+    return {
+        startLine: Number(match[1]),
+        startColumn: Number(match[2]),
+        endLine: Number(match[3]),
+        endColumn: Number(match[4]),
+    };
+}
+function locFromViolation(violation) {
+    const parsed = parseDetailRange(violation.detail);
+    if (parsed) {
+        return {
+            start: { line: parsed.startLine, column: Math.max(0, parsed.startColumn - 1) },
+            end: { line: parsed.endLine, column: Math.max(0, parsed.endColumn - 1) },
+        };
+    }
+    const line = typeof violation.line === 'number' && violation.line > 0 ? violation.line : 1;
+    return {
+        start: { line, column: 0 },
+        end: { line, column: 0 },
+    };
+}
+const rule = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Runs @emeryld/manager format-checker heuristics as ESLint diagnostics.',
+        },
+        schema: [
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    maxFunctionLength: { type: 'integer', minimum: 1 },
+                    maxMethodLength: { type: 'integer', minimum: 1 },
+                    maxIndentationDepth: { type: 'integer', minimum: 1 },
+                    maxFunctionsPerFile: { type: 'integer', minimum: 1 },
+                    maxComponentsPerFile: { type: 'integer', minimum: 1 },
+                    maxFileLength: { type: 'integer', minimum: 1 },
+                    maxDuplicateLineOccurrences: { type: 'integer', minimum: 1 },
+                    minDuplicateLines: { type: 'integer', minimum: 0 },
+                    exportOnly: { type: 'boolean' },
+                    indentationWidth: { type: 'integer', minimum: 1 },
+                },
+            },
+        ],
+    },
+    create(context) {
+        const filename = context.getFilename?.() ?? '<text>';
+        if (!filename || filename === '<input>' || filename === '<text>')
+            return {};
+        if (filename.endsWith('.d.ts'))
+            return {};
+        const limits = buildLimits(context.options?.[0]);
+        return {
+            Program() {
+                const sourceCode = context.getSourceCode();
+                const duplicates = new Map();
+                const fileSnapshots = new Map();
+                const violations = analyzeFileContent(filename, sourceCode.text, limits, duplicates, fileSnapshots);
+                const duplicateViolations = collectDuplicateViolations(duplicates, limits, fileSnapshots);
+                for (const violation of [...violations, ...duplicateViolations]) {
+                    context.report({
+                        loc: locFromViolation(violation),
+                        message: `format-checker (${violation.type}): ${violation.message}`,
+                    });
+                }
+            },
+        };
+    },
+};
+export default {
+    rules: {
+        'format-checker': rule,
+    },
+};

package/dist/format-checker/scan/analysis.js

@@ -16,14 +16,7 @@ export async function analyzeFiles(files, limits) {
     violations.push(...collectDuplicateViolations(duplicateMap, limits, fileSnapshots));
     return violations;
 }
-async function analyzeSingleFile(filePath, limits, duplicates, fileSnapshots) {
-    let content;
-    try {
-        content = await readFile(filePath, 'utf-8');
-    }
-    catch {
-        return [];
-    }
+export function analyzeFileContent(filePath, content, limits, duplicates, fileSnapshots) {
     const lines = content.split(/\r?\n/);
     const importFlags = markImportLines(lines);
     const normalizedLines = lines.map((line, index) => ({
@@ -114,3 +107,13 @@ async function analyzeSingleFile(filePath, limits, duplicates, fileSnapshots) {
     });
     return violations;
 }
+async function analyzeSingleFile(filePath, limits, duplicates, fileSnapshots) {
+    let content;
+    try {
+        content = await readFile(filePath, 'utf-8');
+    }
+    catch {
+        return [];
+    }
+    return analyzeFileContent(filePath, content, limits, duplicates, fileSnapshots);
+}

package/dist/format-checker/scan/index.js

@@ -1,2 +1,3 @@
 export { collectSourceFiles } from './collect.js';
 export { analyzeFiles } from './analysis.js';
+export { analyzeFileContent } from './analysis.js';

package/dist/helper-cli/prompts.js

@@ -110,12 +110,28 @@ function formatInteractiveLines(state, selectedIndex, title, searchState) {
     return lines;
 }
 function renderInteractiveList(lines, previousLineCount) {
+    const columns = process.stdout.columns ?? 80;
+    const ansiRegex = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
+    const visibleLength = (text) => {
+        const clean = text.replace(ansiRegex, '');
+        let length = 0;
+        for (const ch of clean) {
+            const code = ch.codePointAt(0) ?? 0;
+            length += code > 0xffff ? 2 : 1;
+        }
+        return length;
+    };
+    const nextLineCount = lines.reduce((total, line) => {
+        const len = visibleLength(line);
+        const wrapped = Math.max(1, Math.ceil(len / columns));
+        return total + wrapped;
+    }, 0);
     if (previousLineCount > 0) {
         process.stdout.write(`\x1b[${previousLineCount}A`);
         process.stdout.write('\x1b[0J');
     }
     lines.forEach((line) => console.log(line));
-    return lines.length;
+    return nextLineCount;
 }
 export async function promptForScript(entries, title) {
     const supportsRawMode = typeof input.setRawMode === 'function' && input.isTTY;

package/dist/packages/manifest-utils.js

@@ -122,11 +122,6 @@ export function mergeManifestEntries(rootDir, inferred, overrides) {
             merged.push({ ...baseEntry, path: normalized });
         }
     }
-    normalizedOverrides.forEach((entry) => {
-        const name = entry.name || path.basename(entry.path) || 'package';
-        const color = entry.color ?? colorFromSeed(name);
-        merged.push({ name, path: entry.path, color });
-    });
     return merged;
 }
 export function colorFromSeed(seed) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@emeryld/manager",
-  "version": "1.4.14",
+  "version": "1.5.0",
   "description": "Interactive manager for pnpm monorepos (update/test/build/publish).",
   "license": "MIT",
   "type": "module",
@@ -23,13 +23,13 @@
     "node": ">=18"
   },
   "dependencies": {
-    "semver": "^7.7.3",
+    "semver": "^7.7.4",
     "ts-morph": "^27.0.2",
-    "ts-node": "^10.9.1",
-    "typescript": "^5.3.0"
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
   },
   "devDependencies": {
-    "@types/node": "^20.17.0",
+    "@types/node": "^20.19.33",
     "@types/semver": "^7.7.1",
     "cross-env": "^7.0.3"
   },