erosolar-cli 1.7.55 → 1.7.57

package/dist/bin/tools/codeQualityTools.js

@@ -1,294 +0,0 @@
-import { exec } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { promisify } from 'node:util';
-import { analyzeTypeScriptFile, performAdvancedAstAnalysis } from './codeAnalysisTools.js';
-const execAsync = promisify(exec);
-const LINT_CONFIG_CANDIDATES = [
-    'eslint.config.js',
-    'eslint.config.cjs',
-    'eslint.config.mjs',
-    'eslint.config.json',
-    '.eslintrc',
-    '.eslintrc.json',
-    '.eslintrc.cjs',
-    '.eslintrc.js',
-    '.eslintrc.yml',
-    '.eslintrc.yaml',
-];
-export function createCodeQualityTools(workingDir) {
-    return [
-        {
-            name: 'run_lint_checks',
-            description: 'Run ESLint (or npm run lint) with optional pattern targeting and auto-fix support.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    pattern: {
-                        type: 'string',
-                        description: 'Optional file/glob pattern to pass to the linter.',
-                    },
-                    fix: {
-                        type: 'boolean',
-                        description: 'Apply automatic fixes when supported.',
-                    },
-                    timeout: {
-                        type: 'number',
-                        description: 'Command timeout in milliseconds (default: 120000).',
-                    },
-                },
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const rawPattern = args['pattern'];
-                const pattern = typeof rawPattern === 'string' && rawPattern.trim() ? rawPattern.trim() : null;
-                const fix = args['fix'] === true;
-                const timeout = typeof args['timeout'] === 'number' && Number.isFinite(args['timeout']) && args['timeout'] > 0
-                    ? args['timeout']
-                    : 120000;
-                try {
-                    const packageJsonPath = join(workingDir, 'package.json');
-                    if (!existsSync(packageJsonPath)) {
-                        return 'Error: package.json not found. Cannot determine lint command.';
-                    }
-                    const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-                    let command;
-                    if (pkg.scripts?.['lint']) {
-                        const extras = [];
-                        if (pattern) {
-                            extras.push(pattern);
-                        }
-                        if (fix) {
-                            extras.push('--fix');
-                        }
-                        command = 'npm run lint';
-                        if (extras.length > 0) {
-                            command += ` -- ${extras.map(shellEscape).join(' ')}`;
-                        }
-                    }
-                    else {
-                        const target = pattern ?? '.';
-                        command = `npx eslint ${shellEscape(target)} --ext .ts,.tsx,.js,.jsx`;
-                        if (fix) {
-                            command += ' --fix';
-                        }
-                    }
-                    const { stdout, stderr } = await execAsync(command, {
-                        cwd: workingDir,
-                        timeout,
-                        maxBuffer: 1024 * 1024 * 10,
-                    });
-                    let result = `Lint command: ${command}\n\n`;
-                    if (stdout)
-                        result += `stdout:\n${stdout}\n`;
-                    if (stderr)
-                        result += `stderr:\n${stderr}\n`;
-                    return result || 'Lint run completed (no output).';
-                }
-                catch (error) {
-                    const stdout = error.stdout ?? '';
-                    const stderr = error.stderr ?? '';
-                    if (error.killed) {
-                        return `Error: lint command timed out after ${timeout}ms`;
-                    }
-                    return `Error running lint command: ${error.message}\nstdout: ${stdout}\nstderr: ${stderr}`;
-                }
-            },
-        },
-        {
-            name: 'inspect_code_quality',
-            description: 'Generate a maintainability report (function complexity, TODO density, comment coverage) for a file.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    path: {
-                        type: 'string',
-                        description: 'Path to the TypeScript/JavaScript file to inspect.',
-                    },
-                },
-                required: ['path'],
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                try {
-                    const filePath = resolveFilePath(workingDir, args['path']);
-                    if (!existsSync(filePath)) {
-                        return `Error: File not found: ${filePath}`;
-                    }
-                    const content = readFileSync(filePath, 'utf-8');
-                    const analysis = analyzeTypeScriptFile(content, filePath);
-                    const ast = performAdvancedAstAnalysis(content, filePath);
-                    return formatQualityReport(content, analysis, ast);
-                }
-                catch (error) {
-                    return `Error analyzing code quality: ${error instanceof Error ? error.message : String(error)}`;
-                }
-            },
-        },
-        {
-            name: 'list_lint_rules',
-            description: 'Summarize the ESLint configuration and active rules.',
-            parameters: {
-                type: 'object',
-                properties: {},
-                additionalProperties: false,
-            },
-            handler: async () => {
-                try {
-                    const configInfo = await loadLintConfig(workingDir);
-                    if (!configInfo) {
-                        return 'No ESLint configuration found (package.json eslintConfig or .eslintrc/eslint.config.*).';
-                    }
-                    const rules = extractLintRules(configInfo.config);
-                    if (Object.keys(rules).length === 0) {
-                        return `ESLint configuration "${configInfo.source}" found, but no rules were declared.`;
-                    }
-                    return formatLintRules(configInfo.source, rules);
-                }
-                catch (error) {
-                    return `Error reading ESLint configuration: ${error instanceof Error ? error.message : String(error)}`;
-                }
-            },
-        },
-    ];
-}
-function resolveFilePath(workingDir, path) {
-    const value = validatePathArg(path);
-    return value.startsWith('/') ? value : join(workingDir, value);
-}
-function validatePathArg(path) {
-    if (typeof path !== 'string' || !path.trim()) {
-        throw new Error('Path must be a non-empty string.');
-    }
-    return path.trim();
-}
-function shellEscape(value) {
-    if (!value) {
-        return "''";
-    }
-    return `'${value.replace(/'/g, `'\\''`)}'`;
-}
-async function loadLintConfig(workingDir) {
-    const packageJsonPath = join(workingDir, 'package.json');
-    if (existsSync(packageJsonPath)) {
-        const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-        if (pkg.eslintConfig) {
-            return {
-                config: pkg.eslintConfig,
-                source: 'package.json eslintConfig',
-            };
-        }
-    }
-    for (const relativePath of LINT_CONFIG_CANDIDATES) {
-        const absolute = join(workingDir, relativePath);
-        if (!existsSync(absolute)) {
-            continue;
-        }
-        if (relativePath.endsWith('.json') || relativePath === '.eslintrc') {
-            const config = JSON.parse(readFileSync(absolute, 'utf-8'));
-            return { config, source: relativePath };
-        }
-        if (relativePath.endsWith('.js') || relativePath.endsWith('.cjs') || relativePath.endsWith('.mjs')) {
-            const module = await import(pathToFileURL(absolute).href);
-            const config = module.default ?? module;
-            return { config, source: relativePath };
-        }
-    }
-    return null;
-}
-function extractLintRules(config) {
-    if (!config) {
-        return {};
-    }
-    if (Array.isArray(config)) {
-        return config.reduce((acc, entry) => {
-            if (entry && typeof entry === 'object' && 'rules' in entry && typeof entry.rules === 'object') {
-                Object.assign(acc, entry.rules);
-            }
-            return acc;
-        }, {});
-    }
-    if (typeof config === 'object' && 'rules' in config && typeof config.rules === 'object') {
-        return { ...config.rules };
-    }
-    return {};
-}
-function formatLintRules(source, rules) {
-    const output = [];
-    output.push(`# ESLint rules (${source})`);
-    output.push('');
-    const entries = Object.entries(rules).sort(([a], [b]) => a.localeCompare(b));
-    for (const [rule, setting] of entries) {
-        const normalized = normalizeRuleSetting(setting);
-        output.push(`- **${rule}** → ${normalized.level}${normalized.details ? ` (${normalized.details})` : ''}`);
-    }
-    return output.join('\n');
-}
-function normalizeRuleSetting(setting) {
-    if (typeof setting === 'string') {
-        return { level: setting };
-    }
-    if (typeof setting === 'number') {
-        return { level: severityFromNumber(setting) };
-    }
-    if (Array.isArray(setting) && setting.length > 0) {
-        const [levelRaw, ...rest] = setting;
-        const level = typeof levelRaw === 'number' ? severityFromNumber(levelRaw) : String(levelRaw);
-        return {
-            level,
-            details: rest.length > 0 ? JSON.stringify(rest) : undefined,
-        };
-    }
-    if (typeof setting === 'object' && setting !== null) {
-        return {
-            level: 'configured',
-            details: JSON.stringify(setting),
-        };
-    }
-    return { level: 'off' };
-}
-function severityFromNumber(level) {
-    switch (level) {
-        case 0:
-            return 'off';
-        case 1:
-            return 'warn';
-        case 2:
-            return 'error';
-        default:
-            return `level-${level}`;
-    }
-}
-function formatQualityReport(content, structural, ast) {
-    const lines = content.split('\n');
-    const totalLines = lines.length;
-    const todoCount = lines.filter((line) => /TODO|FIXME|HACK/.test(line)).length;
-    const commentLines = lines.filter((line) => line.trim().startsWith('//') || line.trim().startsWith('/*')).length;
-    const commentCoverage = totalLines === 0 ? 0 : (commentLines / totalLines) * 100;
-    const longStructures = ast.symbols.filter((symbol) => symbol.kind !== 'class' && (symbol.statementCount > 40 || symbol.cyclomaticComplexity > 12));
-    const maintainabilityScore = Math.max(10, Math.round(100 -
-        longStructures.length * 4 -
-        Math.min(todoCount * 2, 30) -
-        Math.min(structural.functions.length * 0.5, 15) -
-        Math.min(commentCoverage < 10 ? 20 : 0, 20)));
-    const output = [];
-    output.push(`# Code quality snapshot`);
-    output.push('');
-    output.push(`- Total lines: ${totalLines}`);
-    output.push(`- Comment coverage: ${commentCoverage.toFixed(1)}%`);
-    output.push(`- TODO/FIXME occurrences: ${todoCount}`);
-    output.push(`- Named exports: ${structural.exports.length}`);
-    output.push(`- Maintainability score (heuristic): ${maintainabilityScore}/100`);
-    output.push('');
-    output.push('## Hotspots');
-    if (longStructures.length === 0) {
-        output.push('No large or unusually complex functions detected.');
-    }
-    else {
-        for (const symbol of longStructures) {
-            output.push(`- ${symbol.name} (${symbol.kind}) — statements: ${symbol.statementCount}, CC: ${symbol.cyclomaticComplexity}, lines ${symbol.startLine}-${symbol.endLine}`);
-        }
-    }
-    return output.join('\n');
-}

package/dist/bin/tools/dependencyTools.js

@@ -1,282 +0,0 @@
-import { exec } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { promisify } from 'node:util';
-const execAsync = promisify(exec);
-export function createDependencyTools(workingDir) {
-    return [
-        {
-            name: 'summarize_dependencies',
-            description: 'Summarize dependency counts, categories, and notable packages from package.json.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    detail: {
-                        type: 'string',
-                        enum: ['basic', 'full'],
-                        description: 'Detail level for the summary (default: basic).',
-                    },
-                },
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                try {
-                    const pkg = readPackageJson(workingDir);
-                    if (!pkg) {
-                        return 'Error: package.json not found.';
-                    }
-                    const detail = args['detail'] === 'full' ? 'full' : 'basic';
-                    return formatDependencySummary(pkg, detail);
-                }
-                catch (error) {
-                    return `Error summarizing dependencies: ${error instanceof Error ? error.message : String(error)}`;
-                }
-            },
-        },
-        {
-            name: 'scan_dependency_health',
-            description: 'Run npm audit to surface known vulnerabilities (requires npm registry access).',
-            parameters: {
-                type: 'object',
-                properties: {
-                    timeout: {
-                        type: 'number',
-                        description: 'Timeout in milliseconds (default: 180000).',
-                    },
-                },
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const timeoutArg = args['timeout'];
-                const timeout = typeof timeoutArg === 'number' && Number.isFinite(timeoutArg) && timeoutArg > 0
-                    ? timeoutArg
-                    : 180000;
-                try {
-                    const { stdout } = await execAsync('npm audit --json', {
-                        cwd: workingDir,
-                        timeout,
-                        maxBuffer: 1024 * 1024 * 15,
-                    });
-                    return formatAuditReport(stdout);
-                }
-                catch (error) {
-                    if (error.killed) {
-                        return `Error: npm audit timed out after ${timeout}ms.`;
-                    }
-                    const stdout = error.stdout;
-                    if (stdout && stdout.trim()) {
-                        try {
-                            return formatAuditReport(stdout);
-                        }
-                        catch (parseError) {
-                            // fall through to generic error
-                        }
-                    }
-                    return `Error running npm audit: ${error.message}. stderr: ${error.stderr ?? 'none'}`;
-                }
-            },
-        },
-        {
-            name: 'inspect_dependency_tree',
-            description: 'Analyze package-lock.json for resolved versions and duplicate dependency instances.',
-            parameters: {
-                type: 'object',
-                properties: {},
-                additionalProperties: false,
-            },
-            handler: async () => {
-                try {
-                    const pkg = readPackageJson(workingDir);
-                    if (!pkg) {
-                        return 'Error: package.json not found.';
-                    }
-                    const lockPath = join(workingDir, 'package-lock.json');
-                    if (!existsSync(lockPath)) {
-                        return 'package-lock.json not found. Run npm install to generate it.';
-                    }
-                    const lock = JSON.parse(readFileSync(lockPath, 'utf-8'));
-                    return formatLockSummary(pkg, lock);
-                }
-                catch (error) {
-                    return `Error inspecting dependency tree: ${error instanceof Error ? error.message : String(error)}`;
-                }
-            },
-        },
-    ];
-}
-function readPackageJson(workingDir) {
-    const packageJsonPath = join(workingDir, 'package.json');
-    if (!existsSync(packageJsonPath)) {
-        return null;
-    }
-    return JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-}
-function formatDependencySummary(pkg, detail) {
-    const deps = Object.entries(pkg.dependencies ?? {});
-    const devDeps = Object.entries(pkg.devDependencies ?? {});
-    const optionalDeps = Object.entries(pkg.optionalDependencies ?? {});
-    const output = [];
-    output.push(`# Dependency summary for ${pkg.name ?? 'package'} v${pkg.version ?? '0.0.0'}`);
-    output.push('');
-    output.push(`- Production dependencies: ${deps.length}`);
-    output.push(`- Dev dependencies: ${devDeps.length}`);
-    output.push(`- Optional dependencies: ${optionalDeps.length}`);
-    output.push('');
-    if (detail === 'full') {
-        if (deps.length > 0) {
-            output.push('## Production dependencies');
-            deps
-                .sort(([a], [b]) => a.localeCompare(b))
-                .forEach(([name, version]) => {
-                output.push(`- ${name}: ${version}`);
-            });
-            output.push('');
-        }
-        if (devDeps.length > 0) {
-            output.push('## Dev dependencies');
-            devDeps
-                .sort(([a], [b]) => a.localeCompare(b))
-                .forEach(([name, version]) => {
-                output.push(`- ${name}: ${version}`);
-            });
-            output.push('');
-        }
-        if (optionalDeps.length > 0) {
-            output.push('## Optional dependencies');
-            optionalDeps
-                .sort(([a], [b]) => a.localeCompare(b))
-                .forEach(([name, version]) => {
-                output.push(`- ${name}: ${version}`);
-            });
-            output.push('');
-        }
-    }
-    else {
-        if (deps.length > 0) {
-            output.push('Top production dependencies:');
-            deps
-                .sort(([a], [b]) => a.localeCompare(b))
-                .slice(0, 10)
-                .forEach(([name, version]) => {
-                output.push(`- ${name}: ${version}`);
-            });
-            output.push('');
-        }
-    }
-    return output.join('\n');
-}
-function formatAuditReport(jsonText) {
-    const report = JSON.parse(jsonText);
-    const metadata = report.metadata ?? {};
-    const vulnerabilityCounts = metadata.vulnerabilities ?? report.vulnerabilities ?? {};
-    const output = [];
-    output.push('# npm audit report');
-    output.push('');
-    if (Object.keys(vulnerabilityCounts).length === 0) {
-        output.push('No vulnerabilities reported.');
-    }
-    else {
-        output.push('## Totals by severity');
-        for (const [severity, count] of Object.entries(vulnerabilityCounts)) {
-            output.push(`- ${severity}: ${count}`);
-        }
-        output.push('');
-    }
-    const vulnerabilities = report.vulnerabilities ?? report.advisories ?? {};
-    const entries = Object.entries(vulnerabilities);
-    if (entries.length > 0) {
-        output.push('## Notable vulnerabilities');
-        entries.slice(0, 10).forEach(([name, info]) => {
-            const data = info;
-            const severity = data.severity ?? data.metadata?.severity ?? 'unknown';
-            const via = Array.isArray(data.via)
-                ? data.via.map((item) => (typeof item === 'string' ? item : item.title)).join(', ')
-                : '';
-            output.push(`- ${name}: severity ${severity}${via ? ` (via ${via})` : ''}`);
-            if (data.range) {
-                output.push(`  Affected versions: ${data.range}`);
-            }
-            else if (data.vulnerable_versions) {
-                output.push(`  Affected versions: ${data.vulnerable_versions}`);
-            }
-            if (data.patch_available || data.fixAvailable) {
-                output.push(`  Fix available: ${JSON.stringify(data.patch_available ?? data.fixAvailable)}`);
-            }
-        });
-    }
-    else {
-        output.push('No detailed vulnerability entries were returned by npm audit.');
-    }
-    return output.join('\n');
-}
-function formatLockSummary(pkg, lock) {
-    const deps = Object.keys(pkg.dependencies ?? {});
-    const devDeps = Object.keys(pkg.devDependencies ?? {});
-    const output = [];
-    output.push(`# Dependency tree (${pkg.name ?? 'package'})`);
-    if (lock.lockfileVersion) {
-        output.push(`Lockfile version: ${lock.lockfileVersion}`);
-    }
-    output.push('');
-    if (deps.length > 0) {
-        output.push('## Resolved production dependencies');
-        deps.forEach((dep) => {
-            const version = resolveLockVersion(lock, dep);
-            output.push(`- ${dep}: ${version ?? 'unknown version'}`);
-        });
-        output.push('');
-    }
-    if (devDeps.length > 0) {
-        output.push('## Resolved dev dependencies');
-        devDeps.forEach((dep) => {
-            const version = resolveLockVersion(lock, dep);
-            output.push(`- ${dep}: ${version ?? 'unknown version'}`);
-        });
-        output.push('');
-    }
-    const duplicates = detectDuplicateVersions(lock);
-    if (duplicates.length > 0) {
-        output.push('## Duplicate packages detected');
-        duplicates.forEach(({ name, versions }) => {
-            output.push(`- ${name}: ${Array.from(versions).join(', ')}`);
-        });
-    }
-    else {
-        output.push('No duplicate package versions detected across the lockfile.');
-    }
-    return output.join('\n');
-}
-function resolveLockVersion(lock, name) {
-    if (lock.dependencies && lock.dependencies[name]?.version) {
-        return lock.dependencies[name].version ?? null;
-    }
-    if (lock.packages) {
-        const key = name.startsWith('node_modules/') ? name : `node_modules/${name}`;
-        const entry = lock.packages[key];
-        if (entry?.version) {
-            return entry.version;
-        }
-    }
-    return null;
-}
-function detectDuplicateVersions(lock) {
-    const versionMap = new Map();
-    if (!lock.packages) {
-        return [];
-    }
-    for (const [key, entry] of Object.entries(lock.packages)) {
-        if (!key.startsWith('node_modules/')) {
-            continue;
-        }
-        const name = key.replace(/^node_modules\//, '');
-        if (!versionMap.has(name)) {
-            versionMap.set(name, new Set());
-        }
-        if (entry.version) {
-            versionMap.get(name).add(entry.version);
-        }
-    }
-    return [...versionMap.entries()]
-        .filter(([, versions]) => versions.size > 1)
-        .map(([name, versions]) => ({ name, versions }));
-}