github-mobile-reader 0.1.1 → 0.1.2

package/dist/cli.js

@@ -0,0 +1,552 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+
+// src/parser.ts
+function isJSXFile(filename) {
+  return /\.(jsx|tsx)$/.test(filename);
+}
+function hasJSXContent(lines) {
+  return lines.some((l) => /<[A-Z][A-Za-z]*[\s/>]/.test(l) || /return\s*\(/.test(l));
+}
+function isClassNameOnlyLine(line) {
+  return /^className=/.test(line.trim());
+}
+function extractClassName(line) {
+  const staticMatch = line.match(/className="([^"]*)"/);
+  if (staticMatch) return staticMatch[1];
+  const ternaryMatch = line.match(/className=\{[^?]+\?\s*"([^"]*)"\s*:\s*"([^"]*)"\}/);
+  if (ternaryMatch) return `${ternaryMatch[1]} ${ternaryMatch[2]}`;
+  const templateMatch = line.match(/className=\{`([^`]*)`\}/);
+  if (templateMatch) {
+    const raw = templateMatch[1];
+    const literals = raw.replace(/\$\{[^}]*\}/g, " ").trim();
+    const exprStrings = [...raw.matchAll(/"([^"]*)"/g)].map((m) => m[1]);
+    return [literals, ...exprStrings].filter(Boolean).join(" ");
+  }
+  return null;
+}
+function extractComponentFromLine(line) {
+  const tagMatch = line.match(/<([A-Za-z][A-Za-z0-9.]*)/);
+  if (tagMatch) return tagMatch[1];
+  return "unknown";
+}
+function parseClassNameChanges(addedLines, removedLines) {
+  const componentMap = /* @__PURE__ */ new Map();
+  for (const line of addedLines.filter((l) => /className=/.test(l))) {
+    const cls = extractClassName(line);
+    const comp = extractComponentFromLine(line);
+    if (!cls) continue;
+    if (!componentMap.has(comp)) componentMap.set(comp, { added: /* @__PURE__ */ new Set(), removed: /* @__PURE__ */ new Set() });
+    cls.split(/\s+/).filter(Boolean).forEach((c) => componentMap.get(comp).added.add(c));
+  }
+  for (const line of removedLines.filter((l) => /className=/.test(l))) {
+    const cls = extractClassName(line);
+    const comp = extractComponentFromLine(line);
+    if (!cls) continue;
+    if (!componentMap.has(comp)) componentMap.set(comp, { added: /* @__PURE__ */ new Set(), removed: /* @__PURE__ */ new Set() });
+    cls.split(/\s+/).filter(Boolean).forEach((c) => componentMap.get(comp).removed.add(c));
+  }
+  const changes = [];
+  for (const [comp, { added, removed }] of componentMap) {
+    const pureAdded = [...added].filter((c) => !removed.has(c));
+    const pureRemoved = [...removed].filter((c) => !added.has(c));
+    if (pureAdded.length === 0 && pureRemoved.length === 0) continue;
+    changes.push({ component: comp, added: pureAdded, removed: pureRemoved });
+  }
+  return changes;
+}
+function renderStyleChanges(changes) {
+  const lines = [];
+  for (const change of changes) {
+    lines.push(`**${change.component}**`);
+    if (change.added.length > 0) lines.push(`  + ${change.added.join("  ")}`);
+    if (change.removed.length > 0) lines.push(`  - ${change.removed.join("  ")}`);
+  }
+  return lines;
+}
+function isJSXElement(line) {
+  const t = line.trim();
+  return /^<[A-Za-z]/.test(t) || /^<\/[A-Za-z]/.test(t);
+}
+function isJSXClosing(line) {
+  return /^<\/[A-Za-z]/.test(line.trim());
+}
+function isJSXSelfClosing(line) {
+  return /\/>[\s]*$/.test(line.trim());
+}
+function extractJSXComponentName(line) {
+  const trimmed = line.trim();
+  const closingMatch = trimmed.match(/^<\/([A-Za-z][A-Za-z0-9.]*)/);
+  if (closingMatch) return `/${closingMatch[1]}`;
+  const nameMatch = trimmed.match(/^<([A-Za-z][A-Za-z0-9.]*)/);
+  if (!nameMatch) return trimmed;
+  const name = nameMatch[1];
+  const eventProps = [];
+  for (const m of trimmed.matchAll(/\b(on[A-Z]\w+)=/g)) {
+    eventProps.push(m[1]);
+  }
+  return eventProps.length > 0 ? `${name}(${eventProps.join(", ")})` : name;
+}
+function shouldIgnoreJSX(line) {
+  const t = line.trim();
+  return isClassNameOnlyLine(t) || /^style=/.test(t) || /^aria-/.test(t) || /^data-/.test(t) || /^strokeLinecap=/.test(t) || /^strokeLinejoin=/.test(t) || /^strokeWidth=/.test(t) || /^viewBox=/.test(t) || /^fill=/.test(t) || /^stroke=/.test(t) || /^d="/.test(t) || t === "{" || t === "}" || t === "(" || t === ")" || t === "<>" || t === "</>" || /^\{\/\*/.test(t);
+}
+function parseJSXToFlowTree(lines) {
+  const roots = [];
+  const stack = [];
+  for (const line of lines) {
+    if (!isJSXElement(line)) continue;
+    if (shouldIgnoreJSX(line)) continue;
+    const depth = getIndentDepth(line);
+    if (isJSXClosing(line)) {
+      while (stack.length > 0 && stack[stack.length - 1].depth >= depth) {
+        stack.pop();
+      }
+      continue;
+    }
+    const name = extractJSXComponentName(line);
+    const selfClosing = isJSXSelfClosing(line);
+    const node = {
+      type: "call",
+      name,
+      children: [],
+      depth,
+      priority: 5 /* OTHER */
+    };
+    while (stack.length > 0 && stack[stack.length - 1].depth >= depth) {
+      stack.pop();
+    }
+    if (stack.length === 0) {
+      roots.push(node);
+    } else {
+      stack[stack.length - 1].node.children.push(node);
+    }
+    if (!selfClosing) {
+      stack.push({ node, depth });
+    }
+  }
+  return roots;
+}
+function filterDiffLines(diffText) {
+  const lines = diffText.split("\n");
+  const added = lines.filter((l) => l.startsWith("+") && !l.startsWith("+++") && l.trim() !== "+").map((l) => l.substring(1));
+  const removed = lines.filter((l) => l.startsWith("-") && !l.startsWith("---") && l.trim() !== "-").map((l) => l.substring(1));
+  return { added, removed };
+}
+function normalizeCode(lines) {
+  return lines.map((line) => {
+    let normalized = line;
+    normalized = normalized.replace(/\/\/.*$/, "");
+    normalized = normalized.replace(/\/\*.*?\*\//, "");
+    normalized = normalized.trim();
+    normalized = normalized.replace(/;$/, "");
+    return normalized;
+  }).filter((line) => line.length > 0);
+}
+function getIndentDepth(line) {
+  const match = line.match(/^(\s*)/);
+  if (!match) return 0;
+  return Math.floor(match[1].length / 2);
+}
+function isChaining(line, prevLine) {
+  if (!prevLine) return false;
+  if (!line.trim().startsWith(".")) return false;
+  if (!prevLine.match(/[)\}]$/)) return false;
+  return true;
+}
+function extractChainMethod(line) {
+  const match = line.match(/\.(\w+)\(/);
+  if (match) return `${match[1]}()`;
+  return line.trim();
+}
+function simplifyCallback(methodCall) {
+  const arrowMatch = methodCall.match(/(\w+)\((\w+)\s*=>\s*(\w+)\.(\w+)\)/);
+  if (arrowMatch) {
+    const [, method, param, , prop] = arrowMatch;
+    return `${method}(${param} \u2192 ${prop})`;
+  }
+  const callbackMatch = methodCall.match(/(\w+)\([^)]+\)/);
+  if (callbackMatch) return `${callbackMatch[1]}(callback)`;
+  return methodCall;
+}
+function isConditional(line) {
+  return /^(if|else|switch)\s*[\(\{]/.test(line.trim());
+}
+function isLoop(line) {
+  return /^(for|while)\s*\(/.test(line.trim());
+}
+function isFunctionDeclaration(line) {
+  const t = line.trim();
+  return (
+    // function foo() / async function foo()
+    /^(async\s+)?function\s+\w+/.test(t) || // const foo = () => / const foo = async () => / const foo = async (x: T) =>
+    /^(const|let|var)\s+\w+\s*=\s*(async\s*)?\(/.test(t) || // const foo = function / const foo = async function
+    /^(const|let|var)\s+\w+\s*=\s*(async\s+)?function/.test(t)
+  );
+}
+function shouldIgnore(line) {
+  const ignorePatterns = [
+    /^import\s+/,
+    /^export\s+/,
+    /^type\s+/,
+    /^interface\s+/,
+    /^console\./,
+    /^return$/,
+    /^throw\s+/
+  ];
+  return ignorePatterns.some((p) => p.test(line.trim()));
+}
+function extractRoot(line) {
+  const assignMatch = line.match(/(?:const|let|var)\s+(\w+)\s*=\s*(\w+)/);
+  if (assignMatch) return assignMatch[2];
+  const callMatch = line.match(/^(\w+)\(/);
+  if (callMatch) return `${callMatch[1]}()`;
+  const methodMatch = line.match(/^(\w+)\./);
+  if (methodMatch) return methodMatch[1];
+  return null;
+}
+function parseToFlowTree(lines) {
+  const roots = [];
+  let currentChain = null;
+  let prevLine = null;
+  let baseDepth = -1;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (shouldIgnore(line)) {
+      prevLine = line;
+      continue;
+    }
+    const depth = getIndentDepth(lines[i]);
+    if (baseDepth === -1) baseDepth = depth;
+    const relativeDepth = depth - baseDepth;
+    if (isChaining(line, prevLine)) {
+      const method = extractChainMethod(line);
+      const simplified = simplifyCallback(method);
+      if (currentChain) {
+        const chainNode = {
+          type: "chain",
+          name: simplified,
+          children: [],
+          depth: relativeDepth,
+          priority: 1 /* CHAINING */
+        };
+        let parent = currentChain;
+        while (parent.children.length > 0 && parent.children[parent.children.length - 1].depth >= relativeDepth) {
+          const last = parent.children[parent.children.length - 1];
+          if (last.children.length > 0) parent = last;
+          else break;
+        }
+        parent.children.push(chainNode);
+      }
+      prevLine = line;
+      continue;
+    }
+    if (isFunctionDeclaration(line)) {
+      const funcMatch = line.match(/(?:function|const|let|var)\s+(\w+)/);
+      roots.push({
+        type: "function",
+        name: funcMatch ? `${funcMatch[1]}()` : "function()",
+        children: [],
+        depth: relativeDepth,
+        priority: 4 /* FUNCTION */
+      });
+      currentChain = null;
+      prevLine = line;
+      continue;
+    }
+    const root = extractRoot(line);
+    if (root) {
+      currentChain = {
+        type: "root",
+        name: root,
+        children: [],
+        depth: relativeDepth,
+        priority: 1 /* CHAINING */
+      };
+      roots.push(currentChain);
+    } else if (isConditional(line)) {
+      const condMatch = line.match(/(if|else|switch)\s*\(([^)]+)\)/);
+      const condName = condMatch ? `${condMatch[1]} (${condMatch[2]})` : line.trim();
+      roots.push({
+        type: "condition",
+        name: condName,
+        children: [],
+        depth: relativeDepth,
+        priority: 2 /* CONDITIONAL */
+      });
+      currentChain = null;
+    } else if (isLoop(line)) {
+      roots.push({
+        type: "loop",
+        name: "loop",
+        children: [],
+        depth: relativeDepth,
+        priority: 3 /* LOOP */
+      });
+      currentChain = null;
+    }
+    prevLine = line;
+  }
+  return roots;
+}
+function renderFlowTree(nodes, indent = 0) {
+  const lines = [];
+  const prefix = indent === 0 ? "" : " ".repeat((indent - 1) * 4) + " \u2514\u2500 ";
+  for (const node of nodes) {
+    lines.push(prefix + node.name);
+    if (node.children.length > 0) {
+      lines.push(...renderFlowTree(node.children, indent + 1));
+    }
+  }
+  return lines;
+}
+function generateReaderMarkdown(diffText, meta = {}) {
+  const { added, removed } = filterDiffLines(diffText);
+  const isJSX = Boolean(
+    meta.file && isJSXFile(meta.file) || hasJSXContent(added)
+  );
+  const addedForFlow = isJSX ? added.filter((l) => !isClassNameOnlyLine(l)) : added;
+  const normalizedAdded = normalizeCode(addedForFlow);
+  const flowTree = parseToFlowTree(normalizedAdded);
+  const rawCode = addedForFlow.join("\n");
+  const removedForCode = isJSX ? removed.filter((l) => !isClassNameOnlyLine(l)) : removed;
+  const removedCode = removedForCode.join("\n");
+  const classNameChanges = isJSX ? parseClassNameChanges(added, removed) : [];
+  const jsxTree = isJSX ? parseJSXToFlowTree(added) : [];
+  const sections = [];
+  const lang = isJSX ? "tsx" : "typescript";
+  sections.push("# \u{1F4D6} GitHub Reader View\n");
+  sections.push("> Generated by **github-mobile-reader**");
+  if (meta.repo) sections.push(`> Repository: ${meta.repo}`);
+  if (meta.pr) sections.push(`> Pull Request: #${meta.pr}`);
+  if (meta.commit) sections.push(`> Commit: \`${meta.commit}\``);
+  if (meta.file) sections.push(`> File: \`${meta.file}\``);
+  sections.push("\n");
+  if (flowTree.length > 0) {
+    sections.push("## \u{1F9E0} Logical Flow\n");
+    sections.push("```");
+    sections.push(...renderFlowTree(flowTree));
+    sections.push("```\n");
+  }
+  if (isJSX && jsxTree.length > 0) {
+    sections.push("## \u{1F3A8} JSX Structure\n");
+    sections.push("```");
+    sections.push(...renderFlowTree(jsxTree));
+    sections.push("```\n");
+  }
+  if (isJSX && classNameChanges.length > 0) {
+    sections.push("## \u{1F485} Style Changes\n");
+    sections.push(...renderStyleChanges(classNameChanges));
+    sections.push("");
+  }
+  if (rawCode.trim()) {
+    sections.push("## \u2705 Added Code\n");
+    sections.push(`\`\`\`${lang}`);
+    sections.push(rawCode);
+    sections.push("```\n");
+  }
+  if (removedCode.trim()) {
+    sections.push("## \u274C Removed Code\n");
+    sections.push(`\`\`\`${lang}`);
+    sections.push(removedCode);
+    sections.push("```\n");
+  }
+  sections.push("---");
+  sections.push("\u{1F6E0} Auto-generated by [github-mobile-reader](https://github.com/your-org/github-mobile-reader). Do not edit manually.");
+  return sections.join("\n");
+}
+
+// src/cli.ts
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const get = (flag) => {
+    const idx = args.indexOf(flag);
+    return idx !== -1 ? args[idx + 1] : void 0;
+  };
+  const repo = get("--repo");
+  if (!repo) {
+    console.error("Error: --repo <owner/repo> is required");
+    console.error("");
+    console.error("Examples:");
+    console.error("  npx github-mobile-reader --repo 3rdflr/-FE- --pr 5");
+    console.error("  npx github-mobile-reader --repo 3rdflr/-FE- --all");
+    process.exit(1);
+  }
+  if (!/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.\-]+$/.test(repo)) {
+    console.error('Error: --repo must be in "owner/repo" format (e.g. "3rdflr/my-app")');
+    process.exit(1);
+  }
+  const rawOut = get("--out") ?? "./reader-output";
+  if (path.isAbsolute(rawOut) || rawOut.includes("..")) {
+    console.error('Error: --out must be a relative path without ".." (e.g. "./reader-output")');
+    process.exit(1);
+  }
+  if (args.includes("--token")) {
+    console.error("Error: --token flag is not supported for security reasons.");
+    console.error("       Set the GITHUB_TOKEN environment variable instead:");
+    console.error("       export GITHUB_TOKEN=ghp_xxxx");
+    process.exit(1);
+  }
+  return {
+    repo,
+    pr: get("--pr") ? Number(get("--pr")) : void 0,
+    all: args.includes("--all"),
+    token: process.env.GITHUB_TOKEN,
+    out: rawOut,
+    limit: Number(get("--limit") ?? "10")
+  };
+}
+async function githubFetch(url, token, accept = "application/vnd.github+json") {
+  const headers = { Accept: accept };
+  if (token) headers["Authorization"] = `token ${token}`;
+  const resp = await fetch(url, { headers });
+  if (!resp.ok) {
+    if (resp.status === 404) throw new Error(`Not found: ${url}`);
+    if (resp.status === 401) throw new Error("Authentication failed. Set the GITHUB_TOKEN environment variable.");
+    if (resp.status === 403) throw new Error("Rate limit or permission error. Set GITHUB_TOKEN for higher rate limits.");
+    throw new Error(`GitHub API error (status ${resp.status})`);
+  }
+  return resp;
+}
+async function getPRList(repo, token, limit = 10) {
+  const url = `https://api.github.com/repos/${repo}/pulls?state=all&per_page=${limit}&sort=updated&direction=desc`;
+  const resp = await githubFetch(url, token);
+  const data = await resp.json();
+  return data.map((pr) => ({ number: pr.number, title: pr.title }));
+}
+async function getPRMeta(repo, prNumber, token) {
+  const url = `https://api.github.com/repos/${repo}/pulls/${prNumber}`;
+  const resp = await githubFetch(url, token);
+  const data = await resp.json();
+  return { title: data.title, head: data.head.sha.slice(0, 7) };
+}
+var JS_TS_EXT = /\.(js|jsx|ts|tsx|mjs|cjs)$/;
+async function getPRFileDiffs(repo, prNumber, token) {
+  const url = `https://api.github.com/repos/${repo}/pulls/${prNumber}`;
+  const resp = await githubFetch(url, token, "application/vnd.github.v3.diff");
+  const rawDiff = await resp.text();
+  const chunks = rawDiff.split(/(?=^diff --git )/m).filter(Boolean);
+  return chunks.map((chunk) => {
+    const match = chunk.match(/^diff --git a\/(.+?) b\//m);
+    return match ? { filename: match[1], diff: chunk } : null;
+  }).filter((item) => item !== null && JS_TS_EXT.test(item.filename));
+}
+async function processPR(repo, prNumber, outDir, token) {
+  process.stdout.write(`  Fetching PR #${prNumber}...`);
+  const [fileDiffs, meta] = await Promise.all([
+    getPRFileDiffs(repo, prNumber, token),
+    getPRMeta(repo, prNumber, token)
+  ]);
+  if (fileDiffs.length === 0) {
+    console.log(` \u2014 JS/TS \uBCC0\uACBD \uC5C6\uC74C (\uC2A4\uD0B5)`);
+    return "";
+  }
+  const sections = [];
+  sections.push(`# \u{1F4D6} PR #${prNumber} \u2014 ${meta.title}
+`);
+  sections.push(`> Repository: ${repo}  `);
+  sections.push(`> Commit: \`${meta.head}\`  `);
+  sections.push(`> \uBCC0\uACBD\uB41C JS/TS \uD30C\uC77C: ${fileDiffs.length}\uAC1C
+`);
+  sections.push("---\n");
+  for (const { filename, diff } of fileDiffs) {
+    const section = generateReaderMarkdown(diff, {
+      pr: String(prNumber),
+      commit: meta.head,
+      file: filename,
+      repo
+    });
+    const withoutHeader = section.replace(/^# 📖.*\n/, "").replace(/^> Generated by.*\n/m, "").replace(/^> Repository:.*\n/m, "").replace(/^> Pull Request:.*\n/m, "").replace(/^> Commit:.*\n/m, "").replace(/^> File:.*\n/m, "").replace(/^\n+/, "");
+    sections.push(`## \u{1F4C4} \`${filename}\`
+`);
+    sections.push(withoutHeader);
+    sections.push("\n---\n");
+  }
+  sections.push("\u{1F6E0} Auto-generated by [github-mobile-reader](https://github.com/3rdflr/github-mobile-reader). Do not edit manually.");
+  const markdown = sections.join("\n");
+  fs.mkdirSync(outDir, { recursive: true });
+  const outPath = path.join(outDir, `pr-${prNumber}.md`);
+  fs.writeFileSync(outPath, markdown, "utf8");
+  console.log(` \u2713  "${meta.title}" (${fileDiffs.length}\uAC1C \uD30C\uC77C)`);
+  return outPath;
+}
+async function main() {
+  const opts = parseArgs();
+  console.log(`
+\u{1F4D6} github-mobile-reader CLI`);
+  console.log(`   repo : ${opts.repo}`);
+  console.log(`   out  : ${opts.out}`);
+  if (!opts.token) {
+    console.log(`   auth : none (60 req/hr limit \u2014 use --token or GITHUB_TOKEN for more)
+`);
+  } else {
+    console.log(`   auth : token provided
+`);
+  }
+  if (opts.pr) {
+    const outPath = await processPR(opts.repo, opts.pr, opts.out, opts.token);
+    if (outPath) console.log(`
+\u2705 Done \u2192 ${outPath}
+`);
+    return;
+  }
+  if (opts.all) {
+    console.log(`  Fetching PR list (limit: ${opts.limit})...`);
+    const prs = await getPRList(opts.repo, opts.token, opts.limit);
+    if (prs.length === 0) {
+      console.log("  No PRs found.");
+      return;
+    }
+    console.log(`  Found ${prs.length} PR(s)
+`);
+    const results = [];
+    for (const pr of prs) {
+      try {
+        const outPath = await processPR(opts.repo, pr.number, opts.out, opts.token);
+        if (outPath) results.push(outPath);
+      } catch (err) {
+        console.log(` \u2717  PR #${pr.number} skipped: ${err.message}`);
+      }
+    }
+    console.log(`
+\u2705 Done \u2014 ${results.length} file(s) written to ${opts.out}/
+`);
+    results.forEach((p) => console.log(`   ${p}`));
+    console.log("");
+    return;
+  }
+  console.error("Error: specify --pr <number> or --all");
+  process.exit(1);
+}
+main().catch((err) => {
+  console.error(`
+\u274C ${err.message}
+`);
+  process.exit(1);
+});

package/dist/index.d.mts

@@ -31,6 +31,20 @@ interface ReaderMarkdownMeta {
     file?: string;
     repo?: string;
 }
+interface ClassNameChange {
+    component: string;
+    added: string[];
+    removed: string[];
+}
+declare function isJSXFile(filename: string): boolean;
+declare function hasJSXContent(lines: string[]): boolean;
+declare function isClassNameOnlyLine(line: string): boolean;
+declare function extractClassName(line: string): string | null;
+declare function parseClassNameChanges(addedLines: string[], removedLines: string[]): ClassNameChange[];
+declare function renderStyleChanges(changes: ClassNameChange[]): string[];
+declare function isJSXElement(line: string): boolean;
+declare function extractJSXComponentName(line: string): string;
+declare function parseJSXToFlowTree(lines: string[]): FlowNode[];
 /**
  * Step 1: Filter diff lines — added (+) and removed (-) separately
  */
@@ -59,4 +73,4 @@ declare function parseDiffToLogicalFlow(diffText: string): ParseResult;
  */
 declare function generateReaderMarkdown(diffText: string, meta?: ReaderMarkdownMeta): string;
 
-export { type FlowNode, type ParseResult, Priority, type ReaderMarkdownMeta, filterDiffLines, generateReaderMarkdown, normalizeCode, parseDiffToLogicalFlow, parseToFlowTree, renderFlowTree };
+export { type ClassNameChange, type FlowNode, type ParseResult, Priority, type ReaderMarkdownMeta, extractClassName, extractJSXComponentName, filterDiffLines, generateReaderMarkdown, hasJSXContent, isClassNameOnlyLine, isJSXElement, isJSXFile, normalizeCode, parseClassNameChanges, parseDiffToLogicalFlow, parseJSXToFlowTree, parseToFlowTree, renderFlowTree, renderStyleChanges };

package/dist/index.d.ts

@@ -31,6 +31,20 @@ interface ReaderMarkdownMeta {
     file?: string;
     repo?: string;
 }
+interface ClassNameChange {
+    component: string;
+    added: string[];
+    removed: string[];
+}
+declare function isJSXFile(filename: string): boolean;
+declare function hasJSXContent(lines: string[]): boolean;
+declare function isClassNameOnlyLine(line: string): boolean;
+declare function extractClassName(line: string): string | null;
+declare function parseClassNameChanges(addedLines: string[], removedLines: string[]): ClassNameChange[];
+declare function renderStyleChanges(changes: ClassNameChange[]): string[];
+declare function isJSXElement(line: string): boolean;
+declare function extractJSXComponentName(line: string): string;
+declare function parseJSXToFlowTree(lines: string[]): FlowNode[];
 /**
  * Step 1: Filter diff lines — added (+) and removed (-) separately
  */
@@ -59,4 +73,4 @@ declare function parseDiffToLogicalFlow(diffText: string): ParseResult;
  */
 declare function generateReaderMarkdown(diffText: string, meta?: ReaderMarkdownMeta): string;
 
-export { type FlowNode, type ParseResult, Priority, type ReaderMarkdownMeta, filterDiffLines, generateReaderMarkdown, normalizeCode, parseDiffToLogicalFlow, parseToFlowTree, renderFlowTree };
+export { type ClassNameChange, type FlowNode, type ParseResult, Priority, type ReaderMarkdownMeta, extractClassName, extractJSXComponentName, filterDiffLines, generateReaderMarkdown, hasJSXContent, isClassNameOnlyLine, isJSXElement, isJSXFile, normalizeCode, parseClassNameChanges, parseDiffToLogicalFlow, parseJSXToFlowTree, parseToFlowTree, renderFlowTree, renderStyleChanges };