1import fs from 'node:fs';
2import path from 'node:path';
3 
4import { loadDesignSystemForCwd } from '../design-system.mjs';
5import { createBrowserDetector, detectUrl } from '../engines/browser/detect-url.mjs';
6import { detectHtml } from '../engines/static-html/detect-html.mjs';
7import { detectText } from '../engines/regex/detect-text.mjs';
8import {
9  filterDetectionFindings,
10  readDetectionConfig,
11  shouldIgnoreDetectionFile,
12} from '../../lib/impeccable-config.mjs';
13import {
14  HTML_EXTENSIONS,
15  buildImportGraph,
16  detectFrameworkConfig,
17  isPortListening,
18  walkDir,
19} from '../node/file-system.mjs';
20 
21// ---------------------------------------------------------------------------
22// Output formatting
23// ---------------------------------------------------------------------------
24 
25function formatFindings(findings, jsonMode) {
26  if (jsonMode) return JSON.stringify(findings, null, 2);
27 
28  const grouped = {};
29  for (const f of findings) {
30    if (!grouped[f.file]) grouped[f.file] = [];
31    grouped[f.file].push(f);
32  }
33  const out = [];
34  for (const [file, items] of Object.entries(grouped)) {
35    const importNote = items[0]?.importedBy?.length ? ` (imported by ${items[0].importedBy.join(', ')})` : '';
36    out.push(`\n${file}${importNote}`);
37    for (const item of items) {
38      out.push(`  ${item.line ? `line ${item.line}: ` : ''}[${item.antipattern}] ${item.snippet}`);
39      out.push(`    → ${item.description}`);
40    }
41  }
42  out.push(`\n${findings.length} anti-pattern${findings.length === 1 ? '' : 's'} found.`);
43  return out.join('\n');
44}
45 
46// ---------------------------------------------------------------------------
47// Stdin handling
48// ---------------------------------------------------------------------------
49 
50async function handleStdin(options = {}) {
51  const chunks = [];
52  for await (const chunk of process.stdin) chunks.push(chunk);
53  const input = Buffer.concat(chunks).toString('utf-8');
54  try {
55    const parsed = JSON.parse(input);
56    const fp = parsed?.tool_input?.file_path;
57    if (fp && fs.existsSync(fp)) {
58      return HTML_EXTENSIONS.has(path.extname(fp).toLowerCase())
59        ? detectHtml(fp, options) : detectText(fs.readFileSync(fp, 'utf-8'), fp, options);
60    }
61  } catch { /* not JSON */ }
62  return detectText(input, '<stdin>', options);
63}
64 
65 
66// ---------------------------------------------------------------------------
67// CLI
68// ---------------------------------------------------------------------------
69 
70async function confirm(question) {
71  const rl = (await import('node:readline')).default.createInterface({
72    input: process.stdin, output: process.stderr,
73  });
74  return new Promise((resolve) => {
75    rl.question(`${question} [Y/n] `, (answer) => {
76      rl.close();
77      resolve(!answer || /^y(es)?$/i.test(answer.trim()));
78    });
79  });
80}
81 
82function printUsage() {
83  console.log(`Usage: impeccable detect [options] [file-or-dir-or-url...]
84 
85Scan files or URLs for UI anti-patterns and design quality issues.
86 
87Options:
88  --json              Output results as JSON
89  --gpt               Also report GPT-specific provider tells (off by default)
90  --gemini            Also report Gemini-specific provider tells (off by default)
91  --no-config         Do not apply project config, detector ignores, or DESIGN.md
92  --no-design-system  Do not load local DESIGN.md / .impeccable/design.json context
93  --help              Show this help message
94 
95Project config:
96  Respects .impeccable/config.json and .impeccable/config.local.json detector
97  settings: detector.ignoreRules, detector.ignoreFiles, detector.ignoreValues,
98  and detector.designSystem.enabled.
99 
100Detection modes:
101  HTML files     Static HTML/CSS analysis (default, catches linked CSS)
102  Non-HTML files Regex pattern matching (CSS, JSX, TSX, etc.)
103  URLs           Puppeteer full browser rendering (auto-detected)
104 
105Examples:
106  impeccable detect src/
107  impeccable detect index.html
108  impeccable detect https://example.com
109  impeccable detect --json .
110  impeccable detect --no-config src/`);
111}
112 
113async function detectCli() {
114  let args = process.argv.slice(2).map(arg => {
115    if (arg === '-json') return '--json';
116    if (arg === '-fast') return '--fast';
117    return arg;
118  });
119  if (args[0] === 'detect') args = args.slice(1);
120  const jsonMode = args.includes('--json');
121  const helpMode = args.includes('--help');
122  // --fast (regex-only) is deprecated: since the jsdom removal, the static
123  // HTML/CSS analysis is fast and covers every rule, so the regex-only path
124  // only loses coverage for no real speed win. Accept the flag for back-compat
125  // but ignore it and run the full scan.
126  if (args.includes('--fast')) {
127    process.stderr.write(
128      'Note: --fast is deprecated and ignored. The full scan is fast now and runs every rule.\n',
129    );
130  }
131  const configEnabled = !args.includes('--no-config');
132  const detectionConfig = configEnabled
133    ? readDetectionConfig(process.cwd())
134    : { ignoreRules: [], ignoreFiles: [], ignoreValues: [] };
135  const providers = [];
136  if (args.includes('--gpt')) providers.push('gpt');
137  if (args.includes('--gemini')) providers.push('gemini');
138  const designSystemEnabled = configEnabled && !args.includes('--no-design-system') && detectionConfig.designSystem?.enabled !== false;
139  const designSystem = designSystemEnabled ? loadDesignSystemForCwd(process.cwd()) : null;
140  const scanOptions = designSystem ? { providers, designSystem } : { providers };
141  const targets = args.filter(a => !a.startsWith('--'));
142 
143  if (helpMode) { printUsage(); process.exit(0); }
144 
145  let allFindings = [];
146 
147  if (!process.stdin.isTTY && targets.length === 0) {
148    allFindings = await handleStdin(scanOptions);
149  } else {
150    const paths = targets.length > 0 ? targets : [process.cwd()];
151    const urlTargetCount = paths.filter(target => /^https?:\/\//i.test(target)).length;
152    const browserDetector = urlTargetCount > 1 ? await createBrowserDetector() : null;
153 
154    try {
155      for (const target of paths) {
156        if (/^https?:\/\//i.test(target)) {
157          try {
158            const scanner = browserDetector
159              ? (url) => browserDetector.detectUrl(url, scanOptions)
160              : (url) => detectUrl(url, scanOptions);
161            allFindings.push(...await scanner(target));
162          } catch (e) { process.stderr.write(`Error: ${e.message}\n`); }
163          continue;
164        }
165 
166        const resolved = path.resolve(target);
167        let stat;
168        try { stat = fs.statSync(resolved); }
169        catch { process.stderr.write(`Warning: cannot access ${target}\n`); continue; }
170 
171        if (stat.isDirectory()) {
172          // Check for framework dev server config (skip in JSON mode to avoid polluting output)
173          if (!jsonMode) {
174            const fwConfig = detectFrameworkConfig(resolved);
175            if (fwConfig) {
176              const probe = await isPortListening(fwConfig.port, fwConfig.fingerprint);
177              if (probe.listening && probe.matched) {
178                process.stderr.write(
179                  `\n${fwConfig.name} dev server detected on localhost:${fwConfig.port}.\n` +
180                  `For more accurate results, scan the running site:\n` +
181                  `  npx impeccable detect http://localhost:${fwConfig.port}\n\n`
182                );
183              } else if (probe.listening && !probe.matched) {
184                process.stderr.write(
185                  `\n${fwConfig.name} project detected (${path.basename(fwConfig.configPath)}).\n` +
186                  `Port ${fwConfig.port} is in use by another service. Start the ${fwConfig.name} dev server and scan via URL for best results.\n\n`
187                );
188              } else {
189                process.stderr.write(
190                  `\n${fwConfig.name} project detected (${path.basename(fwConfig.configPath)}).\n` +
191                  `Start the dev server and scan via URL for best results:\n` +
192                  `  npx impeccable detect http://localhost:${fwConfig.port}\n\n`
193                );
194              }
195            }
196          }
197 
198          const files = walkDir(resolved)
199            .filter(file => !shouldIgnoreDetectionFile(file, process.cwd(), detectionConfig));
200          const htmlCount = files.filter(f => HTML_EXTENSIONS.has(path.extname(f).toLowerCase())).length;
201 
202          // Warn and confirm if scanning many files (static HTML/CSS processes each HTML file)
203          if (files.length > 50 && process.stdin.isTTY && !jsonMode) {
204            process.stderr.write(
205              `\nFound ${files.length} files (${htmlCount} HTML) in ${target}.\n` +
206              `Scanning may take a while${htmlCount > 10 ? ' (static HTML/CSS processes each HTML file individually)' : ''}.\n` +
207              `Target a specific subdirectory to narrow scope.\n`
208            );
209            const ok = await confirm('Continue?');
210            if (!ok) { process.stderr.write('Aborted.\n'); process.exit(0); }
211          }
212 
213          // Build import graph for multi-file awareness
214          const graph = buildImportGraph(files);
215          // Build reverse map: file -> set of files that import it
216          const importedByMap = new Map();
217          for (const [importer, imports] of graph) {
218            for (const imported of imports) {
219              if (!importedByMap.has(imported)) importedByMap.set(imported, new Set());
220              importedByMap.get(imported).add(importer);
221            }
222          }
223 
224          for (const file of files) {
225            const ext = path.extname(file).toLowerCase();
226            let fileFindings;
227            if (HTML_EXTENSIONS.has(ext)) {
228              fileFindings = await detectHtml(file, scanOptions);
229            } else {
230              fileFindings = detectText(fs.readFileSync(file, 'utf-8'), file, scanOptions);
231            }
232            // Annotate findings with import context
233            const importers = importedByMap.get(file);
234            if (importers && importers.size > 0) {
235              const importerNames = [...importers].map(f => path.basename(f));
236              for (const f of fileFindings) {
237                f.importedBy = importerNames;
238              }
239            }
240            allFindings.push(...fileFindings);
241          }
242        } else if (stat.isFile()) {
243          if (shouldIgnoreDetectionFile(resolved, process.cwd(), detectionConfig)) continue;
244          const ext = path.extname(resolved).toLowerCase();
245          if (HTML_EXTENSIONS.has(ext)) {
246            allFindings.push(...await detectHtml(resolved, scanOptions));
247          } else {
248            allFindings.push(...detectText(fs.readFileSync(resolved, 'utf-8'), resolved, scanOptions));
249          }
250        }
251      }
252    } finally {
253      if (browserDetector) await browserDetector.close();
254    }
255  }
256 
257  allFindings = filterDetectionFindings(allFindings, detectionConfig);
258 
259  if (allFindings.length > 0) {
260    if (jsonMode) process.stdout.write(formatFindings(allFindings, true) + '\n');
261    else process.stderr.write(formatFindings(allFindings, false) + '\n');
262    process.exit(2);
263  }
264  if (jsonMode) process.stdout.write('[]\n');
265  process.exit(0);
266}
267 
268export { formatFindings, handleStdin, confirm, printUsage, detectCli };
269