monomind 2.7.3 → 2.7.4

package/packages/@monomind/cli/.claude/skills/monodesign/scripts/detector/fix/index.mjs

@@ -1,426 +0,0 @@
-/**
- * Auto-fix engine: detect -> apply safe codemods -> re-detect -> report.
- *
- * Single-pass by design: every fixer is idempotent and lands values on the
- * safe side of its detector threshold, so the re-detect step only verifies —
- * it never triggers another round of edits (no oscillation).
- *
- * Honors the same filter pipeline as `detect`: project config ignores
- * (.monodesign/config.json), inline monodesign-disable* directives, and file
- * ignores — an ignored finding is never "fixed".
- */
-
-import fs from 'node:fs';
-import path from 'node:path';
-
-import { loadDesignSystemForCwd } from '../design-system.mjs';
-import { detectHtml } from '../engines/static-html/detect-html.mjs';
-import { detectText } from '../engines/regex/detect-text.mjs';
-import {
-  filterDetectionFindings,
-  readDetectionConfig,
-  shouldIgnoreDetectionFile,
-} from '../../lib/monodesign-config.mjs';
-import { HTML_EXTENSIONS, walkDir } from '../node/file-system.mjs';
-import { UNFIXABLE_REASONS, getFixer, fixableRuleIds, FIXERS } from './fixers.mjs';
-
-// ---------------------------------------------------------------------------
-// Edit application
-// ---------------------------------------------------------------------------
-
-/** Apply edits to content. Edits are sorted; overlapping edits are dropped
- *  (first wins). Returns { content, applied } — applied lists the edits used. */
-function applyEdits(content, edits) {
-  const sorted = [...edits].sort((a, b) => a.start - b.start || a.end - b.end);
-  const kept = [];
-  let lastEnd = -1;
-  for (const edit of sorted) {
-    if (edit.start < lastEnd) continue; // overlap — first edit wins
-    kept.push(edit);
-    lastEnd = Math.max(edit.end, edit.start);
-  }
-  let result = content;
-  for (let i = kept.length - 1; i >= 0; i--) {
-    const { start, end, replacement } = kept[i];
-    result = result.slice(0, start) + replacement + result.slice(end);
-  }
-  return { content: result, applied: kept };
-}
-
-/** Atomic write: temp file in the same directory, then rename over target. */
-function writeFileAtomic(filePath, content) {
-  const tmp = path.join(
-    path.dirname(filePath),
-    `.${path.basename(filePath)}.${process.pid}.monodesign-tmp`,
-  );
-  fs.writeFileSync(tmp, content, 'utf-8');
-  fs.renameSync(tmp, filePath);
-}
-
-// ---------------------------------------------------------------------------
-// Unified diff (minimal single-hunk implementation for --dry-run)
-// ---------------------------------------------------------------------------
-
-function unifiedDiff(oldText, newText, label) {
-  if (oldText === newText) return '';
-  const a = oldText.split('\n');
-  const b = newText.split('\n');
-  let p = 0;
-  while (p < a.length && p < b.length && a[p] === b[p]) p++;
-  let s = 0;
-  while (s < a.length - p && s < b.length - p && a[a.length - 1 - s] === b[b.length - 1 - s]) s++;
-  const aEnd = a.length - s;
-  const bEnd = b.length - s;
-  const ctxStart = Math.max(0, p - 3);
-  const ctxEnd = Math.min(a.length, aEnd + 3);
-  const oldLen = ctxEnd - ctxStart;
-  const newLen = (p - ctxStart) + (bEnd - p) + (ctxEnd - aEnd);
-  const lines = [`--- a/${label}`, `+++ b/${label}`, `@@ -${ctxStart + 1},${oldLen} +${ctxStart + 1},${newLen} @@`];
-  for (let i = ctxStart; i < p; i++) lines.push(` ${a[i]}`);
-  for (let i = p; i < aEnd; i++) lines.push(`-${a[i]}`);
-  for (let i = p; i < bEnd; i++) lines.push(`+${b[i]}`);
-  for (let i = aEnd; i < ctxEnd; i++) lines.push(` ${a[i]}`);
-  return lines.join('\n');
-}
-
-// ---------------------------------------------------------------------------
-// Linked stylesheet resolution (HTML findings whose declaration lives in CSS)
-// ---------------------------------------------------------------------------
-
-function extractLinkedStylesheets(html, htmlPath) {
-  const out = [];
-  const linkRe = /<link\b[^>]*>/gi;
-  let m;
-  while ((m = linkRe.exec(html)) !== null) {
-    const tag = m[0];
-    if (!/rel\s*=\s*["']?stylesheet/i.test(tag)) continue;
-    const href = tag.match(/href\s*=\s*["']([^"']+)["']/i)?.[1];
-    if (!href || /^(?:https?:)?\/\//i.test(href) || href.startsWith('data:')) continue;
-    const resolved = path.resolve(path.dirname(htmlPath), href.split(/[?#]/)[0]);
-    if (fs.existsSync(resolved)) out.push(resolved);
-  }
-  return out;
-}
-
-// ---------------------------------------------------------------------------
-// Fix run
-// ---------------------------------------------------------------------------
-
-function groupByRule(findings) {
-  const byRule = new Map();
-  for (const f of findings) {
-    if (!byRule.has(f.antipattern)) byRule.set(f.antipattern, []);
-    byRule.get(f.antipattern).push(f);
-  }
-  return byRule;
-}
-
-/**
- * Run the fix loop over file/directory targets.
- *
- * options:
- *   cwd       — project root for config + design-system loading
- *   dryRun    — compute edits and diffs; write nothing
- *   rules     — restrict fixing to these rule ids
- *   noConfig  — skip project config + inline-ignore filtering
- *
- * Returns a report:
- *   { dryRun, fixed, remaining, skipped, filesChanged, diffs, warnings }
- */
-async function runFix(targets, options = {}) {
-  const cwd = options.cwd || process.cwd();
-  const dryRun = Boolean(options.dryRun);
-  const ruleFilter = options.rules && options.rules.length ? new Set(options.rules) : null;
-  const config = options.noConfig
-    ? { ignoreRules: [], ignoreFiles: [], ignoreValues: [] }
-    : readDetectionConfig(cwd);
-  const designSystemEnabled = !options.noConfig && config.designSystem?.enabled !== false;
-  const designSystem = designSystemEnabled ? loadDesignSystemForCwd(cwd) : null;
-  const scanOptions = { providers: [], inlineIgnores: !options.noConfig };
-  if (designSystem) scanOptions.designSystem = designSystem;
-
-  const warnings = [];
-  const files = [];
-  for (const target of targets) {
-    if (/^https?:\/\//i.test(target)) {
-      warnings.push(`Skipping URL target ${target}: fix operates on local files only.`);
-      continue;
-    }
-    const resolved = path.resolve(cwd, target);
-    let stat;
-    try { stat = fs.statSync(resolved); }
-    catch { warnings.push(`Warning: cannot access ${target}`); continue; }
-    if (stat.isDirectory()) {
-      files.push(...walkDir(resolved).filter(f => !shouldIgnoreDetectionFile(f, cwd, config)));
-    } else if (!shouldIgnoreDetectionFile(resolved, cwd, config)) {
-      files.push(resolved);
-    }
-  }
-  const uniqueFiles = [...new Set(files)];
-
-  const detectFile = async (file) => {
-    const ext = path.extname(file).toLowerCase();
-    const found = HTML_EXTENSIONS.has(ext)
-      ? await detectHtml(file, scanOptions)
-      : detectText(fs.readFileSync(file, 'utf-8'), file, scanOptions);
-    return filterDetectionFindings(found, config);
-  };
-
-  // 1. Detect
-  const findingsByFile = new Map();
-  for (const file of uniqueFiles) {
-    const found = await detectFile(file);
-    if (found.length > 0) findingsByFile.set(file, found);
-  }
-
-  // 2. Plan + apply fixes in memory. Buffers exist only for files that carry
-  //    findings (or are stylesheets linked from such a file) — files with no
-  //    findings are never touched.
-  const buffers = new Map(); // path -> { original, content, changed, parents:Set }
-  const loadBuffer = (file) => {
-    let buf = buffers.get(file);
-    if (!buf) {
-      const original = fs.readFileSync(file, 'utf-8');
-      buf = { original, content: original, changed: false, parents: new Set() };
-      buffers.set(file, buf);
-    }
-    return buf;
-  };
-
-  const skipped = []; // { file, antipattern, count, reason }
-  const attempts = []; // { file, antipattern, before, notes, targetFile }
-
-  for (const [file, findings] of findingsByFile) {
-    const ext = path.extname(file).toLowerCase();
-    for (const [rule, ruleFindings] of groupByRule(findings)) {
-      const count = ruleFindings.length;
-      if (ruleFilter && !ruleFilter.has(rule)) {
-        skipped.push({ file, antipattern: rule, count, reason: 'excluded by --rule' });
-        continue;
-      }
-      const fixer = getFixer(rule);
-      if (!fixer) {
-        skipped.push({
-          file,
-          antipattern: rule,
-          count,
-          reason: UNFIXABLE_REASONS[rule] || 'no deterministic safe fix exists for this rule',
-        });
-        continue;
-      }
-      const buf = loadBuffer(file);
-      let edits = fixer.fix(buf.content, ext);
-      let targetFile = file;
-      if (edits.length === 0 && HTML_EXTENSIONS.has(ext)) {
-        // The offending declaration may live in a linked stylesheet — the
-        // detector cascades linked CSS into HTML findings.
-        for (const cssPath of extractLinkedStylesheets(buf.original, file)) {
-          const cssBuf = loadBuffer(cssPath);
-          const cssEdits = fixer.fix(cssBuf.content, path.extname(cssPath).toLowerCase());
-          if (cssEdits.length > 0) {
-            edits = cssEdits;
-            targetFile = cssPath;
-            cssBuf.parents.add(file);
-            break;
-          }
-        }
-      }
-      if (edits.length === 0) {
-        skipped.push({
-          file,
-          antipattern: rule,
-          count,
-          reason: 'no safely rewritable declaration found in source',
-        });
-        continue;
-      }
-      const targetBuf = loadBuffer(targetFile);
-      const { content, applied } = applyEdits(targetBuf.content, edits);
-      if (content !== targetBuf.content) {
-        targetBuf.content = content;
-        targetBuf.changed = true;
-      }
-      attempts.push({
-        file,
-        antipattern: rule,
-        before: count,
-        targetFile,
-        notes: applied.map(e => e.note).filter(Boolean),
-      });
-    }
-  }
-
-  const changedFiles = [...buffers.entries()].filter(([, b]) => b.changed);
-  const filesChanged = changedFiles.map(([p]) => p);
-
-  // 3. Write (atomic) or diff (dry-run)
-  const diffs = [];
-  if (dryRun) {
-    for (const [p, b] of changedFiles) {
-      diffs.push({ file: p, diff: unifiedDiff(b.original, b.content, path.relative(cwd, p) || p) });
-    }
-  } else {
-    for (const [p, b] of changedFiles) writeFileAtomic(p, b.content);
-  }
-
-  // 4. Re-detect touched files to verify (skip in dry-run — nothing changed
-  //    on disk). Linked-CSS edits are verified through their parent HTML.
-  const remaining = [];
-  if (!dryRun && changedFiles.length > 0) {
-    const recheck = new Set();
-    for (const [p, b] of changedFiles) {
-      if (findingsByFile.has(p)) recheck.add(p);
-      for (const parent of b.parents) recheck.add(parent);
-    }
-    const after = new Map();
-    for (const p of recheck) after.set(p, await detectFile(p));
-    for (const attempt of attempts) {
-      const afterFindings = after.get(attempt.file) || [];
-      const stillThere = afterFindings.filter(f => f.antipattern === attempt.antipattern).length;
-      attempt.after = stillThere;
-      attempt.fixed = Math.max(0, attempt.before - stillThere);
-      if (stillThere > 0) {
-        remaining.push({ file: attempt.file, antipattern: attempt.antipattern, count: stillThere });
-      }
-    }
-  } else {
-    for (const attempt of attempts) {
-      attempt.after = dryRun ? null : attempt.before;
-      attempt.fixed = dryRun ? attempt.before : 0;
-    }
-  }
-
-  return {
-    dryRun,
-    fixed: attempts.map(a => ({
-      file: a.file,
-      antipattern: a.antipattern,
-      before: a.before,
-      after: a.after,
-      fixed: a.fixed,
-      targetFile: a.targetFile,
-      notes: a.notes,
-    })),
-    remaining,
-    skipped,
-    filesChanged,
-    diffs,
-    warnings,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// CLI
-// ---------------------------------------------------------------------------
-
-function printFixUsage() {
-  console.log(`Usage: monodesign fix [options] <file-or-dir...>
-
-Auto-fix detector findings where a deterministic, safe codemod exists.
-Runs detect, applies fixes, re-detects to verify, and reports
-fixed / remaining / skipped findings. Files without findings are never touched.
-
-Options:
-  --dry-run           Print unified diffs of would-be changes; write nothing
-  --json              Output the fix report as JSON
-  --rule <id,...>     Only fix the given rule ids
-  --no-config         Skip project config and inline-ignore filtering
-  --help              Show this help message
-
-Fixable rules:
-${Object.entries(FIXERS).map(([id, f]) => `  ${id.padEnd(26)} ${f.description}`).join('\n')}
-
-Everything else is reported as skipped with a reason (e.g. broken-image:
-choosing a real image is a content decision, not a codemod).
-
-Examples:
-  monodesign fix src/
-  monodesign fix --dry-run index.html
-  monodesign fix --rule tight-leading,tiny-text styles.css`);
-}
-
-function formatFixReport(report, jsonMode) {
-  if (jsonMode) return JSON.stringify(report, null, 2);
-  const out = [];
-  if (report.dryRun) {
-    for (const { diff } of report.diffs) {
-      if (diff) out.push(diff, '');
-    }
-  }
-  const verb = report.dryRun ? 'would fix' : 'fixed';
-  for (const item of report.fixed) {
-    const where = item.targetFile && item.targetFile !== item.file
-      ? `${item.file} (edited ${item.targetFile})`
-      : item.file;
-    out.push(`${verb} [${item.antipattern}] ${item.fixed}/${item.before} in ${where}`);
-  }
-  for (const item of report.remaining) {
-    out.push(`remaining [${item.antipattern}] ${item.count} in ${item.file}`);
-  }
-  for (const item of report.skipped) {
-    out.push(`skipped [${item.antipattern}] ${item.count} in ${item.file} — ${item.reason}`);
-  }
-  const fixedTotal = report.fixed.reduce((n, f) => n + (f.fixed || 0), 0);
-  const remainingTotal = report.remaining.reduce((n, f) => n + f.count, 0);
-  const skippedTotal = report.skipped.reduce((n, f) => n + f.count, 0);
-  out.push(`\n${report.dryRun ? 'Would fix' : 'Fixed'} ${fixedTotal}, remaining ${remainingTotal}, skipped ${skippedTotal}. ${report.filesChanged.length} file${report.filesChanged.length === 1 ? '' : 's'} ${report.dryRun ? 'would change' : 'changed'}.`);
-  return out.join('\n');
-}
-
-async function runFixCli(args) {
-  const targets = [];
-  const options = { dryRun: false, rules: null, noConfig: false };
-  let jsonMode = false;
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (arg === '--help' || arg === '-h') { printFixUsage(); process.exit(0); }
-    else if (arg === '--dry-run') options.dryRun = true;
-    else if (arg === '--json') jsonMode = true;
-    else if (arg === '--no-config') options.noConfig = true;
-    else if (arg === '--rule' || arg.startsWith('--rule=')) {
-      const value = arg.startsWith('--rule=') ? arg.slice('--rule='.length) : args[++i];
-      if (!value || value.startsWith('--')) {
-        process.stderr.write('Error: --rule requires a comma-separated list of rule ids.\n');
-        process.exit(1);
-      }
-      options.rules = [...(options.rules || []), ...value.split(',').map(s => s.trim()).filter(Boolean)];
-    } else if (arg.startsWith('--')) {
-      process.stderr.write(`Error: unknown option ${arg}\n\nRun: monodesign fix --help\n`);
-      process.exit(1);
-    } else {
-      targets.push(arg);
-    }
-  }
-
-  if (options.rules) {
-    const fixable = new Set(fixableRuleIds());
-    const unknown = options.rules.filter(r => !fixable.has(r));
-    if (unknown.length > 0) {
-      process.stderr.write(`Error: no fixer for rule(s): ${unknown.join(', ')}.\nFixable rules: ${fixableRuleIds().join(', ')}\n`);
-      process.exit(1);
-    }
-  }
-
-  if (targets.length === 0) {
-    process.stderr.write('Error: fix requires at least one file or directory target.\n\nRun: monodesign fix --help\n');
-    process.exit(1);
-  }
-
-  const report = await runFix(targets, options);
-  for (const warning of report.warnings) process.stderr.write(`${warning}\n`);
-  const formatted = formatFixReport(report, jsonMode);
-  if (jsonMode || report.dryRun) process.stdout.write(formatted + '\n');
-  else process.stderr.write(formatted + '\n');
-  process.exit(!report.dryRun && report.remaining.length > 0 ? 2 : 0);
-}
-
-export {
-  runFix,
-  runFixCli,
-  applyEdits,
-  unifiedDiff,
-  writeFileAtomic,
-  extractLinkedStylesheets,
-  printFixUsage,
-  formatFixReport,
-};

package/packages/@monomind/cli/.claude/skills/monodesign/scripts/detector/node/file-system.mjs

@@ -1,198 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-
-// ---------------------------------------------------------------------------
-// File walker
-// ---------------------------------------------------------------------------
-
-const SKIP_DIRS = new Set([
-  'node_modules', '.git', 'dist', 'build', '.next', '.nuxt', '.output',
-  '.svelte-kit', '__pycache__', '.turbo', '.vercel',
-]);
-
-const SCANNABLE_EXTENSIONS = new Set([
-  '.html', '.htm', '.css', '.scss', '.sass', '.less',
-  '.jsx', '.tsx', '.js', '.ts',
-  '.vue', '.svelte', '.astro',
-]);
-
-const HTML_EXTENSIONS = new Set(['.html', '.htm']);
-
-function walkDir(dir) {
-  const files = [];
-  let entries;
-  try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return files; }
-  for (const entry of entries) {
-    if (SKIP_DIRS.has(entry.name)) continue;
-    const full = path.join(dir, entry.name);
-    if (entry.isDirectory()) files.push(...walkDir(full));
-    else if (SCANNABLE_EXTENSIONS.has(path.extname(entry.name).toLowerCase())) files.push(full);
-  }
-  return files;
-}
-
-
-// ---------------------------------------------------------------------------
-// Import graph (multi-file awareness)
-// ---------------------------------------------------------------------------
-
-function resolveImport(specifier, fromDir, fileSet) {
-  if (!/^[./]/.test(specifier)) return null; // skip bare specifiers
-  const base = path.resolve(fromDir, specifier);
-  if (fileSet.has(base)) return base;
-  for (const ext of SCANNABLE_EXTENSIONS) {
-    const withExt = base + ext;
-    if (fileSet.has(withExt)) return withExt;
-  }
-  // index file convention
-  for (const ext of SCANNABLE_EXTENSIONS) {
-    const indexFile = path.join(base, 'index' + ext);
-    if (fileSet.has(indexFile)) return indexFile;
-  }
-  return null;
-}
-
-function buildImportGraph(files) {
-  const fileSet = new Set(files);
-  const graph = new Map();
-
-  for (const file of files) {
-    const content = fs.readFileSync(file, 'utf-8');
-    const dir = path.dirname(file);
-    const imports = new Set();
-
-    // ES imports: import ... from '...' and import '...'
-    const esRe = /import\s+(?:[\s\S]*?from\s+)?['"]([^'"]+)['"]/g;
-    let m;
-    while ((m = esRe.exec(content)) !== null) {
-      const resolved = resolveImport(m[1], dir, fileSet);
-      if (resolved) imports.add(resolved);
-    }
-
-    // CSS @import
-    const cssRe = /@import\s+(?:url\(\s*)?['"]?([^'");\s]+)['"]?\s*\)?/g;
-    while ((m = cssRe.exec(content)) !== null) {
-      const resolved = resolveImport(m[1], dir, fileSet);
-      if (resolved) imports.add(resolved);
-    }
-
-    // SCSS @use / @forward
-    const scssRe = /@(?:use|forward)\s+['"]([^'"]+)['"]/g;
-    while ((m = scssRe.exec(content)) !== null) {
-      const resolved = resolveImport(m[1], dir, fileSet);
-      if (resolved) imports.add(resolved);
-    }
-
-    graph.set(file, imports);
-  }
-  return graph;
-}
-
-// ---------------------------------------------------------------------------
-// Framework dev server detection
-// ---------------------------------------------------------------------------
-
-const FRAMEWORK_CONFIGS = [
-  { name: 'Next.js', files: ['next.config.js', 'next.config.mjs', 'next.config.ts'], defaultPort: 3000,
-    portRe: /port\s*[:=]\s*(\d+)/,
-    fingerprint: { header: 'x-powered-by', value: /next/i } },
-  { name: 'SvelteKit', files: ['svelte.config.js', 'svelte.config.ts'], defaultPort: 5173,
-    portRe: /port\s*[:=]\s*(\d+)/,
-    fingerprint: { header: 'x-sveltekit-page', value: null } },
-  { name: 'Nuxt', files: ['nuxt.config.js', 'nuxt.config.ts'], defaultPort: 3000,
-    portRe: /port\s*[:=]\s*(\d+)/,
-    fingerprint: { header: 'x-powered-by', value: /nuxt/i } },
-  { name: 'Vite', files: ['vite.config.js', 'vite.config.ts', 'vite.config.mjs'], defaultPort: 5173,
-    portRe: /port\s*[:=]\s*(\d+)/,
-    fingerprint: { body: /@vite\/client/ } },
-  { name: 'Astro', files: ['astro.config.js', 'astro.config.ts', 'astro.config.mjs'], defaultPort: 4321,
-    portRe: /port\s*[:=]\s*(\d+)/,
-    fingerprint: { body: /astro/i } },
-  { name: 'Angular', files: ['angular.json'], defaultPort: 4200,
-    portRe: /"port"\s*:\s*(\d+)/,
-    fingerprint: { body: /ng-version/i } },
-  { name: 'Remix', files: ['remix.config.js', 'remix.config.ts'], defaultPort: 3000,
-    portRe: /port\s*[:=]\s*(\d+)/,
-    fingerprint: { header: 'x-powered-by', value: /remix/i } },
-];
-
-function detectFrameworkConfig(dir) {
-  let entries;
-  try { entries = fs.readdirSync(dir); } catch { return null; }
-  const entrySet = new Set(entries);
-
-  for (const cfg of FRAMEWORK_CONFIGS) {
-    const match = cfg.files.find(f => entrySet.has(f));
-    if (!match) continue;
-
-    const configPath = path.join(dir, match);
-    let port = cfg.defaultPort;
-    try {
-      const content = fs.readFileSync(configPath, 'utf-8');
-      const portMatch = content.match(cfg.portRe);
-      if (portMatch) port = parseInt(portMatch[1], 10);
-    } catch { /* use default */ }
-
-    return { name: cfg.name, port, configPath, fingerprint: cfg.fingerprint };
-  }
-  return null;
-}
-
-/**
- * Check if a port is listening and optionally verify it matches the expected framework.
- * Returns { listening: true, matched: true/false } or { listening: false }.
- */
-async function isPortListening(port, fingerprint = null) {
-  if (!fingerprint) {
-    // Simple TCP probe fallback
-    const net = await import('node:net');
-    return new Promise((resolve) => {
-      const sock = net.default.createConnection({ port, host: '127.0.0.1' });
-      sock.setTimeout(500);
-      sock.on('connect', () => { sock.destroy(); resolve({ listening: true, matched: true }); });
-      sock.on('error', () => resolve({ listening: false }));
-      sock.on('timeout', () => { sock.destroy(); resolve({ listening: false }); });
-    });
-  }
-
-  // HTTP probe with fingerprint matching
-  try {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 2000);
-    const res = await fetch(`http://localhost:${port}/`, { signal: controller.signal, redirect: 'follow' });
-    clearTimeout(timeout);
-
-    // Check header fingerprint
-    if (fingerprint.header) {
-      const val = res.headers.get(fingerprint.header);
-      if (val && (!fingerprint.value || fingerprint.value.test(val))) {
-        return { listening: true, matched: true };
-      }
-    }
-
-    // Check body fingerprint
-    if (fingerprint.body) {
-      const body = await res.text();
-      if (fingerprint.body.test(body)) {
-        return { listening: true, matched: true };
-      }
-    }
-
-    // Port is listening but doesn't match the expected framework
-    return { listening: true, matched: false };
-  } catch {
-    return { listening: false };
-  }
-}
-
-export {
-  SKIP_DIRS,
-  SCANNABLE_EXTENSIONS,
-  HTML_EXTENSIONS,
-  walkDir,
-  resolveImport,
-  buildImportGraph,
-  FRAMEWORK_CONFIGS,
-  detectFrameworkConfig,
-  isPortListening,
-};