ui-strings 0.1.0

package/dist/cli.js

@@ -0,0 +1,1244 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { spawn } from "node:child_process";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join as join2, resolve } from "node:path";
+import { Command } from "commander";
+import pc from "picocolors";
+
+// src/extract.ts
+import { existsSync } from "node:fs";
+import { basename, join, relative, sep } from "node:path";
+import {
+  Node,
+  Project,
+  SyntaxKind,
+  ts
+} from "ts-morph";
+
+// src/detect.ts
+var COPY_ATTR_PATTERN = /^(aria-(label|description|valuetext|placeholder|roledescription)|placeholder|title|alt|label|legend|summary|description|helperText|errorMessage|emptyText|tooltip|caption|heading|subtitle)$/i;
+var TECHNICAL_ATTRS = new Set([
+  "className",
+  "class",
+  "id",
+  "style",
+  "href",
+  "src",
+  "srcSet",
+  "srcset",
+  "to",
+  "path",
+  "type",
+  "name",
+  "key",
+  "rel",
+  "target",
+  "role",
+  "htmlFor",
+  "for",
+  "variant",
+  "size",
+  "color",
+  "width",
+  "height",
+  "method",
+  "action",
+  "autoComplete",
+  "loading",
+  "decoding",
+  "lang",
+  "dir",
+  "form",
+  "value",
+  "defaultValue"
+]);
+var COPY_KEY_PATTERN = /(label|title|message|description|text|placeholder|error|success|warning|hint|help|caption|heading|subtitle|tooltip|empty|confirm|cancel|body|summary)/i;
+var TECHNICAL_KEYS = new Set([
+  "className",
+  "id",
+  "href",
+  "src",
+  "key",
+  "name",
+  "type",
+  "variant",
+  "value",
+  "path",
+  "url",
+  "icon",
+  "color",
+  "size",
+  "target",
+  "rel",
+  "method",
+  "field",
+  "slug",
+  "locale",
+  "format",
+  "testId"
+]);
+var CLASSNAME_CALLEES = new Set([
+  "cn",
+  "cx",
+  "clsx",
+  "classnames",
+  "classNames",
+  "cva",
+  "tw",
+  "twMerge",
+  "twJoin"
+]);
+var URLISH = /^(https?:\/\/|mailto:|tel:|www\.|[./#~@])/;
+var HEX_COLOR = /^#[0-9a-fA-F]{3,8}$/;
+var IDENTIFIER_TOKEN = /^[A-Za-z0-9]+([-_][A-Za-z0-9\[\]%./:#]+)+$/;
+var CONSTANT_TOKEN = /^[A-Z0-9_]+$/;
+var hasNonLatinLetter = (text) => {
+  for (const ch of text) {
+    const code = ch.codePointAt(0) ?? 0;
+    if (code > 767 && /[\p{L}\p{Nl}]/u.test(ch)) {
+      return true;
+    }
+  }
+  return false;
+};
+var looksLikeEnglishCopy = (text) => {
+  const trimmed = text.trim();
+  if (!/[A-Za-z]/.test(trimmed)) {
+    return false;
+  }
+  if (URLISH.test(trimmed) || HEX_COLOR.test(trimmed)) {
+    return false;
+  }
+  const words = trimmed.split(/\s+/);
+  if (words.length === 1) {
+    const word = words[0] ?? "";
+    if (IDENTIFIER_TOKEN.test(word) || CONSTANT_TOKEN.test(word)) {
+      return false;
+    }
+    return /^[A-Z][a-z']+([.!?…]|\.\.\.)?$/.test(word) || /[.!?…]$/.test(word);
+  }
+  const technical = words.filter((word) => /[-_:\[\]{}/\\#@=]|\d/.test(word) && !/^[A-Za-z]+[.,:;!?…]*$/.test(word)).length;
+  if (technical / words.length > 0.4) {
+    return false;
+  }
+  const alpha = words.filter((word) => /^[A-Za-z][A-Za-z']*[.,:;!?…]*$/.test(word)).length;
+  return alpha >= 2;
+};
+var hasCopyTextEn = (text) => {
+  if (hasNonLatinLetter(text)) {
+    return true;
+  }
+  for (const match of text.matchAll(/["'`]([^"'`\n]*)["'`]/g)) {
+    if (looksLikeEnglishCopy(match[1] ?? "")) {
+      return true;
+    }
+  }
+  return false;
+};
+var withoutPlaceholders = (text) => text.replace(/\{[^{}]*\}/g, "");
+var lexical = (text) => hasNonLatinLetter(text) || looksLikeEnglishCopy(text);
+var isCopyEn = (text, context) => {
+  const { kind, attr, callee, key } = context;
+  if (hasNonLatinLetter(text)) {
+    return true;
+  }
+  if (kind === "jsx-text") {
+    return /\p{L}/u.test(withoutPlaceholders(text));
+  }
+  if (kind === "jsx-attribute") {
+    if (attr === undefined) {
+      return false;
+    }
+    if (COPY_ATTR_PATTERN.test(attr)) {
+      return /\p{L}/u.test(text);
+    }
+    if (TECHNICAL_ATTRS.has(attr) || attr.startsWith("data-") || attr.startsWith("on")) {
+      return false;
+    }
+    return lexical(text);
+  }
+  if (kind === "object-property" || kind === "metadata") {
+    if (key !== undefined) {
+      if (COPY_KEY_PATTERN.test(key)) {
+        return /\p{L}/u.test(text);
+      }
+      if (TECHNICAL_KEYS.has(key)) {
+        return false;
+      }
+    }
+    return lexical(text);
+  }
+  if (kind === "call-argument") {
+    if (callee !== undefined && CLASSNAME_CALLEES.has(callee)) {
+      return false;
+    }
+    return lexical(text);
+  }
+  return lexical(text);
+};
+var detector = {
+  isCopy: isCopyEn,
+  hasCopyText: hasCopyTextEn
+};
+
+// src/extract.ts
+var INLINE_TAGS = new Set([
+  "b",
+  "i",
+  "em",
+  "strong",
+  "span",
+  "small",
+  "a",
+  "code",
+  "u",
+  "s",
+  "mark",
+  "sup",
+  "sub",
+  "abbr",
+  "ruby",
+  "rt"
+]);
+var BREAK_TAGS = new Set(["br", "wbr"]);
+var INTERACTIVE_KEY_PATTERN = /^(message|error|success|warning|status)|(message|error)$/i;
+var INTERACTIVE_FILE_PATTERN = /(^|\/)(actions|route)\.tsx?$/;
+var collapseWhitespace = (text) => text.replace(/\s+/g, " ").trim();
+var calleeName = (expression) => {
+  if (Node.isPropertyAccessExpression(expression)) {
+    return expression.getName();
+  }
+  return collapseWhitespace(expression.getText()).slice(0, 60);
+};
+var isConsoleCall = (expression) => Node.isPropertyAccessExpression(expression) && expression.getExpression().getText() === "console";
+var isModuleSpecifier = (node) => {
+  const parent = node.getParent();
+  return (Node.isImportDeclaration(parent) || Node.isExportDeclaration(parent)) && parent.getModuleSpecifier() === node;
+};
+var isDirective = (node) => Node.isExpressionStatement(node.getParent());
+var templateToText = (node) => {
+  let text = node.getHead().getLiteralText();
+  for (const span of node.getTemplateSpans()) {
+    text += `{${collapseWhitespace(span.getExpression().getText())}}`;
+    text += span.getLiteral().getLiteralText();
+  }
+  return text;
+};
+var unwrapExpression = (node) => {
+  let current = node;
+  while (Node.isAsExpression(current) || Node.isSatisfiesExpression(current) || Node.isParenthesizedExpression(current)) {
+    current = current.getExpression();
+  }
+  return current;
+};
+var rootIdentifierOf = (expression) => {
+  let current = unwrapExpression(expression);
+  while (Node.isCallExpression(current) || Node.isPropertyAccessExpression(current) || Node.isElementAccessExpression(current) || Node.isNonNullExpression(current)) {
+    current = unwrapExpression(current.getExpression());
+  }
+  return Node.isIdentifier(current) ? current : undefined;
+};
+var declKeyOf = (declaration) => `${declaration.getSourceFile().getFilePath()}:${declaration.getPos()}`;
+var declarationOf = (identifier) => {
+  const symbol = identifier.getSymbol();
+  if (symbol === undefined) {
+    return;
+  }
+  const aliased = symbol.getAliasedSymbol() ?? symbol;
+  return aliased.getDeclarations().find(Node.isVariableDeclaration);
+};
+var tagNameOf = (element) => {
+  if (Node.isJsxElement(element)) {
+    return element.getOpeningElement().getTagNameNode().getText();
+  }
+  if (Node.isJsxSelfClosingElement(element)) {
+    return element.getTagNameNode().getText();
+  }
+  return;
+};
+var enclosingTag = (node) => {
+  const element = node.getFirstAncestor(Node.isJsxElement);
+  return element ? tagNameOf(element) : undefined;
+};
+var returnedJsxTag = (callback) => {
+  if (callback === undefined || !Node.isArrowFunction(callback) && !Node.isFunctionExpression(callback)) {
+    return;
+  }
+  const body = callback.getBody();
+  const returned = Node.isBlock(body) ? body.getStatements().find(Node.isReturnStatement)?.getExpression() : body;
+  return returned ? tagNameOf(unwrapExpression(returned)) : undefined;
+};
+var renderSiteTag = (jsxExpression) => {
+  if (!Node.isJsxExpression(jsxExpression)) {
+    return;
+  }
+  const expression = jsxExpression.getExpression();
+  if (expression !== undefined) {
+    const call = unwrapExpression(expression);
+    if (Node.isCallExpression(call)) {
+      const callee = call.getExpression();
+      if (Node.isPropertyAccessExpression(callee) && /^(map|flatMap)$/.test(callee.getName())) {
+        const tag = returnedJsxTag(call.getArguments()[0]);
+        if (tag !== undefined) {
+          return tag;
+        }
+      }
+    }
+  }
+  const owner = jsxExpression.getFirstAncestor((ancestor) => Node.isJsxElement(ancestor) || Node.isJsxSelfClosingElement(ancestor));
+  return owner ? tagNameOf(owner) : undefined;
+};
+var containsJsx = (node) => node.getFirstDescendant((descendant) => Node.isJsxElement(descendant) || Node.isJsxSelfClosingElement(descendant) || Node.isJsxFragment(descendant)) !== undefined;
+var joinPieces = (pieces) => pieces.join("").replace(/ {2,}/g, " ").replace(/ *\n */g, `
+`).replace(/^\n+|\n+$/g, "").trim();
+var mergeInline = (element, hasCopy) => {
+  const pieces = [];
+  for (const child of element.getJsxChildren()) {
+    const piece = mergeChild(child, hasCopy);
+    if (piece === null) {
+      return null;
+    }
+    pieces.push(piece);
+  }
+  const text = joinPieces(pieces);
+  return text === "" ? null : text;
+};
+var mergeChild = (child, hasCopy) => {
+  if (Node.isJsxText(child)) {
+    return child.getLiteralText().replace(/\s+/g, " ");
+  }
+  if (Node.isJsxSelfClosingElement(child)) {
+    const tag = child.getTagNameNode().getText();
+    return BREAK_TAGS.has(tag) ? `
+` : null;
+  }
+  if (Node.isJsxElement(child)) {
+    const tag = tagNameOf(child);
+    if (tag && INLINE_TAGS.has(tag)) {
+      return mergeInline(child, hasCopy);
+    }
+    return null;
+  }
+  if (Node.isJsxExpression(child)) {
+    const expression = child.getExpression();
+    if (expression === undefined) {
+      return "";
+    }
+    if (Node.isStringLiteral(expression) || Node.isNoSubstitutionTemplateLiteral(expression)) {
+      return expression.getLiteralText();
+    }
+    if (Node.isTemplateExpression(expression)) {
+      return templateToText(expression);
+    }
+    if (!containsJsx(expression) && !hasCopy(expression.getText())) {
+      return `{${collapseWhitespace(expression.getText())}}`;
+    }
+    return null;
+  }
+  return null;
+};
+var mergeRuns = (container, hasCopy) => {
+  const runs = [];
+  let nodes = [];
+  let pieces = [];
+  let anchor;
+  const flush = () => {
+    const text = joinPieces(pieces);
+    if (text !== "" && anchor !== undefined) {
+      runs.push({ text, nodes, anchor });
+    }
+    nodes = [];
+    pieces = [];
+    anchor = undefined;
+  };
+  for (const child of container.getJsxChildren()) {
+    const piece = mergeChild(child, hasCopy);
+    if (piece === null) {
+      flush();
+      continue;
+    }
+    if (anchor === undefined && piece.trim() !== "") {
+      anchor = child;
+    }
+    nodes.push(child);
+    pieces.push(piece);
+  }
+  flush();
+  return runs;
+};
+var classify = (node) => {
+  if (node.getKind() === SyntaxKind.JsxText) {
+    return { kind: "jsx-text" };
+  }
+  let current = node.getParent();
+  let previous = node;
+  while (current) {
+    if (Node.isThrowStatement(current)) {
+      return { kind: "internal" };
+    }
+    if (Node.isCallExpression(current)) {
+      const expression = current.getExpression();
+      if (isConsoleCall(expression)) {
+        return { kind: "internal" };
+      }
+      if (current.getArguments().includes(previous)) {
+        return { kind: "call-argument", callee: calleeName(expression) };
+      }
+    }
+    if (Node.isNewExpression(current)) {
+      const name = current.getExpression().getText();
+      if (name.endsWith("Error")) {
+        return { kind: "internal" };
+      }
+      return { kind: "call-argument", callee: `new ${name}` };
+    }
+    if (Node.isPropertyAssignment(current)) {
+      const key = current.getName();
+      const declaration = current.getFirstAncestorByKind(SyntaxKind.VariableDeclaration);
+      if (declaration?.getName() === "metadata") {
+        return { kind: "metadata", key };
+      }
+      return { kind: "object-property", key };
+    }
+    if (Node.isVariableDeclaration(current) && Node.isArrayLiteralExpression(unwrapExpression(previous))) {
+      return { kind: "array-item", key: current.getName() };
+    }
+    if (Node.isJsxAttribute(current)) {
+      return { kind: "jsx-attribute", attr: current.getNameNode().getText() };
+    }
+    if (Node.isJsxExpression(current)) {
+      const parent = current.getParent();
+      if (Node.isJsxElement(parent) || Node.isJsxFragment(parent) || Node.isJsxSelfClosingElement(parent)) {
+        return { kind: "jsx-text" };
+      }
+    }
+    if (Node.isArrowFunction(current) || Node.isFunctionDeclaration(current) || Node.isFunctionExpression(current) || Node.isMethodDeclaration(current)) {
+      break;
+    }
+    previous = current;
+    current = current.getParent();
+  }
+  return { kind: "other" };
+};
+var A11Y_ATTRS = new Set(["alt", "title"]);
+var isFunctionBoundary = (node) => Node.isArrowFunction(node) || Node.isFunctionDeclaration(node) || Node.isFunctionExpression(node) || Node.isMethodDeclaration(node);
+var conditionText = (node) => collapseWhitespace(node.getText()).slice(0, 60);
+var conditionOf = (node) => {
+  let previous = node;
+  let current = node.getParent();
+  while (current) {
+    if (Node.isConditionalExpression(current)) {
+      if (current.getWhenTrue() === previous) {
+        return {
+          condition: conditionText(current.getCondition()),
+          branch: "then"
+        };
+      }
+      if (current.getWhenFalse() === previous) {
+        return {
+          condition: conditionText(current.getCondition()),
+          branch: "else"
+        };
+      }
+    }
+    if (Node.isBinaryExpression(current) && current.getRight() === previous) {
+      const operator = current.getOperatorToken().getKind();
+      if (operator === SyntaxKind.AmpersandAmpersandToken) {
+        return { condition: conditionText(current.getLeft()), branch: "then" };
+      }
+      if (operator === SyntaxKind.BarBarToken || operator === SyntaxKind.QuestionQuestionToken) {
+        return { condition: conditionText(current.getLeft()), branch: "else" };
+      }
+    }
+    if (isFunctionBoundary(current)) {
+      return;
+    }
+    previous = current;
+    current = current.getParent();
+  }
+  return;
+};
+var surfaceFor = (classified, file) => {
+  const { kind, attr, key } = classified;
+  if (kind === "internal") {
+    return "internal";
+  }
+  if (kind === "metadata") {
+    return "meta";
+  }
+  if (kind === "jsx-attribute" && attr) {
+    if (attr.startsWith("aria-") || A11Y_ATTRS.has(attr)) {
+      return "a11y";
+    }
+    if (/error|invalid/i.test(attr)) {
+      return "interactive";
+    }
+    return "visible";
+  }
+  if (kind === "call-argument") {
+    return "interactive";
+  }
+  if (kind === "object-property") {
+    if (key && INTERACTIVE_KEY_PATTERN.test(key) || INTERACTIVE_FILE_PATTERN.test(basename(file)) || file.includes(`${sep}api${sep}`)) {
+      return "interactive";
+    }
+    return "visible";
+  }
+  return "visible";
+};
+var groupFor = (relativeFile, hasAppDir) => {
+  const parts = relativeFile.split(sep);
+  const appIndex = parts.indexOf("app");
+  if (hasAppDir && parts[0] === "src" && appIndex === 1) {
+    const segments = parts.slice(2, -1).filter((segment) => segment !== "_dependencies" && !(segment.startsWith("(") && segment.endsWith(")")));
+    return `/${segments.join("/")}`;
+  }
+  const dirs = parts.slice(0, -1);
+  if (dirs[0] === "src") {
+    dirs.shift();
+  }
+  return dirs.slice(0, 2).join("/") || "(root)";
+};
+var DEFAULT_EXCLUDES = [
+  "**/*.{test,spec}.{ts,tsx,js,jsx}",
+  "**/__tests__/**",
+  "**/__mocks__/**"
+];
+var scanProject = (options) => {
+  const { projectDir, srcGlob } = options;
+  const tsConfigFilePath = join(projectDir, "tsconfig.json");
+  const project = existsSync(tsConfigFilePath) ? new Project({ tsConfigFilePath, skipAddingFilesFromTsConfig: true }) : new Project({
+    compilerOptions: {
+      allowJs: true,
+      jsx: ts.JsxEmit.Preserve
+    },
+    skipAddingFilesFromTsConfig: true
+  });
+  const excludes = [...DEFAULT_EXCLUDES, ...options.exclude ?? []];
+  const sourceFiles = project.addSourceFilesAtPaths([
+    `${projectDir}/${srcGlob}`,
+    ...excludes.map((glob) => `!${projectDir}/${glob}`)
+  ]);
+  const hasAppDir = sourceFiles.some((file) => relative(projectDir, file.getFilePath()).startsWith(`src${sep}app${sep}`));
+  const renderSites = new Map;
+  for (const sourceFile of sourceFiles) {
+    const relativeFile = relative(projectDir, sourceFile.getFilePath());
+    sourceFile.forEachDescendant((node) => {
+      if (!Node.isJsxExpression(node)) {
+        return;
+      }
+      const expression = node.getExpression();
+      if (expression === undefined) {
+        return;
+      }
+      const identifier = rootIdentifierOf(expression);
+      if (identifier === undefined) {
+        return;
+      }
+      const declaration = declarationOf(identifier);
+      if (declaration === undefined) {
+        return;
+      }
+      const declKey = declKeyOf(declaration);
+      if (renderSites.has(declKey)) {
+        return;
+      }
+      const tag = renderSiteTag(node);
+      if (tag !== undefined) {
+        renderSites.set(declKey, {
+          tag,
+          usedAt: `${relativeFile}:${node.getStartLineNumber()}`
+        });
+      }
+    });
+  }
+  const entries = [];
+  for (const sourceFile of sourceFiles) {
+    const relativeFile = relative(projectDir, sourceFile.getFilePath());
+    const group = groupFor(relativeFile, hasAppDir);
+    const consumed = new Set;
+    const nodeKey = (node) => `${node.getPos()}:${node.getEnd()}`;
+    const push = (text, node, classified) => {
+      if (!detector.isCopy(text, classified)) {
+        return;
+      }
+      const declaration = classified.kind === "array-item" ? node.getFirstAncestorByKind(SyntaxKind.VariableDeclaration) : undefined;
+      const rendered = declaration ? renderSites.get(declKeyOf(declaration)) : undefined;
+      const tag = classified.kind === "jsx-text" ? tagNameOf(node) ?? enclosingTag(node) : rendered?.tag;
+      const owner = classified.kind === "jsx-attribute" ? node.getFirstAncestorByKind(SyntaxKind.JsxOpeningElement) ?? node.getFirstAncestorByKind(SyntaxKind.JsxSelfClosingElement) : undefined;
+      entries.push({
+        text,
+        file: relativeFile,
+        line: node.getStartLineNumber(),
+        group,
+        surface: surfaceFor(classified, relativeFile),
+        ...classified,
+        ...tag ? { tag } : {},
+        ...rendered ? { usedAt: rendered.usedAt } : {},
+        ...owner ? { elementLine: owner.getStartLineNumber() } : {},
+        ...conditionOf(node) ?? {}
+      });
+    };
+    sourceFile.forEachDescendant((node) => {
+      if (consumed.has(nodeKey(node))) {
+        return;
+      }
+      if (Node.isJsxElement(node) || Node.isJsxFragment(node)) {
+        const runs = mergeRuns(node, detector.hasCopyText);
+        const coversAll = runs.length === 1 && runs[0]?.nodes.length === node.getJsxChildren().length;
+        for (const run of runs) {
+          for (const child of run.nodes) {
+            consumed.add(nodeKey(child));
+            child.forEachDescendant((descendant, traversal) => {
+              if (Node.isJsxAttribute(descendant)) {
+                traversal.skip();
+                return;
+              }
+              consumed.add(nodeKey(descendant));
+            });
+          }
+          push(run.text, coversAll ? node : run.anchor, { kind: "jsx-text" });
+        }
+        return;
+      }
+      if (Node.isJsxText(node)) {
+        push(collapseWhitespace(node.getLiteralText()), node, classify(node));
+        return;
+      }
+      if (Node.isStringLiteral(node) || Node.isNoSubstitutionTemplateLiteral(node)) {
+        if (isModuleSpecifier(node) || isDirective(node)) {
+          return;
+        }
+        push(node.getLiteralText(), node, classify(node));
+        return;
+      }
+      if (Node.isTemplateExpression(node)) {
+        push(templateToText(node), node, classify(node));
+      }
+    });
+  }
+  const attrRank = (entry) => {
+    if (entry.attr === "label" || entry.attr === "legend") {
+      return 0;
+    }
+    if (entry.attr === "placeholder") {
+      return 2;
+    }
+    return entry.attr ? 3 : 1;
+  };
+  entries.sort((a, b) => a.group.localeCompare(b.group) || a.file.localeCompare(b.file) || (a.elementLine ?? a.line) - (b.elementLine ?? b.line) || attrRank(a) - attrRank(b) || a.line - b.line);
+  return {
+    projectDir,
+    srcGlob,
+    scannedFiles: sourceFiles.length,
+    generatedAt: new Date().toISOString(),
+    entries
+  };
+};
+
+// src/report-html.ts
+var toEmbeddedJson = (value) => JSON.stringify(value).replace(/</g, "\\u003c");
+var renderHtml = (result) => {
+  const data = toEmbeddedJson(result);
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>UI Strings — ${result.projectDir.split("/").at(-1) ?? ""}</title>
+<style>
+  :root {
+    --bg: #f6f7f9; --card: #ffffff; --text: #1a2233; --muted: #66708a;
+    --border: #e2e6ee; --accent: #2456c8; --accent-soft: #e8eefb;
+    --edit: #7a4dbf; --edit-soft: #f2ecfb;
+    font-family: "Hiragino Sans", "Noto Sans JP", system-ui, sans-serif;
+  }
+  * { box-sizing: border-box; }
+  body { margin: 0; background: var(--bg); color: var(--text); font-size: 14px; padding-bottom: 70px; }
+  header { padding: 20px 24px 0; }
+  h1 { margin: 0 0 4px; font-size: 20px; }
+  .meta { color: var(--muted); font-size: 12px; }
+  .stats { display: flex; flex-wrap: wrap; gap: 10px; padding: 14px 24px; }
+  .stat { background: var(--card); border: 1px solid var(--border); border-radius: 10px; padding: 8px 14px; }
+  .stat b { font-size: 18px; }
+  .stat span { color: var(--muted); font-size: 11px; display: block; }
+  .controls { display: flex; flex-wrap: wrap; gap: 8px; align-items: center; padding: 0 24px 12px; }
+  input[type="search"], select {
+    padding: 7px 10px; border: 1px solid var(--border); border-radius: 8px;
+    background: var(--card); color: var(--text); font-size: 13px;
+  }
+  input[type="search"] { min-width: 260px; }
+  .chip, .viewbtn {
+    border: 1px solid var(--border); background: var(--card); border-radius: 999px;
+    padding: 5px 12px; cursor: pointer; font-size: 12px; color: var(--muted);
+    font-family: ui-monospace, monospace;
+  }
+  .chip.active, .viewbtn.active { background: var(--accent-soft); border-color: var(--accent); color: var(--accent); }
+  .viewswitch { display: inline-flex; gap: 4px; margin-right: 8px; }
+  .viewbtn { font-family: inherit; }
+  main { padding: 0 24px 40px; max-width: 1200px; }
+  .empty { color: var(--muted); padding: 30px 0; text-align: center; }
+  mark { background: #ffe58a; border-radius: 3px; }
+
+  .ctx {
+    font-family: ui-monospace, monospace; font-size: 11px; color: var(--muted);
+    background: #f2f4f8; border: 1px solid var(--border); border-radius: 5px;
+    padding: 1px 6px; white-space: nowrap;
+  }
+  .cond {
+    font-family: ui-monospace, monospace; font-size: 11px; color: #8a6d1d;
+    background: #fdf6e3; border: 1px solid #eadfb8; border-radius: 5px;
+    padding: 1px 6px; white-space: nowrap;
+  }
+  .badge { font-family: ui-monospace, monospace; font-size: 11px; border-radius: 6px; padding: 2px 7px; background: var(--accent-soft); color: var(--accent); }
+  .badge.interactive { background: #fff3e0; color: #9a5b00; }
+  .badge.a11y { background: #eef2ee; color: #3d6b45; }
+  .badge.internal, .badge.meta { background: #f0f0f2; color: #6a6a72; }
+  .iconbtn {
+    border: none; background: none; cursor: pointer; font-size: 13px; color: var(--muted);
+    padding: 1px 4px; border-radius: 5px; visibility: hidden;
+  }
+  .iconbtn:hover { background: var(--accent-soft); }
+
+  /* page view */
+  .page { margin-top: 22px; border: 1px solid var(--border); border-radius: 12px; background: var(--card); overflow: hidden; }
+  .page-bar {
+    display: flex; align-items: center; gap: 8px; padding: 8px 14px;
+    background: #eef1f6; border-bottom: 1px solid var(--border);
+  }
+  .page-bar .route { font-family: ui-monospace, monospace; font-size: 12px; color: var(--muted);
+    background: var(--card); border: 1px solid var(--border); border-radius: 6px; padding: 2px 10px; }
+  .page-bar .count { margin-left: auto; font-size: 11px; color: var(--muted); }
+  .page-body { padding: 14px 20px 12px; }
+  .file-divider { display: flex; align-items: center; gap: 8px; margin: 12px 0 6px; color: var(--muted); font-size: 10.5px; font-family: ui-monospace, monospace; }
+  .file-divider::before, .file-divider::after { content: ""; flex: 1; border-top: 1px dashed var(--border); }
+  .item { display: flex; gap: 8px; align-items: baseline; padding: 3px 4px; border-radius: 6px; }
+  .item:hover { background: #fafbfd; }
+  .item:hover .iconbtn { visibility: visible; }
+  .item .txt { white-space: pre-line; line-height: 1.6; }
+  .item.edited .txt { text-decoration: line-through; text-decoration-color: #b3261e88; }
+  .item .newtxt { white-space: pre-line; line-height: 1.6; color: var(--edit); font-weight: 600; }
+  details { margin: 10px 0 4px; border-top: 1px solid var(--border); }
+  summary { cursor: pointer; padding: 8px 0; font-size: 12px; color: var(--muted); font-weight: 600; font-family: ui-monospace, monospace; }
+
+  /* table view */
+  .group { margin-top: 18px; }
+  .group > h2 {
+    font-size: 14px; margin: 0 0 6px; padding: 6px 10px; background: var(--accent-soft);
+    color: var(--accent); border-radius: 8px; display: inline-block;
+  }
+  .group-count { color: var(--muted); font-weight: normal; margin-left: 6px; }
+  table { width: 100%; border-collapse: collapse; background: var(--card); border: 1px solid var(--border); }
+  th, td { text-align: left; padding: 6px 10px; border-top: 1px solid var(--border); vertical-align: top; }
+  thead th { border-top: none; background: #fafbfd; color: var(--muted); font-size: 11px; font-weight: 600; }
+  td.text { width: 40%; white-space: pre-line; }
+  td.loc { color: var(--muted); font-size: 12px; white-space: nowrap; font-family: ui-monospace, monospace; }
+  td.mono { font-family: ui-monospace, monospace; font-size: 12px; color: var(--muted); white-space: nowrap; }
+  td.ops { white-space: nowrap; }
+  tr:hover .iconbtn { visibility: visible; }
+  .newtxt-cell { color: var(--edit); font-weight: 600; }
+
+  /* editor */
+  .editbox { flex: 1; }
+  .editbox textarea, #promptText {
+    width: 100%; min-height: 56px; padding: 8px; border: 1px solid var(--edit);
+    border-radius: 8px; font: inherit; font-size: 13px;
+  }
+  .editbox .row { display: flex; gap: 6px; margin-top: 4px; }
+  .smallbtn {
+    border: 1px solid var(--border); background: var(--card); border-radius: 6px;
+    padding: 4px 10px; cursor: pointer; font-size: 12px;
+  }
+  .smallbtn.primary { background: var(--edit); border-color: var(--edit); color: #fff; }
+
+  /* bottom bar and modal */
+  #fixbar {
+    position: fixed; left: 0; right: 0; bottom: 0; display: none; gap: 12px; align-items: center;
+    background: var(--edit-soft); border-top: 1px solid var(--edit); padding: 10px 24px; z-index: 10;
+  }
+  #fixbar.show { display: flex; }
+  #fixbar b { color: var(--edit); }
+  #modal {
+    display: none; position: fixed; inset: 0; background: rgba(20,25,40,0.45); z-index: 20;
+    align-items: center; justify-content: center;
+  }
+  #modal.show { display: flex; }
+  #modal .box { background: var(--card); border-radius: 12px; padding: 18px; width: min(760px, 92vw); }
+  #modal h2 { margin: 0 0 10px; font-size: 15px; }
+  #promptText { min-height: 320px; font-family: ui-monospace, monospace; font-size: 12px; }
+  #modal .row { display: flex; gap: 8px; margin-top: 10px; justify-content: flex-end; }
+</style>
+</head>
+<body>
+<header>
+  <h1>UI Strings</h1>
+  <div class="meta" id="meta"></div>
+</header>
+<div class="stats" id="stats"></div>
+<div class="controls">
+  <span class="viewswitch">
+    <button class="viewbtn active" id="btnPage">Page view</button>
+    <button class="viewbtn" id="btnTable">Table view</button>
+  </span>
+  <input type="search" id="search" placeholder="Search text or file name…" />
+  <select id="groupSelect"><option value="">All groups</option></select>
+  <span id="chips"></span>
+</div>
+<main id="list"></main>
+<div id="fixbar">
+  <b><span id="editCount"></span> edits</b>
+  <button class="smallbtn primary" id="btnCopyAll">Copy fix prompt</button>
+  <button class="smallbtn" id="btnGenerate">Preview prompt</button>
+  <button class="smallbtn" id="btnClearEdits">Clear</button>
+</div>
+<div id="modal">
+  <div class="box">
+    <h2>Fix Prompt</h2>
+    <textarea id="promptText" readonly></textarea>
+    <div class="row">
+      <button class="smallbtn primary" id="btnCopyPrompt">Copy</button>
+      <button class="smallbtn" id="btnCloseModal">Close</button>
+    </div>
+  </div>
+</div>
+<script type="application/json" id="data">${data}</script>
+<script>
+const RESULT = JSON.parse(document.getElementById("data").textContent);
+RESULT.entries.forEach((e, i) => { e.id = i; });
+const SURFACES = ["visible", "interactive", "a11y", "meta", "internal"];
+const state = { view: "page", query: "", group: "", surfaces: new Set(), editingId: null };
+
+const STORAGE_KEY = "ui-strings-edits:" + RESULT.projectDir;
+const editKey = (e) => e.file + ":" + e.line + ":" + e.text;
+let edits = {};
+try { edits = JSON.parse(localStorage.getItem(STORAGE_KEY) || "{}"); } catch { edits = {}; }
+const saveEdits = () => localStorage.setItem(STORAGE_KEY, JSON.stringify(edits));
+
+const escapeHtml = (s) => s.replace(/[&<>"]/g, (c) => ({"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;"}[c]));
+const highlight = (s, q) => {
+  const escaped = escapeHtml(s);
+  if (!q) return escaped;
+  const eq = escapeHtml(q).replace(/[.*+?^\${}()|[\\]\\\\]/g, "\\\\$&");
+  return escaped.replace(new RegExp(eq, "gi"), (m) => "<mark>" + m + "</mark>");
+};
+const contextOf = (e) =>
+  e.kind === "array-item" && e.key ? (e.tag ? e.key + " → <" + e.tag + ">" : e.key) :
+  e.attr ? e.attr + "=" : e.callee ? e.callee + "()" : e.key ? e.key + ":" : e.tag ? "<" + e.tag + ">" : "";
+const condOf = (e) => {
+  if (!e.condition) return "";
+  if (e.branch === "else") {
+    return /^[A-Za-z_$][\\w$.]*$/.test(e.condition) ? "!" + e.condition : "!(" + e.condition + ")";
+  }
+  return e.condition;
+};
+const locOf = (e) => e.file + ":" + e.line;
+
+function copyText(text) {
+  if (navigator.clipboard) return navigator.clipboard.writeText(text);
+  const ta = document.createElement("textarea");
+  ta.value = text; document.body.appendChild(ta); ta.select();
+  document.execCommand("copy"); ta.remove();
+  return Promise.resolve();
+}
+
+function matches(e) {
+  if (e.surface === "internal" && !state.surfaces.has("internal")) return false;
+  if (state.surfaces.size && !state.surfaces.has(e.surface)) return false;
+  if (state.group && e.group !== state.group) return false;
+  if (state.query) {
+    const q = state.query.toLowerCase();
+    if (!e.text.toLowerCase().includes(q) && !e.file.toLowerCase().includes(q)) return false;
+  }
+  return true;
+}
+
+function chipsHtml(e) {
+  const ctx = contextOf(e);
+  const cond = condOf(e);
+  const ctxTitle = e.usedAt ? ' title="render: ' + escapeHtml(e.usedAt) + '"' : "";
+  return (ctx ? '<span class="ctx"' + ctxTitle + ">" + escapeHtml(ctx) + "</span>" : "") +
+    (cond ? '<span class="cond" title="branching condition">' + escapeHtml(cond) + "</span>" : "");
+}
+
+function editorHtml(e) {
+  const current = edits[editKey(e)]?.newText ?? e.text;
+  return '<span class="editbox">' +
+    '<textarea data-edit-input="' + e.id + '">' + escapeHtml(current) + "</textarea>" +
+    '<span class="row">' +
+    '<button class="smallbtn primary" data-edit-save="' + e.id + '">Save</button>' +
+    '<button class="smallbtn" data-edit-cancel="' + e.id + '">Cancel</button>' +
+    (edits[editKey(e)] ? '<button class="smallbtn" data-edit-remove="' + e.id + '">Discard edit</button>' : "") +
+    "</span></span>";
+}
+
+function textHtml(e) {
+  const edit = edits[editKey(e)];
+  let html = '<span class="txt">' + highlight(e.text, state.query) + "</span>";
+  if (edit) html += '<span class="newtxt">→ ' + escapeHtml(edit.newText) + "</span>";
+  return html;
+}
+
+function itemButtons(e) {
+  return '<button class="iconbtn" data-edit="' + e.id + '" title="Edit text">✎</button>' +
+    '<button class="iconbtn" data-copy="' + e.id + '" title="Copy row (TSV)">\uD83D\uDCCB</button>';
+}
+
+function renderPageView(entries) {
+  const groups = new Map();
+  for (const e of entries) {
+    if (!groups.has(e.group)) groups.set(e.group, []);
+    groups.get(e.group).push(e);
+  }
+  let html = "";
+  for (const [group, items] of groups) {
+    const visible = items.filter((e) => e.surface === "visible");
+    const rest = new Map();
+    for (const e of items) {
+      if (e.surface === "visible") continue;
+      if (!rest.has(e.surface)) rest.set(e.surface, []);
+      rest.get(e.surface).push(e);
+    }
+    html += '<section class="page"><div class="page-bar">' +
+      '<span class="route">' + escapeHtml(group) + '</span>' +
+      '<span class="count">' + items.length + " items</span></div><div class=\\"page-body\\">";
+    let currentFile = "";
+    const renderItem = (e) => {
+      if (state.editingId === e.id) {
+        return '<div class="item">' + chipsHtml(e) + editorHtml(e) + "</div>";
+      }
+      return '<div class="item' + (edits[editKey(e)] ? " edited" : "") + '" title="' + escapeHtml(locOf(e)) + '">' +
+        chipsHtml(e) + textHtml(e) + itemButtons(e) + "</div>";
+    };
+    for (const e of visible) {
+      if (e.file !== currentFile) {
+        currentFile = e.file;
+        html += '<div class="file-divider">' + escapeHtml(e.file.split("/").pop()) + "</div>";
+      }
+      html += renderItem(e);
+    }
+    for (const [surface, list] of rest) {
+      html += "<details" + (list.some((e) => state.editingId === e.id) ? " open" : "") +
+        "><summary>" + surface + " (" + list.length + ")</summary>";
+      for (const e of list) html += renderItem(e);
+      html += "</details>";
+    }
+    html += "</div></section>";
+  }
+  return html;
+}
+
+function renderTableView(entries) {
+  const groups = new Map();
+  for (const e of entries) {
+    if (!groups.has(e.group)) groups.set(e.group, []);
+    groups.get(e.group).push(e);
+  }
+  let html = "";
+  for (const [group, items] of groups) {
+    html += '<section class="group"><h2>' + escapeHtml(group) +
+      '<span class="group-count">' + items.length + " items</span></h2>";
+    html += "<table><thead><tr><th>text</th><th>surface</th><th>kind</th><th>context</th><th>location</th><th></th></tr></thead><tbody>";
+    for (const e of items) {
+      const edit = edits[editKey(e)];
+      const cond = condOf(e);
+      const textCell = state.editingId === e.id
+        ? editorHtml(e)
+        : highlight(e.text, state.query) +
+          (edit ? '<div class="newtxt-cell">→ ' + escapeHtml(edit.newText) + "</div>" : "");
+      html += "<tr><td class=\\"text\\">" + textCell + "</td>" +
+        '<td class="mono"><span class="badge ' + e.surface + '">' + e.surface + "</span></td>" +
+        '<td class="mono">' + e.kind + "</td>" +
+        '<td class="mono"' + (e.usedAt ? ' title="render: ' + escapeHtml(e.usedAt) + '"' : "") + ">" + escapeHtml(contextOf(e)) +
+        (cond ? ' <span class="cond">' + escapeHtml(cond) + "</span>" : "") + "</td>" +
+        '<td class="loc">' + highlight(locOf(e), state.query) + "</td>" +
+        '<td class="ops">' + itemButtons(e) + "</td></tr>";
+    }
+    html += "</tbody></table></section>";
+  }
+  return html;
+}
+
+function render() {
+  const entries = RESULT.entries.filter(matches);
+  const uniqueTexts = new Set(entries.map((e) => e.text)).size;
+  const files = new Set(entries.map((e) => e.file)).size;
+  document.getElementById("meta").textContent =
+    RESULT.projectDir + "  /  " + RESULT.srcGlob + "  /  generated: " + RESULT.generatedAt;
+  document.getElementById("stats").innerHTML =
+    '<div class="stat"><b>' + entries.length + "</b><span>strings shown</span></div>" +
+    '<div class="stat"><b>' + uniqueTexts + "</b><span>unique strings</span></div>" +
+    '<div class="stat"><b>' + files + "</b><span>files</span></div>" +
+    '<div class="stat"><b>' + RESULT.scannedFiles + "</b><span>files scanned</span></div>";
+  const list = document.getElementById("list");
+  list.innerHTML = entries.length
+    ? (state.view === "page" ? renderPageView(entries) : renderTableView(entries))
+    : '<div class="empty">No matching strings</div>';
+  renderFixbar();
+}
+
+function renderFixbar() {
+  const count = Object.keys(edits).length;
+  const bar = document.getElementById("fixbar");
+  bar.classList.toggle("show", count > 0);
+  document.getElementById("editCount").textContent = count;
+}
+
+function generatePrompt() {
+  const list = Object.values(edits);
+  const lines = [];
+  lines.push("Update the following UI strings. Target repository: " + RESULT.projectDir);
+  lines.push("Change only string literals and JSX text. Do not change logic or markup structure.");
+  lines.push('Each location is given as "file path:line number". A merged string may span multiple nodes across <br> or inline elements.');
+  lines.push("");
+  list.forEach((edit, i) => {
+    lines.push((i + 1) + ". " + edit.file + ":" + edit.line);
+    lines.push("   Current: " + edit.text.replace(/\\n/g, "\\\\n"));
+    lines.push("   Replace with: " + edit.newText.replace(/\\n/g, "\\\\n"));
+  });
+  return lines.join("\\n");
+}
+
+document.getElementById("list").addEventListener("click", (event) => {
+  const target = event.target.closest("button");
+  if (!target) return;
+  const byId = (value) => RESULT.entries[Number(value)];
+  if (target.dataset.edit !== undefined) {
+    state.editingId = Number(target.dataset.edit);
+    render();
+    const ta = document.querySelector('[data-edit-input="' + state.editingId + '"]');
+    if (ta) { ta.focus(); ta.setSelectionRange(ta.value.length, ta.value.length); }
+  } else if (target.dataset.copy !== undefined) {
+    const e = byId(target.dataset.copy);
+    copyText([e.text, e.surface, e.kind, contextOf(e), locOf(e)].join("\\t"));
+    target.textContent = "✓";
+    setTimeout(() => { target.textContent = "\uD83D\uDCCB"; }, 800);
+  } else if (target.dataset.editSave !== undefined) {
+    const e = byId(target.dataset.editSave);
+    const ta = document.querySelector('[data-edit-input="' + e.id + '"]');
+    const newText = ta.value;
+    if (newText !== e.text && newText.trim() !== "") {
+      edits[editKey(e)] = { file: e.file, line: e.line, text: e.text, newText };
+    } else {
+      delete edits[editKey(e)];
+    }
+    saveEdits();
+    state.editingId = null;
+    render();
+  } else if (target.dataset.editCancel !== undefined) {
+    state.editingId = null;
+    render();
+  } else if (target.dataset.editRemove !== undefined) {
+    const e = byId(target.dataset.editRemove);
+    delete edits[editKey(e)];
+    saveEdits();
+    state.editingId = null;
+    render();
+  }
+});
+
+document.getElementById("btnCopyAll").onclick = (event) => {
+  copyText(generatePrompt());
+  event.target.textContent = "Copied ✓";
+  setTimeout(() => { event.target.textContent = "Copy fix prompt"; }, 1200);
+};
+document.getElementById("btnGenerate").onclick = () => {
+  document.getElementById("promptText").value = generatePrompt();
+  document.getElementById("modal").classList.add("show");
+};
+document.getElementById("btnCopyPrompt").onclick = (event) => {
+  copyText(document.getElementById("promptText").value);
+  event.target.textContent = "Copied";
+  setTimeout(() => { event.target.textContent = "Copy"; }, 1000);
+};
+document.getElementById("btnCloseModal").onclick = () =>
+  document.getElementById("modal").classList.remove("show");
+document.getElementById("btnClearEdits").onclick = () => {
+  edits = {};
+  saveEdits();
+  render();
+};
+
+const surfaceCounts = new Map();
+for (const e of RESULT.entries) surfaceCounts.set(e.surface, (surfaceCounts.get(e.surface) ?? 0) + 1);
+const chips = document.getElementById("chips");
+for (const surface of SURFACES) {
+  const count = surfaceCounts.get(surface) ?? 0;
+  if (!count) continue;
+  const chip = document.createElement("button");
+  chip.className = "chip";
+  chip.textContent = surface + " " + count;
+  chip.onclick = () => {
+    state.surfaces.has(surface) ? state.surfaces.delete(surface) : state.surfaces.add(surface);
+    chip.classList.toggle("active");
+    render();
+  };
+  chips.appendChild(chip);
+}
+
+const btnPage = document.getElementById("btnPage");
+const btnTable = document.getElementById("btnTable");
+btnPage.onclick = () => { state.view = "page"; btnPage.classList.add("active"); btnTable.classList.remove("active"); render(); };
+btnTable.onclick = () => { state.view = "table"; btnTable.classList.add("active"); btnPage.classList.remove("active"); render(); };
+
+const groupSelect = document.getElementById("groupSelect");
+for (const group of [...new Set(RESULT.entries.map((e) => e.group))].sort()) {
+  const option = document.createElement("option");
+  option.value = group;
+  option.textContent = group;
+  groupSelect.appendChild(option);
+}
+groupSelect.onchange = () => { state.group = groupSelect.value; render(); };
+document.getElementById("search").oninput = (event) => {
+  state.query = event.target.value.trim();
+  render();
+};
+render();
+</script>
+</body>
+</html>
+`;
+};
+
+// src/report-md.ts
+var escapeCell = (text) => text.replace(/\|/g, "\\|").replace(/\n/g, "<br>");
+var countBy = (entries, keyOf) => {
+  const counts = new Map;
+  for (const entry of entries) {
+    const key = keyOf(entry);
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  return counts;
+};
+var contextOf = (entry) => {
+  const parts = [];
+  if (entry.kind === "array-item" && entry.key) {
+    parts.push(entry.tag ? `\`${entry.key}\` → \`<${entry.tag}>\`` : `\`${entry.key}\``);
+  } else if (entry.attr) {
+    parts.push(`\`${entry.attr}=\``);
+  } else if (entry.callee) {
+    parts.push(`\`${entry.callee}()\``);
+  } else if (entry.key) {
+    parts.push(`\`${entry.key}:\``);
+  } else if (entry.tag) {
+    parts.push(`\`<${entry.tag}>\``);
+  }
+  if (entry.condition) {
+    const negated = entry.branch === "else" ? `!(${entry.condition})` : entry.condition;
+    parts.push(`cond: \`${negated}\``);
+  }
+  return parts.join(" ");
+};
+var renderMarkdown = (result, visibleEntries) => {
+  const lines = [];
+  lines.push("# UI Strings");
+  lines.push("");
+  lines.push(`- Target: \`${result.projectDir}\` (\`${result.srcGlob}\`)`);
+  lines.push(`- Generated: ${result.generatedAt}`);
+  lines.push(`- Strings: **${visibleEntries.length}** / Files scanned: ${result.scannedFiles}`);
+  lines.push("");
+  lines.push("## Count by surface");
+  lines.push("");
+  lines.push("| surface | count |");
+  lines.push("| --- | ---: |");
+  const surfaceCounts = countBy(visibleEntries, (entry) => entry.surface);
+  for (const [surface, count] of [...surfaceCounts.entries()].sort((a, b) => b[1] - a[1])) {
+    lines.push(`| \`${surface}\` | ${count} |`);
+  }
+  lines.push("");
+  lines.push("## Count by kind");
+  lines.push("");
+  lines.push("| kind | count |");
+  lines.push("| --- | ---: |");
+  const kindCounts = countBy(visibleEntries, (entry) => entry.kind);
+  for (const [kind, count] of [...kindCounts.entries()].sort((a, b) => b[1] - a[1])) {
+    lines.push(`| \`${kind}\` | ${count} |`);
+  }
+  lines.push("");
+  lines.push("## Count by group");
+  lines.push("");
+  lines.push("| group | count |");
+  lines.push("| --- | ---: |");
+  const groupCounts = countBy(visibleEntries, (entry) => entry.group);
+  for (const [group, count] of [...groupCounts.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
+    lines.push(`| ${group} | ${count} |`);
+  }
+  lines.push("");
+  lines.push("## All strings");
+  let currentGroup = "";
+  let currentFile = "";
+  for (const entry of visibleEntries) {
+    if (entry.group !== currentGroup) {
+      currentGroup = entry.group;
+      currentFile = "";
+      lines.push("");
+      lines.push(`### ${currentGroup}`);
+    }
+    if (entry.file !== currentFile) {
+      currentFile = entry.file;
+      lines.push("");
+      lines.push(`#### ${currentFile}`);
+      lines.push("");
+      lines.push("| line | surface | context | text |");
+      lines.push("| ---: | --- | --- | --- |");
+    }
+    lines.push(`| ${entry.line} | \`${entry.surface}\` | ${contextOf(entry)} | ${escapeCell(entry.text)} |`);
+  }
+  lines.push("");
+  return lines.join(`
+`);
+};
+
+// src/cli.ts
+var program = new Command;
+program.name("ui-strings").description("Extract user-reachable UI strings from a React (TS/TSX) codebase and generate reports").version("0.1.0");
+program.command("scan").argument("[projectDir]", "root directory of the target project", ".").option("--src <glob>", "glob of files to scan", "src/**/*.{ts,tsx,js,jsx}").option("--exclude <globs>", "extra exclude globs (comma-separated; test/spec/__tests__ are always excluded)", "").option("--out <dir>", "output directory", "./ui-strings-report").option("--format <list>", "output formats (json,md,html)", "json,md,html").option("--include-internal", "include console/throw strings in the Markdown listing", false).option("--open", "open the HTML report in a browser after generation", false).action(async (projectDirArg, options) => {
+  const projectDir = resolve(projectDirArg);
+  const formats = new Set(options.format.split(",").map((format) => format.trim()));
+  console.log(pc.dim(`Scanning: ${projectDir}/${options.src}`));
+  const result = scanProject({
+    projectDir,
+    srcGlob: options.src,
+    exclude: options.exclude.split(",").map((glob) => glob.trim()).filter((glob) => glob !== "")
+  });
+  const visibleEntries = options.includeInternal ? result.entries : result.entries.filter((entry) => entry.kind !== "internal");
+  const outDir = resolve(options.out);
+  mkdirSync(outDir, { recursive: true });
+  const written = [];
+  if (formats.has("json")) {
+    const path = join2(outDir, "ui-strings.json");
+    writeFileSync(path, JSON.stringify(result, null, 2));
+    written.push(path);
+  }
+  if (formats.has("md")) {
+    const path = join2(outDir, "ui-strings.md");
+    writeFileSync(path, renderMarkdown(result, visibleEntries));
+    written.push(path);
+  }
+  let htmlPath;
+  if (formats.has("html")) {
+    htmlPath = join2(outDir, "ui-strings.html");
+    writeFileSync(htmlPath, renderHtml(result));
+    written.push(htmlPath);
+  }
+  const surfaceCounts = new Map;
+  for (const entry of result.entries) {
+    surfaceCounts.set(entry.surface, (surfaceCounts.get(entry.surface) ?? 0) + 1);
+  }
+  const internalCount = surfaceCounts.get("internal") ?? 0;
+  console.log();
+  console.log(pc.bold(`${pc.green(String(visibleEntries.length))} strings` + (internalCount > 0 ? pc.dim(` (+${internalCount} internal)`) : "")) + pc.dim(` / ${result.scannedFiles} files scanned`));
+  for (const [surface, count] of [...surfaceCounts.entries()].sort((a, b) => b[1] - a[1])) {
+    console.log(`  ${surface.padEnd(12)} ${count}`);
+  }
+  console.log();
+  for (const path of written) {
+    console.log(pc.dim(`→ ${path}`));
+  }
+  if (options.open && htmlPath) {
+    const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+    spawn(opener, [htmlPath], { detached: true, stdio: "ignore" }).unref();
+  }
+});
+await program.parseAsync();