@emeryld/manager 1.0.0 → 1.1.0

package/dist/format-checker/config.js

@@ -0,0 +1,63 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { rootDir } from '../helper-cli/env.js';
+export const REPORTING_MODES = ['group', 'file'];
+export const DEFAULT_LIMITS = {
+    maxFunctionLength: 120,
+    maxIndentationDepth: 6,
+    maxFunctionsPerFile: 16,
+    maxComponentsPerFile: 8,
+    maxFileLength: 500,
+    maxDuplicateLineOccurrences: 3,
+    minDuplicateLines: 3,
+    exportOnly: true,
+    indentationWidth: 2,
+    reportingMode: 'group',
+};
+const SETTINGS_SECTION = 'manager.formatChecker';
+const workspaceSettingsPath = path.join(rootDir, '.vscode', 'settings.json');
+function coerceNumber(value, fallback, options) {
+    const num = Number(value);
+    if (Number.isNaN(num))
+        return fallback;
+    if (options?.allowZero) {
+        return num < 0 ? fallback : Math.floor(num);
+    }
+    return num <= 0 ? fallback : Math.floor(num);
+}
+export async function loadFormatLimits() {
+    if (!existsSync(workspaceSettingsPath))
+        return DEFAULT_LIMITS;
+    try {
+        const raw = await readFile(workspaceSettingsPath, 'utf-8');
+        const json = JSON.parse(raw);
+        const settings = json[SETTINGS_SECTION];
+        if (!settings || typeof settings !== 'object')
+            return DEFAULT_LIMITS;
+        const settingsRecord = settings;
+        return {
+            maxFunctionLength: coerceNumber(settingsRecord.maxFunctionLength, DEFAULT_LIMITS.maxFunctionLength),
+            maxIndentationDepth: coerceNumber(settingsRecord.maxIndentationDepth, DEFAULT_LIMITS.maxIndentationDepth),
+            maxFunctionsPerFile: coerceNumber(settingsRecord.maxFunctionsPerFile, DEFAULT_LIMITS.maxFunctionsPerFile),
+            maxComponentsPerFile: coerceNumber(settingsRecord.maxComponentsPerFile, DEFAULT_LIMITS.maxComponentsPerFile),
+            maxFileLength: coerceNumber(settingsRecord.maxFileLength, DEFAULT_LIMITS.maxFileLength),
+            maxDuplicateLineOccurrences: coerceNumber(settingsRecord.maxDuplicateLineOccurrences, DEFAULT_LIMITS.maxDuplicateLineOccurrences),
+            minDuplicateLines: coerceNumber(settingsRecord.minDuplicateLines, DEFAULT_LIMITS.minDuplicateLines, { allowZero: true }),
+            exportOnly: Boolean(settingsRecord.exportOnly ?? DEFAULT_LIMITS.exportOnly),
+            indentationWidth: coerceNumber(settingsRecord.indentationWidth, DEFAULT_LIMITS.indentationWidth),
+            reportingMode: coerceReportingMode(settingsRecord.reportingMode, DEFAULT_LIMITS.reportingMode),
+        };
+    }
+    catch (error) {
+        return DEFAULT_LIMITS;
+    }
+}
+function coerceReportingMode(value, fallback) {
+    if (typeof value !== 'string')
+        return fallback;
+    if (REPORTING_MODES.includes(value)) {
+        return value;
+    }
+    return fallback;
+}

package/dist/format-checker/index.js

@@ -0,0 +1,38 @@
+import { colors } from '../utils/log.js';
+import { rootDir } from '../helper-cli/env.js';
+import { loadFormatLimits, } from './config.js';
+import { collectSourceFiles, analyzeFiles } from './scan/index.js';
+import { reportViolations } from './report.js';
+import { promptLimits } from './cli/prompts.js';
+import { parseScanCliArgs, printScanUsage } from './cli/options.js';
+export async function runFormatChecker() {
+    console.log(colors.cyan('Gathering defaults from .vscode/settings.json (manager.formatChecker)'));
+    const defaults = await loadFormatLimits();
+    const limits = await promptLimits(defaults);
+    await executeFormatCheck(limits);
+}
+export async function runFormatCheckerScanCli(argv) {
+    const { overrides, help } = parseScanCliArgs(argv);
+    if (help) {
+        printScanUsage();
+        return;
+    }
+    const defaults = await loadFormatLimits();
+    const limits = { ...defaults, ...overrides };
+    console.log(colors.cyan('Running format checker scan (machine-friendly)'));
+    await executeFormatCheck(limits);
+}
+async function executeFormatCheck(limits) {
+    console.log(colors.magenta('Scanning workspace for source files...'));
+    const files = await collectSourceFiles(rootDir);
+    if (files.length === 0) {
+        console.log(colors.yellow('No source files were found to analyze.'));
+        return;
+    }
+    console.log(colors.magenta(`Analyzing ${files.length} files`));
+    const violations = await analyzeFiles(files, limits);
+    const hadViolations = reportViolations(violations, limits.reportingMode);
+    if (!hadViolations) {
+        console.log(colors.green('Workspace meets the configured format limits.'));
+    }
+}

package/dist/format-checker/report.js

@@ -0,0 +1,115 @@
+import path from 'node:path';
+import { colors } from '../utils/log.js';
+import { rootDir } from '../helper-cli/env.js';
+const TYPE_LABELS = {
+    functionLength: 'Function length',
+    indentation: 'Indentation depth',
+    functionCount: 'Functions per file',
+    componentCount: 'Components per file',
+    fileLength: 'File length',
+    duplicateLine: 'Repeated code',
+};
+const TYPE_ORDER = [
+    'fileLength',
+    'functionLength',
+    'functionCount',
+    'componentCount',
+    'indentation',
+    'duplicateLine',
+];
+export function reportViolations(violations, reportingMode) {
+    if (violations.length === 0) {
+        console.log(colors.green('Format checker found no violations.'));
+        return false;
+    }
+    console.log(colors.bold('Format checker violations:'));
+    if (reportingMode === 'group') {
+        for (const type of TYPE_ORDER) {
+            const entries = violations.filter((violation) => violation.type === type);
+            if (!entries.length)
+                continue;
+            entries.sort((a, b) => b.severity - a.severity);
+            console.log(colors.bold(`- ${TYPE_LABELS[type]} (${entries.length})`));
+            for (const entry of entries) {
+                const relativePath = path.relative(rootDir, entry.file) || entry.file;
+                const isDuplicate = entry.type === 'duplicateLine';
+                const locationDescriptor = isDuplicate
+                    ? entry.line
+                        ? `${relativePath}:${entry.line}`
+                        : relativePath
+                    : entry.detail
+                        ? `${relativePath}:${entry.detail}`
+                        : entry.line
+                            ? `${relativePath}:${entry.line}`
+                            : relativePath;
+                logViolationEntry(entry, isDuplicate ? '    ' : '  ', isDuplicate ? undefined : locationDescriptor);
+                if (isDuplicate && entry.detail) {
+                    console.log(`    ${colors.dim('Places:')}`);
+                    entry.detail
+                        .split('\n')
+                        .filter(Boolean)
+                        .forEach((occurrence) => {
+                        console.log(`      ${colors.dim(occurrence)}`);
+                    });
+                }
+            }
+            console.log('');
+        }
+    }
+    else {
+        const violationsByFile = new Map();
+        for (const entry of violations) {
+            const bucket = violationsByFile.get(entry.file);
+            if (bucket) {
+                bucket.push(entry);
+            }
+            else {
+                violationsByFile.set(entry.file, [entry]);
+            }
+        }
+        const sortedFiles = [...violationsByFile.entries()].sort(([a], [b]) => a.localeCompare(b));
+        for (const [file, entries] of sortedFiles) {
+            const relativePath = path.relative(rootDir, file) || file;
+            console.log(colors.bold(relativePath));
+            const sortedEntries = [...entries].sort((a, b) => (a.line ?? 0) - (b.line ?? 0));
+            for (const entry of sortedEntries) {
+                const hasRangeDetail = entry.type !== 'duplicateLine' && Boolean(entry.detail);
+                const locationDescriptor = hasRangeDetail
+                    ? `${relativePath}:${entry.detail}`
+                    : entry.line
+                        ? `${relativePath}:${entry.line}`
+                        : relativePath;
+                if (entry.type === 'duplicateLine') {
+                    const occurrenceDescriptor = entry.line
+                        ? `${relativePath}:${entry.line}`
+                        : relativePath;
+                    logViolationEntry(entry, '  ', occurrenceDescriptor);
+                    if (entry.detail) {
+                        console.log(`    ${colors.dim('Places:')}`);
+                        entry.detail
+                            .split('\n')
+                            .filter(Boolean)
+                            .forEach((occurrence) => {
+                            console.log(`      ${colors.dim(occurrence)}`);
+                        });
+                    }
+                    continue;
+                }
+                logViolationEntry(entry, '  ', locationDescriptor);
+            }
+            console.log('');
+        }
+    }
+    return true;
+}
+function logViolationEntry(entry, messagePrefix, locationDescriptor) {
+    console.log(`${messagePrefix}${colors.yellow(`${entry.message} (severity ${entry.severity})`)}`);
+    if (entry.snippet) {
+        entry.snippet.split('\n').forEach((line) => {
+            console.log(`    ${colors.yellow(line)}`);
+        });
+    }
+    if (locationDescriptor) {
+        console.log(`    ${colors.dim(locationDescriptor)}`);
+    }
+}

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

@@ -0,0 +1,99 @@
+import { readFile } from 'node:fs/promises';
+import { collectDuplicateViolations, recordDuplicateLines, } from './duplicates.js';
+import { countIndentation, groupIndentationViolations, } from './indentation.js';
+import { collectFunctionRecords } from './functions.js';
+import { markImportLines, normalizeLine } from './utils.js';
+export async function analyzeFiles(files, limits) {
+    const violations = [];
+    const duplicateMap = new Map();
+    for (const file of files) {
+        violations.push(...(await analyzeSingleFile(file, limits, duplicateMap)));
+    }
+    violations.push(...collectDuplicateViolations(duplicateMap, limits));
+    return violations;
+}
+async function analyzeSingleFile(filePath, limits, duplicates) {
+    let content;
+    try {
+        content = await readFile(filePath, 'utf-8');
+    }
+    catch {
+        return [];
+    }
+    const lines = content.split(/\r?\n/);
+    const importFlags = markImportLines(lines);
+    const normalizedLines = lines.map((line, index) => ({
+        normalized: normalizeLine(line),
+        trimmed: line.trim(),
+        isImport: Boolean(importFlags[index]),
+        raw: line,
+    }));
+    const violations = [];
+    if (lines.length > limits.maxFileLength) {
+        violations.push({
+            type: 'fileLength',
+            file: filePath,
+            line: 1,
+            severity: lines.length - limits.maxFileLength,
+            message: `File has ${lines.length} lines (max ${limits.maxFileLength})`,
+        });
+    }
+    const indentationViolations = [];
+    lines.forEach((line, index) => {
+        const indent = countIndentation(line, limits.indentationWidth);
+        if (indent > limits.maxIndentationDepth) {
+            indentationViolations.push({ line: index + 1, indent });
+        }
+    });
+    recordDuplicateLines(normalizedLines, filePath, limits, duplicates);
+    const indentationGroups = groupIndentationViolations(indentationViolations, lines, limits.maxIndentationDepth);
+    indentationGroups
+        .sort((a, b) => b.severity - a.severity)
+        .slice(0, 4)
+        .forEach((group) => {
+        violations.push({
+            type: 'indentation',
+            file: filePath,
+            line: group.startLine,
+            severity: group.severity,
+            message: `Indentation level ${group.maxIndent} exceeds max ${limits.maxIndentationDepth}`,
+            snippet: group.snippet,
+            detail: `${group.startLine}:${group.startColumn}/${group.endLine}:${group.endColumn}`,
+        });
+    });
+    const allFunctions = collectFunctionRecords(content, filePath);
+    const functions = limits.exportOnly
+        ? allFunctions.filter((record) => record.isExported)
+        : allFunctions;
+    const componentCount = functions.filter((record) => record.isComponent).length;
+    if (componentCount > limits.maxComponentsPerFile) {
+        violations.push({
+            type: 'componentCount',
+            file: filePath,
+            line: functions.find((record) => record.isComponent)?.startLine,
+            severity: componentCount - limits.maxComponentsPerFile,
+            message: `Found ${componentCount} components (max ${limits.maxComponentsPerFile})`,
+        });
+    }
+    if (functions.length > limits.maxFunctionsPerFile) {
+        violations.push({
+            type: 'functionCount',
+            file: filePath,
+            line: functions[0]?.startLine,
+            severity: functions.length - limits.maxFunctionsPerFile,
+            message: `Contains ${functions.length} functions (max ${limits.maxFunctionsPerFile})`,
+        });
+    }
+    functions.forEach((record) => {
+        if (record.length > limits.maxFunctionLength) {
+            violations.push({
+                type: 'functionLength',
+                file: filePath,
+                line: record.startLine,
+                severity: record.length - limits.maxFunctionLength,
+                message: `Function ${record.name ?? '<anonymous>'} spans ${record.length} lines (max ${limits.maxFunctionLength})`,
+            });
+        }
+    });
+    return violations;
+}

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

@@ -0,0 +1,33 @@
+import { readdir } from 'node:fs/promises';
+import path from 'node:path';
+import { SOURCE_EXTENSIONS, IGNORED_DIRECTORIES } from './constants.js';
+export async function collectSourceFiles(root) {
+    const results = [];
+    await walk(root, results);
+    return results;
+}
+async function walk(directory, results) {
+    let entries;
+    try {
+        entries = await readdir(directory, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (entry.isSymbolicLink())
+            continue;
+        if (entry.isDirectory()) {
+            if (IGNORED_DIRECTORIES.has(entry.name))
+                continue;
+            await walk(path.join(directory, entry.name), results);
+            continue;
+        }
+        if (!entry.isFile())
+            continue;
+        const ext = path.extname(entry.name).toLowerCase();
+        if (!SOURCE_EXTENSIONS.has(ext))
+            continue;
+        results.push(path.join(directory, entry.name));
+    }
+}

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

@@ -0,0 +1,23 @@
+export const SOURCE_EXTENSIONS = new Set([
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.mts',
+    '.mjs',
+    '.cts',
+    '.cjs',
+]);
+export const IGNORED_DIRECTORIES = new Set([
+    '.git',
+    'node_modules',
+    'dist',
+    'bin',
+    '.turbo',
+    '.cache',
+    '.next',
+    'out',
+    '.pnpm',
+    '.idea',
+    '.vscode',
+]);

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

@@ -0,0 +1,108 @@
+import path from 'node:path';
+import { getLineColumnRange } from './utils.js';
+export function recordDuplicateLines(normalizedLines, filePath, limits, duplicates) {
+    const minLines = Math.max(1, limits.minDuplicateLines);
+    if (limits.minDuplicateLines <= 0 || minLines === 1) {
+        normalizedLines.forEach((entry, index) => {
+            if (!entry.normalized)
+                return;
+            const snippet = entry.trimmed.replace(/\s+/g, ' ');
+            if (!snippet)
+                return;
+            if (entry.isImport)
+                return;
+            const { startColumn, endColumn } = getLineColumnRange(entry.raw);
+            addDuplicateOccurrence(duplicates, entry.normalized, filePath, index + 1, startColumn, index + 1, endColumn, snippet);
+        });
+        return;
+    }
+    for (let i = 0; i + minLines <= normalizedLines.length; i += 1) {
+        const slice = normalizedLines.slice(i, i + minLines);
+        if (slice.some((entry) => !entry.normalized))
+            continue;
+        const key = slice.map((entry) => entry.normalized).join('\n');
+        const snippetLines = slice
+            .map((entry) => entry.trimmed)
+            .filter(Boolean);
+        if (!snippetLines.length)
+            continue;
+        if (slice.some((entry) => entry.isImport))
+            continue;
+        const snippet = snippetLines
+            .map((line) => line.replace(/\s+/g, ' '))
+            .join('\n');
+        if (!snippet)
+            continue;
+        const firstNonEmptyIndex = slice.findIndex((entry) => entry.trimmed.length > 0);
+        let lastNonEmptyIndex = -1;
+        for (let offset = slice.length - 1; offset >= 0; offset -= 1) {
+            if (slice[offset].trimmed.length > 0) {
+                lastNonEmptyIndex = offset;
+                break;
+            }
+        }
+        if (firstNonEmptyIndex === -1 || lastNonEmptyIndex === -1)
+            continue;
+        const startLine = i + 1 + firstNonEmptyIndex;
+        const endLine = i + 1 + lastNonEmptyIndex;
+        const { startColumn } = getLineColumnRange(slice[firstNonEmptyIndex].raw);
+        const { endColumn } = getLineColumnRange(slice[lastNonEmptyIndex].raw);
+        addDuplicateOccurrence(duplicates, key, filePath, startLine, startColumn, endLine, endColumn, snippet);
+    }
+}
+function addDuplicateOccurrence(duplicates, key, filePath, startLine, startColumn, endLine, endColumn, snippet) {
+    const tracker = duplicates.get(key);
+    if (tracker) {
+        tracker.count += 1;
+        if (tracker.occurrences.length < 6) {
+            tracker.occurrences.push({
+                file: filePath,
+                line: startLine,
+                startColumn,
+                endLine,
+                endColumn,
+                snippet,
+            });
+        }
+        return;
+    }
+    duplicates.set(key, {
+        count: 1,
+        snippet,
+        occurrences: [
+            {
+                file: filePath,
+                line: startLine,
+                startColumn,
+                endLine,
+                endColumn,
+                snippet,
+            },
+        ],
+    });
+}
+export function collectDuplicateViolations(duplicates, limits) {
+    const violations = [];
+    for (const tracker of duplicates.values()) {
+        if (tracker.count <= limits.maxDuplicateLineOccurrences)
+            continue;
+        if (tracker.occurrences.length === 0)
+            continue;
+        violations.push({
+            type: 'duplicateLine',
+            file: tracker.occurrences[0].file,
+            line: tracker.occurrences[0].line,
+            severity: tracker.count - limits.maxDuplicateLineOccurrences,
+            message: `Repeated ${tracker.count} times (max ${limits.maxDuplicateLineOccurrences})`,
+            detail: tracker.occurrences
+                .map((occurrence) => {
+                const relativePath = path.relative(process.cwd(), occurrence.file);
+                return `${relativePath}:${occurrence.line}:${occurrence.startColumn}/${occurrence.endLine}:${occurrence.endColumn}`;
+            })
+                .join('\n'),
+            snippet: tracker.snippet,
+            repeatCount: tracker.count,
+        });
+    }
+    return violations;
+}

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

@@ -0,0 +1,70 @@
+import * as ts from 'typescript';
+import { resolveScriptKind } from './utils.js';
+export function collectFunctionRecords(content, filePath) {
+    const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.ESNext, true, resolveScriptKind(filePath));
+    const records = [];
+    function visit(node) {
+        if ((ts.isFunctionDeclaration(node) ||
+            ts.isFunctionExpression(node) ||
+            ts.isArrowFunction(node) ||
+            ts.isMethodDeclaration(node)) &&
+            node.body) {
+            const start = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+            const end = sourceFile.getLineAndCharacterOfPosition(node.end);
+            const length = end.line - start.line + 1;
+            const name = resolveFunctionName(node);
+            const isComponent = typeof name === 'string' && isComponentFunction(node, name);
+            const isExported = ts.isExportDeclaration(node);
+            records.push({
+                name,
+                startLine: start.line + 1,
+                length,
+                isComponent,
+                isExported,
+            });
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return records;
+}
+function resolveFunctionName(node) {
+    if ('name' in node && node.name) {
+        const candidate = node.name;
+        if (ts.isIdentifier(candidate)) {
+            return candidate.text;
+        }
+    }
+    const parent = node.parent;
+    if (parent) {
+        if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
+            return parent.name.text;
+        }
+        if ((ts.isPropertyAssignment(parent) || ts.isPropertyDeclaration(parent)) &&
+            ts.isIdentifier(parent.name)) {
+            return parent.name.text;
+        }
+    }
+    return undefined;
+}
+function isComponentFunction(node, name) {
+    if (!/^[A-Z]/.test(name))
+        return false;
+    return containsJsx(node);
+}
+function containsJsx(node) {
+    let found = false;
+    function walk(child) {
+        if (child.kind === ts.SyntaxKind.JsxElement ||
+            child.kind === ts.SyntaxKind.JsxSelfClosingElement ||
+            child.kind === ts.SyntaxKind.JsxFragment) {
+            found = true;
+            return;
+        }
+        if (found)
+            return;
+        ts.forEachChild(child, walk);
+    }
+    ts.forEachChild(node, walk);
+    return found;
+}

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

@@ -0,0 +1,58 @@
+import { getLineColumnRange } from './utils.js';
+export function countIndentation(line, tabWidth) {
+    let indent = 0;
+    for (const char of line) {
+        if (char === ' ')
+            indent += 1;
+        else if (char === '\t')
+            indent += tabWidth;
+        else
+            break;
+    }
+    return indent / tabWidth;
+}
+export function groupIndentationViolations(violations, lines, maxDepth) {
+    if (!violations.length)
+        return [];
+    const sorted = [...violations].sort((a, b) => a.line - b.line);
+    const grouped = [];
+    let currentGroup = [];
+    let previousLine = -Infinity;
+    for (const violation of sorted) {
+        if (violation.line === previousLine + 1) {
+            currentGroup.push(violation);
+        }
+        else {
+            if (currentGroup.length) {
+                grouped.push(currentGroup);
+            }
+            currentGroup = [violation];
+        }
+        previousLine = violation.line;
+    }
+    if (currentGroup.length) {
+        grouped.push(currentGroup);
+    }
+    return grouped.map((group) => {
+        const startLine = group[0].line;
+        const endLine = group[group.length - 1].line;
+        const maxIndent = Math.max(...group.map((entry) => entry.indent));
+        const severity = Math.max(maxIndent - maxDepth, 0);
+        const contextStartLine = Math.max(1, startLine - 1);
+        const contextEndLine = Math.min(lines.length, endLine + 1);
+        const snippet = lines
+            .slice(contextStartLine - 1, contextEndLine)
+            .join('\n');
+        const { startColumn } = getLineColumnRange(lines[startLine - 1]);
+        const { endColumn } = getLineColumnRange(lines[endLine - 1]);
+        return {
+            startLine,
+            endLine,
+            startColumn,
+            endColumn,
+            maxIndent,
+            severity,
+            snippet,
+        };
+    });
+}

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

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

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,68 @@
+import path from 'node:path';
+import * as ts from 'typescript';
+export function normalizeLine(line) {
+    const trimmed = line.trim();
+    if (trimmed.length < 12)
+        return undefined;
+    const collapse = trimmed.replace(/\s+/g, ' ');
+    const noNumbers = collapse.replace(/\d+/g, '#');
+    return noNumbers.toLowerCase();
+}
+export function markImportLines(lines) {
+    const flags = new Array(lines.length).fill(false);
+    let insideImport = false;
+    let braceBalance = 0;
+    const importStart = /^(export\s+)?import\b/;
+    const fromLine = /^\}?\s*from\b/;
+    for (let index = 0; index < lines.length; index += 1) {
+        const trimmed = lines[index].trim();
+        const openBraces = (trimmed.match(/{/g) ?? []).length;
+        const closeBraces = (trimmed.match(/}/g) ?? []).length;
+        if (importStart.test(trimmed)) {
+            flags[index] = true;
+            braceBalance = openBraces - closeBraces;
+            insideImport = braceBalance > 0;
+            continue;
+        }
+        if (insideImport) {
+            flags[index] = true;
+            braceBalance += openBraces - closeBraces;
+            if (braceBalance <= 0) {
+                insideImport = false;
+                braceBalance = 0;
+            }
+            continue;
+        }
+        if (fromLine.test(trimmed)) {
+            flags[index] = true;
+        }
+    }
+    return flags;
+}
+export function getLineColumnRange(line) {
+    const leadingSpaceCount = line.length - line.trimStart().length;
+    const startColumn = leadingSpaceCount + 1;
+    const trimmedEndLength = line.trimEnd().length;
+    const endColumn = Math.max(trimmedEndLength, startColumn);
+    return { startColumn, endColumn };
+}
+export function resolveScriptKind(filePath) {
+    switch (path.extname(filePath).toLowerCase()) {
+        case '.ts':
+            return ts.ScriptKind.TS;
+        case '.tsx':
+            return ts.ScriptKind.TSX;
+        case '.mts':
+        case '.cts':
+            return ts.ScriptKind.TS;
+        case '.js':
+            return ts.ScriptKind.JS;
+        case '.jsx':
+            return ts.ScriptKind.JSX;
+        case '.mjs':
+        case '.cjs':
+            return ts.ScriptKind.JS;
+        default:
+            return ts.ScriptKind.Unknown;
+    }
+}