github-mobile-reader 0.1.0

package/dist/action.js

@@ -0,0 +1,348 @@
+"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/action.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var import_child_process = require("child_process");
+
+// src/parser.ts
+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.replace(/\/\*.*?\*\//, "");
+    normalized = normalized.trim();
+    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) {
+  return /^(function|const|let|var)\s+\w+\s*=?\s*(async\s*)?\(/.test(line.trim()) || /^(async\s+)?function\s+\w+/.test(line.trim());
+}
+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;
+    }
+    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;
+    } else 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;
+  }
+  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 parseDiffToLogicalFlow(diffText) {
+  const { added, removed } = filterDiffLines(diffText);
+  const normalizedAdded = normalizeCode(added);
+  const flowTree = parseToFlowTree(normalizedAdded);
+  return {
+    root: flowTree,
+    rawCode: added.join("\n"),
+    removedCode: removed.join("\n")
+  };
+}
+function generateReaderMarkdown(diffText, meta = {}) {
+  const result = parseDiffToLogicalFlow(diffText);
+  const sections = [];
+  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 (result.root.length > 0) {
+    sections.push("## \u{1F9E0} Logical Flow\n");
+    sections.push("```");
+    sections.push(...renderFlowTree(result.root));
+    sections.push("```\n");
+  }
+  if (result.rawCode.trim()) {
+    sections.push("## \u2705 Added Code\n");
+    sections.push("```typescript");
+    sections.push(result.rawCode);
+    sections.push("```\n");
+  }
+  if (result.removedCode.trim()) {
+    sections.push("## \u274C Removed Code\n");
+    sections.push("```typescript");
+    sections.push(result.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/action.ts
+function env(name, fallback) {
+  const val = process.env[name] ?? fallback;
+  if (val === void 0) {
+    throw new Error(`Required environment variable "${name}" is not set.`);
+  }
+  return val;
+}
+function run(cmd, cwd) {
+  return (0, import_child_process.execSync)(cmd, {
+    cwd: cwd ?? process.cwd(),
+    encoding: "utf8",
+    stdio: ["pipe", "pipe", "pipe"]
+  }).trim();
+}
+function getFileDiffs(baseBranch) {
+  let rawDiff;
+  try {
+    rawDiff = run(`git diff origin/${baseBranch}...HEAD`);
+  } catch {
+    rawDiff = run("git diff HEAD");
+  }
+  if (!rawDiff) return [];
+  const fileDiffs = [];
+  const chunks = rawDiff.split(/(?=^diff --git )/m).filter(Boolean);
+  for (const chunk of chunks) {
+    const fileMatch = chunk.match(/^diff --git a\/(.+?) b\//m);
+    if (!fileMatch) continue;
+    const filename = fileMatch[1];
+    if (!/\.(js|jsx|ts|tsx|mjs|cjs)$/.test(filename)) continue;
+    fileDiffs.push({ filename, diff: chunk });
+  }
+  return fileDiffs;
+}
+function writeMarkdown(outputDir, prNumber, fileDiffs, meta) {
+  const parts = [
+    `# \u{1F4D6} PR #${prNumber} \u2014 Mobile Reader View
+`,
+    `> Repository: ${meta.repo}  `,
+    `> Commit: \`${meta.commit}\`  `,
+    `> Generated by **github-mobile-reader**
+`,
+    "---\n"
+  ];
+  for (const { filename, diff } of fileDiffs) {
+    const section = generateReaderMarkdown(diff, {
+      pr: prNumber,
+      commit: meta.commit,
+      file: filename,
+      repo: meta.repo
+    });
+    parts.push(`## \u{1F4C4} \`${filename}\`
+`);
+    parts.push(section);
+    parts.push("\n---\n");
+  }
+  if (parts.length === 5) {
+    parts.push("_No JavaScript / TypeScript changes detected in this PR._\n");
+  }
+  const outPath = path.join(outputDir, `pr-${prNumber}.md`);
+  fs.mkdirSync(outputDir, { recursive: true });
+  fs.writeFileSync(outPath, parts.join("\n"), "utf8");
+  console.log(`[github-mobile-reader] Written \u2192 ${outPath}`);
+  return outPath;
+}
+async function postComment(token, repo, prNumber, body) {
+  const [owner, repoName] = repo.split("/");
+  const url = `https://api.github.com/repos/${owner}/${repoName}/issues/${prNumber}/comments`;
+  const resp = await fetch(url, {
+    method: "POST",
+    headers: {
+      Authorization: `token ${token}`,
+      "Content-Type": "application/json",
+      Accept: "application/vnd.github+json"
+    },
+    body: JSON.stringify({ body })
+  });
+  if (!resp.ok) {
+    const text = await resp.text();
+    throw new Error(`GitHub API error ${resp.status}: ${text}`);
+  }
+  console.log("[github-mobile-reader] PR comment posted.");
+}
+async function main() {
+  const token = env("GITHUB_TOKEN");
+  const repo = env("GITHUB_REPOSITORY");
+  const prNumber = env("PR_NUMBER");
+  const baseBranch = env("BASE_BRANCH", "main");
+  const outputDir = env("OUTPUT_DIR", "docs/reader");
+  const commit = run("git rev-parse --short HEAD");
+  console.log(`[github-mobile-reader] Processing PR #${prNumber} (${repo})`);
+  const fileDiffs = getFileDiffs(baseBranch);
+  console.log(`[github-mobile-reader] Found ${fileDiffs.length} JS/TS file(s) with changes`);
+  const outPath = writeMarkdown(outputDir, prNumber, fileDiffs, { repo, commit });
+  const fileList = fileDiffs.map((f) => `- \`${f.filename}\``).join("\n") || "- (none)";
+  const commentBody = [
+    "## \u{1F4D6} Mobile Reader View Generated",
+    "",
+    `A mobile-friendly summary has been written to \`${outPath}\`.`,
+    "",
+    "**Changed files processed:**",
+    fileList,
+    "",
+    `> Powered by [github-mobile-reader](https://www.npmjs.com/package/github-mobile-reader)`
+  ].join("\n");
+  await postComment(token, repo, prNumber, commentBody);
+}
+main().catch((err) => {
+  console.error("[github-mobile-reader] Fatal:", err.message);
+  process.exit(1);
+});

package/dist/index.d.mts

@@ -0,0 +1,62 @@
+/**
+ * github-mobile-reader - Diff to Logical Flow Parser v0.2
+ *
+ * Philosophy:
+ * - Summarize, don't explain
+ * - Be conservative when ambiguous
+ * - Show less rather than show wrong
+ */
+declare enum Priority {
+    CHAINING = 1,
+    CONDITIONAL = 2,
+    LOOP = 3,
+    FUNCTION = 4,
+    OTHER = 5
+}
+interface FlowNode {
+    type: 'root' | 'chain' | 'condition' | 'loop' | 'function' | 'call';
+    name: string;
+    children: FlowNode[];
+    depth: number;
+    priority: Priority;
+}
+interface ParseResult {
+    root: FlowNode[];
+    rawCode: string;
+    removedCode: string;
+}
+interface ReaderMarkdownMeta {
+    pr?: string;
+    commit?: string;
+    file?: string;
+    repo?: string;
+}
+/**
+ * Step 1: Filter diff lines — added (+) and removed (-) separately
+ */
+declare function filterDiffLines(diffText: string): {
+    added: string[];
+    removed: string[];
+};
+/**
+ * Step 2: Normalize code — remove noise, preserve structure
+ */
+declare function normalizeCode(lines: string[]): string[];
+/**
+ * Main parser: convert normalized lines → FlowNode tree
+ */
+declare function parseToFlowTree(lines: string[]): FlowNode[];
+/**
+ * Render flow tree as markdown lines
+ */
+declare function renderFlowTree(nodes: FlowNode[], indent?: number): string[];
+/**
+ * Main entry: parse a raw diff string → ParseResult
+ */
+declare function parseDiffToLogicalFlow(diffText: string): ParseResult;
+/**
+ * Generate the complete Reader Markdown document
+ */
+declare function generateReaderMarkdown(diffText: string, meta?: ReaderMarkdownMeta): string;
+
+export { type FlowNode, type ParseResult, Priority, type ReaderMarkdownMeta, filterDiffLines, generateReaderMarkdown, normalizeCode, parseDiffToLogicalFlow, parseToFlowTree, renderFlowTree };

package/dist/index.d.ts

@@ -0,0 +1,62 @@
+/**
+ * github-mobile-reader - Diff to Logical Flow Parser v0.2
+ *
+ * Philosophy:
+ * - Summarize, don't explain
+ * - Be conservative when ambiguous
+ * - Show less rather than show wrong
+ */
+declare enum Priority {
+    CHAINING = 1,
+    CONDITIONAL = 2,
+    LOOP = 3,
+    FUNCTION = 4,
+    OTHER = 5
+}
+interface FlowNode {
+    type: 'root' | 'chain' | 'condition' | 'loop' | 'function' | 'call';
+    name: string;
+    children: FlowNode[];
+    depth: number;
+    priority: Priority;
+}
+interface ParseResult {
+    root: FlowNode[];
+    rawCode: string;
+    removedCode: string;
+}
+interface ReaderMarkdownMeta {
+    pr?: string;
+    commit?: string;
+    file?: string;
+    repo?: string;
+}
+/**
+ * Step 1: Filter diff lines — added (+) and removed (-) separately
+ */
+declare function filterDiffLines(diffText: string): {
+    added: string[];
+    removed: string[];
+};
+/**
+ * Step 2: Normalize code — remove noise, preserve structure
+ */
+declare function normalizeCode(lines: string[]): string[];
+/**
+ * Main parser: convert normalized lines → FlowNode tree
+ */
+declare function parseToFlowTree(lines: string[]): FlowNode[];
+/**
+ * Render flow tree as markdown lines
+ */
+declare function renderFlowTree(nodes: FlowNode[], indent?: number): string[];
+/**
+ * Main entry: parse a raw diff string → ParseResult
+ */
+declare function parseDiffToLogicalFlow(diffText: string): ParseResult;
+/**
+ * Generate the complete Reader Markdown document
+ */
+declare function generateReaderMarkdown(diffText: string, meta?: ReaderMarkdownMeta): string;
+
+export { type FlowNode, type ParseResult, Priority, type ReaderMarkdownMeta, filterDiffLines, generateReaderMarkdown, normalizeCode, parseDiffToLogicalFlow, parseToFlowTree, renderFlowTree };