getmdfromleetcode 1.1.0 → 1.1.2

package/README.md

@@ -12,6 +12,7 @@
 - 提取官方题解内容（包括解题思路和代码实现）
 - 支持多种编程语言的代码展示
 - 数学公式自动转换为 LaTeX 格式
+- 支持将生成内容复制到系统剪贴板
 
 ## 安装
 
@@ -23,6 +24,18 @@
 yarn install
 ```
 
+或者全局安装:
+
+```bash
+yarn global add getmdfromleetcode
+```
+
+或者使用 npm:
+
+```bash
+npm install -g getmdfromleetcode
+```
+
 ## 使用方法
 
 ### 作为命令行工具使用
@@ -37,12 +50,10 @@ node index.js -u <leetcode-problem-url>
 node index.js -u https://leetcode.cn/problems/two-sum/
 ```
 
-### 使用 yarn 脚本
-
-你也可以使用 yarn 脚本运行：
+安装后也可以直接使用命令：
 
 ```bash
-yarn start -u https://leetcode.cn/problems/two-sum/
+getmdfromleetcode -u <leetcode-problem-url>
 ```
 
 ### 参数说明
@@ -50,17 +61,24 @@ yarn start -u https://leetcode.cn/problems/two-sum/
 - `-u, --url`: 指定 LeetCode 题目 URL（必填）
 - `-e, --english`: 切换到英文内容显示
 - `-r, --raw`: 输出原始 HTML 格式内容
+- `-c, --clipboard`: 将输出内容复制到系统剪贴板
 
 示例：
 ```bash
 # 获取中文题目内容
-yarn start -u https://leetcode.cn/problems/two-sum/
+getmdfromleetcode -u https://leetcode.cn/problems/two-sum/
 
 # 获取英文题目内容
-yarn start -u https://leetcode.cn/problems/two-sum/ -e
+getmdfromleetcode -u https://leetcode.cn/problems/two-sum/ -e
 
 # 获取原始 HTML 格式内容
-yarn start -u https://leetcode.cn/problems/two-sum/ -r
+getmdfromleetcode -u https://leetcode.cn/problems/two-sum/ -r
+
+# 获取题目内容并复制到剪贴板
+getmdfromleetcode -u https://leetcode.cn/problems/two-sum/ -c
+
+# 组合使用多个参数
+getmdfromleetcode -u https://leetcode.cn/problems/two-sum/ -e -c
 ```
 
 ## 输出内容

package/index.js

@@ -6,29 +6,49 @@
  * 从LeetCode题目页面生成Markdown格式的题目描述
  */
 
-import yargs from 'yargs/yargs';
+import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
 import { fetchProblemDataViaGraphQL, fetchProblemDataFromPage } from './lib/problemDataFetcher.js';
 import { formatAsMarkdown } from './lib/markdownFormatter.js';
+import { execSync } from 'child_process';
+import { writeFileSync } from 'fs';
 
 // 解析命令行参数
 const argv = yargs(hideBin(process.argv))
   .option('url', {
     alias: 'u',
     type: 'string',
-    description: 'LeetCode题目URL',
+    description: 'LeetCode problem URL',
     demandOption: true
   })
   .option('english', {
     alias: 'e',
     type: 'boolean',
-    description: '使用英文内容',
+    description: 'Use English content',
     default: false
   })
   .option('raw', {
     alias: 'r',
     type: 'boolean',
-    description: '输出原始HTML格式',
+    description: 'Output raw HTML content',
+    default: false
+  })
+  .option('clipboard', {
+    alias: 'c',
+    type: 'boolean',
+    description: 'Copy output to clipboard',
+    default: false
+  })
+  .option('username', {
+    alias: 'n',
+    type: 'string',
+    description: 'Username for specific solution author',
+    default: 'endlesscheng'  // 设置默认用户名为endlesscheng
+  })
+  .option('solutionOnly', {
+    alias: 's',
+    type: 'boolean',
+    description: 'Output solution only',
     default: false
   })
   .help()
@@ -37,35 +57,70 @@ const argv = yargs(hideBin(process.argv))
 
 // 主函数
 async function main() {
+  const { url, english, raw, clipboard, username, solutionOnly } = argv;
+  const language = english ? 'english' : 'chinese';
+  const rawOutput = raw;
+  
   try {
-    const url = argv.url;
-    const useEnglish = argv.english;
-    const rawOutput = argv.raw;
-    const language = useEnglish ? 'english' : 'chinese';
-    
     let questionData;
     
+    // 首先尝试通过GraphQL API获取数据
     try {
-      // 首先尝试通过GraphQL API获取数据
-      questionData = await fetchProblemDataViaGraphQL(url, language);
-    } catch (graphqlError) {
-      console.error(`GraphQL API request failed: ${graphqlError.message}`);
-      try {
-        // 如果GraphQL失败，尝试从页面的__NEXT_DATA__中提取
-        questionData = await fetchProblemDataFromPage(url, language);
-      } catch (pageError) {
-        console.error(`Page data extraction failed: ${pageError.message}`);
-        throw new Error(`Failed to fetch problem data via both methods: ${graphqlError.message}; ${pageError.message}`);
-      }
+      questionData = await fetchProblemDataViaGraphQL(url, language, username);
+    } catch (apiError) {
+      console.error('Failed to fetch data via GraphQL API, trying to fetch from page...', apiError.message);
+      // 如果API获取失败，则尝试从页面获取数据
+      questionData = await fetchProblemDataFromPage(url, language, username);
     }
     
-    // 格式化为Markdown
-    const markdown = formatAsMarkdown(questionData, rawOutput);
+    // 添加语言信息到 questionData
+    questionData.isEnglish = english;
+    
+    // 根据solutionOnly参数决定输出内容
+    let outputContent;
+    if (solutionOnly) {
+      // 只输出题解
+      if (questionData.solution) {
+        outputContent = formatAsMarkdown(questionData, rawOutput, true); // 传递solutionOnly标志
+      } else {
+        console.log('No solution found for the given problem.');
+        return;
+      }
+    } else {
+      // 正常输出完整内容
+      outputContent = formatAsMarkdown(questionData, rawOutput);
+    }
     
-    // 输出结果
-    console.log(markdown);
+    // 如果用户指定了复制到剪贴板的选项，则复制内容
+    if (clipboard) {
+      try {
+        // 将内容写入临时文件
+        writeFileSync('/tmp/leetcode_content.txt', outputContent);
+        
+        // 根据操作系统使用不同的命令复制到剪贴板
+        if (process.platform === 'darwin') {
+          // macOS
+          execSync('pbcopy < /tmp/leetcode_content.txt');
+        } else if (process.platform === 'win32') {
+          // Windows
+          execSync('clip < /tmp/leetcode_content.txt');
+        } else {
+          // Linux
+          execSync('xclip -selection clipboard < /tmp/leetcode_content.txt');
+        }
+        
+        console.log('Content copied to clipboard successfully!');
+      } catch (clipboardError) {
+        console.error('Failed to copy content to clipboard:', clipboardError.message);
+        // 即使复制到剪贴板失败，仍然输出内容
+        console.log(outputContent);
+      }
+    } else {
+      // 正常输出内容
+      console.log(outputContent);
+    }
   } catch (error) {
-    console.error('Error:', error.message);
+    console.error('Error fetching or processing problem data:', error.message);
     process.exit(1);
   }
 }

package/lib/markdownFormatter.js

@@ -1,17 +1,19 @@
 /**
- * Markdown格式化模块
+ * Markdown format化模块
  */
 
 import * as cheerio from 'cheerio';
 
 // 将题目内容格式化为Markdown
-function formatAsMarkdown(question, rawOutput = false) {
+function formatAsMarkdown(question, rawOutput = false, solutionOnly = false) {
   const title = question.displayTitle;
   const difficulty = question.difficulty;
   const content = question.displayContent;
   const topicTags = question.topicTags || [];
   const solution = question.solution;
-  
+  const isEnglish = question.isEnglish || false;
+  const url = question.url || ''; // 获取题目URL
+  //console.log(question);
   // 如果需要原始输出，则返回包含标题和难度的原始HTML内容
   if (rawOutput) {
     let rawResult = '';
@@ -22,7 +24,7 @@ function formatAsMarkdown(question, rawOutput = false) {
       rawResult += `<p><strong>Difficulty:</strong> ${difficulty}</p>\n`;
     }
     rawResult += content;
-    
+
     // 添加题解内容（如果存在）
     if (solution && solution.content) {
       rawResult += `\n\n<h2>题解</h2>\n`;
@@ -31,20 +33,20 @@ function formatAsMarkdown(question, rawOutput = false) {
       rawResult += `\n\n<h2>题解</h2>\n`;
       rawResult += `<p>没有找到题解</p>\n`;
     }
-    
+
     return rawResult;
   }
-  
+
   // 使用cheerio处理HTML格式的描述
-  const $ = cheerio.load(content, {decodeEntities: false});
-  
+  const $ = cheerio.load(content, { decodeEntities: false });
+
   // 提取文本内容并格式化
   let description = '';
-  
+
   // 按照HTML中的顺序处理所有元素
   $('body').children().each((i, elem) => {
     const $elem = $(elem);
-    
+
     if (elem.tagName === 'p') {
       // 处理段落中的内联元素
       let text = '';
@@ -53,14 +55,14 @@ function formatAsMarkdown(question, rawOutput = false) {
         if (child.type === 'text') {
           text += child.data;
         } else if (child.tagName === 'strong') {
-          text += `**${$child.text()}**`;
+          text += ` **${$child.text()}** `;
         } else if (child.tagName === 'em') {
-          text += `*${$child.text()}*`;
+          text += ` *${$child.text()}* `;
         } else if (child.tagName === 'code') {
           text += `\`${$child.text()}\``;
         } else if (child.tagName === 'sup') {
           // 处理上标（数学公式中的幂）
-          text += `^${$child.text()}`;
+          text += `^{${$child.text()}}`;
         } else if (child.tagName === 'sub') {
           // 处理下标
           text += `_${$child.text()}`;
@@ -72,10 +74,18 @@ function formatAsMarkdown(question, rawOutput = false) {
       text = text.trim();
       if (text) {
         // 特殊处理示例标题
-        if (text.startsWith('示例') || text.startsWith('Example')) {
+        if (text.startsWith('**示例') || text.startsWith('**Example')) {
+          // 去掉前后的**
+          text = text.replace(/^\*\*(.*)\*\*$/, '$1');
           description += `\n\n## ${text}\n\n`;
-        } else if (text.startsWith('提示') || text.startsWith('Hint')) {
-          description += `\n\n## 提示:\n`;
+        } else if (text.startsWith('**提示') || text.startsWith('**Hint')) {
+          // 去掉前后的**
+          text = text.replace(/^\*\*(.*)\*\*$/, '$1');
+          description += `\n\n## ${text}\n`;
+        } else if (text.startsWith('**进阶**')) {
+          // 去掉前后的**
+          text = text.replace(/^\*\*(.*)\*\*$/, '$1');
+          description += `\n\n## ${text}\n`;
         } else {
           description += text + '\n\n';
         }
@@ -87,177 +97,123 @@ function formatAsMarkdown(question, rawOutput = false) {
       }
     } else if (elem.tagName === 'ul' || elem.tagName === 'ol') {
       $elem.children('li').each((j, li) => {
-        const text = $(li).text().trim();
-        if (text) {
-          description += `- ${text}\n`;
+        let text = '';
+        // 保留li元素中的所有内容，包括strong标签
+        $(li).contents().each((k, child) => {
+          const $child = $(child);
+          if (child.type === 'text') {
+            text += child.data;
+          } else if (child.tagName === 'strong') {
+            text += ` **${$child.text()}** `;
+          } else if (child.tagName === 'code') {
+            // 特殊处理code标签中的sup和sub标签
+            let codeText = '';
+            $child.contents().each((l, codeChild) => {
+              if (codeChild.type === 'text') {
+                codeText += codeChild.data;
+              } else if (codeChild.tagName === 'sup') {
+                // 处理上标（数学公式中的幂）
+                console.log('处理code中的sup标签'); // 调试信息
+                codeText += `^${$(codeChild).text()}`;
+              } else if (codeChild.tagName === 'sub') {
+                // 处理下标
+                console.log('处理code中的sub标签'); // 调试信息
+                codeText += `_${$(codeChild).text()}`;
+              } else {
+                codeText += $(codeChild).text();
+              }
+            });
+            text += `\`${codeText}\``;
+          } else if (child.tagName === 'sup') {
+            // 处理上标（数学公式中的幂）
+            text += `^${$child.text()}`;
+          } else if (child.tagName === 'sub') {
+            // 处理下标
+            text += `_${$child.text()}`;
+          } else {
+            // 其他标签直接获取文本
+            text += $child.text();
+          }
+        });
+        if (text.trim()) {
+          // 处理列表项中的数学表达式
+          description += `- ${text.trim()}\n`;
         }
       });
       description += '\n';
     }
   });
-  
+
+  // 如果只输出题解
+  if (solutionOnly) {
+    if (solution && solution.content) {
+      // 直接返回题解内容
+      let solutionContent = solution.content || '';
+      return solutionContent;
+    } else {
+      return '没有找到题解';
+    }
+  }
+
   // 构建Markdown输出
   let markdown = '';
   if (title) {
     markdown += `# ${title}\n\n`;
   }
-  
+
   if (difficulty) {
     markdown += `**Difficulty:** ${difficulty}\n\n`;
   } else {
     markdown += `**Difficulty:** 未找到\n\n`;
   }
-  
+
   // 添加题目标签
   if (topicTags.length > 0) {
-    const tags = topicTags.map(tag => 
+    const tags = topicTags.map(tag =>
       tag.translatedName || tag.name
     ).join(', ');
     markdown += `**Tags:** ${tags}\n\n`;
   }
-  
+
   if (description) {
     // 格式化描述内容
     let formattedDescription = description;
-    
-    // 处理示例部分
-    formattedDescription = formattedDescription.replace(/示例\s*(\d+)\s*:/g, '\n\n## 示例 $1:\n\n');
-    formattedDescription = formattedDescription.replace(/示例\s*(\d+)\s*：/g, '\n\n## 示例 $1:\n\n');
-    formattedDescription = formattedDescription.replace(/Example\s*(\d+)\s*:/g, '\n\n## Example $1:\n\n');
-    
+
+    // 仅保留解释部分的处理
     // 处理解释部分
     formattedDescription = formattedDescription.replace(/解释：/g, '\n**解释:** ');
     formattedDescription = formattedDescription.replace(/Explanation:/g, '\n**Explanation:** ');
-    
-    // 处理提示部分
-    formattedDescription = formattedDescription.replace(/提示：/g, '\n\n## 提示:\n');
-    formattedDescription = formattedDescription.replace(/进阶：/g, '\n\n**进阶:**\n');
-    formattedDescription = formattedDescription.replace(/Follow up:/g, '\n\n**Follow up:**\n');
-    
-    // 处理列表项
-    formattedDescription = formattedDescription.replace(/\n \* /g, '\n- ');
-    
-    // 修复特殊字符问题
-    formattedDescription = formattedDescription.replace(/(\d+)\\u003csup\\u003e(\d+)\\u003c\/sup\\u003e/g, '$1^$2');
-    formattedDescription = formattedDescription.replace(/(\d+)\\u003csub\\u003e(\d+)\\u003c\/sub\\u003e/g, '$1_$2');
-    
-    // 特殊处理常见的数学范围表达式，先处理特定的表达式
-    formattedDescription = formattedDescription.replace(/10\s*\^\s*4/g, '$10^4$');
-    formattedDescription = formattedDescription.replace(/10\s*\^\s*5/g, '$10^5$');
-    formattedDescription = formattedDescription.replace(/10\s*\^\s*9/g, '$10^9$');
-    
-    // 将其他数字^数字的表达式用$包裹，符合LaTeX规范（排除特定已处理的表达式）
-    formattedDescription = formattedDescription.replace(/(\d+)\s*\^\s*(\d+)/g, function(match, p1, p2) {
-      // 如果不是已经特殊处理的表达式，则添加LaTeX标记
-      if (!(p1 === '10' && (p2 === '4' || p2 === '5' || p2 === '9'))) {
-        return `$${p1}^${p2}$`;
-      }
-      return match;
-    });
-    
-    // 处理下标表达式（例如 H_2 -> $H_2$ 或 H_{2} -> $H_{2}$）
-    formattedDescription = formattedDescription.replace(/([A-Za-z])_({?[0-9]+}?)/g, function(match, p1, p2) {
-      // 如果已经是{数字}格式，则直接使用，否则添加大括号
-      if (!p2.startsWith('{')) {
-        p2 = '{' + p2 + '}';
-      }
-      return `$${p1}_${p2}$`;
-    });
-    
-    // 处理负数的上标情况
-    formattedDescription = formattedDescription.replace(/-\s*(\d+)\^(\d+)/g, '-\$$1^$2\$');
-    
+
     // 清理多余的空白字符
     formattedDescription = formattedDescription.replace(/\n\s*\n\s*\n/g, '\n\n');
     formattedDescription = formattedDescription.replace(/^ +/gm, '');
-    
-    markdown += `## Description\n\n${formattedDescription}\n`;
+
+    // 根据语言显示不同的标题
+    const descriptionTitle = isEnglish ? "Description" : "题目描述";
+    markdown += `## ${descriptionTitle}\n\n${formattedDescription}\n`;
   } else {
-    markdown += '## Description\n\n未能提取到题目描述\n\n';
+    // 根据语言显示不同的标题
+    const descriptionTitle = isEnglish ? "Description" : "题目描述";
+    markdown += `## ${descriptionTitle}\n\n未能提取到题目描述\n\n`;
+  }
+  // 添加题目来源
+  if (url) {
+    markdown += `\n\n## SOURCE\n\n[${title}](${url})\n\n`;
   }
-  
   // 添加题解内容（如果存在）
   if (solution && solution.content) {
     markdown += '\n## 题解\n\n';
-    
-    // 处理题解内容
-    const solution$ = cheerio.load(solution.content || '', {decodeEntities: false});
-    
-    // 提取题解文本内容并格式化
-    let solutionText = '';
-    
-    // 更简单直接的方法：直接提取所有文本内容并按段落处理
-    const allText = solution$('body').text();
-    // 修复：不使用trim，保留原始段落格式
-    const paragraphs = allText.split('\n');
-    
-    paragraphs.forEach(paragraph => {
-      // 修复：只对纯文本段落进行处理，保留空行和缩进
-      if (paragraph.trim()) {
-        // 检查是否是标题
-        if (paragraph.trim().startsWith('####')) {
-          solutionText += `\n\n${paragraph.trim()}\n\n`;
-        } else if (paragraph.trim().startsWith('###')) {
-          solutionText += `\n\n${paragraph.trim()}\n\n`;
-        } else if (paragraph.trim().startsWith('##')) {
-          solutionText += `\n\n${paragraph.trim()}\n\n`;
-        } else if (paragraph.trim().startsWith('#')) {
-          solutionText += `\n\n${paragraph.trim()}\n\n`;
-        } else {
-          // 普通段落，保留原始格式
-          solutionText += `${paragraph}\n`;
-        }
-      } else {
-        // 空行直接添加
-        solutionText += '\n';
-      }
-    });
-    
-    // 特殊处理代码块部分，保留原始缩进
-    const codeBlocks = solution$('pre');
-    codeBlocks.each((i, elem) => {
-      const $elem = solution$(elem);
-      const classAttr = $elem.attr('class') || '';
-      let lang = '';
-      // 尝试从class中提取语言信息
-      const langMatch = classAttr.match(/\[([^\]]+)\]/);
-      if (langMatch) {
-        lang = langMatch[1].split('-')[0];
-      }
-      
-      const codeText = $elem.text();
-      if (codeText) {
-        // 修复：保留原始代码的缩进
-        solutionText += '```' + lang + '\n' + codeText + '```\n\n';
-      }
-    });
-    
-    // 应用与题目描述相同的数学公式处理
-    solutionText = solutionText.replace(/(\d+)\\u003csup\\u003e(\d+)\\u003c\/sup\\u003e/g, '$1^$2');
-    solutionText = solutionText.replace(/(\d+)\\u003csub\\u003e(\d+)\\u003c\/sub\\u003e/g, '$1_$2');
-    solutionText = solutionText.replace(/10\s*\^\s*4/g, '$10^4$');
-    solutionText = solutionText.replace(/10\s*\^\s*5/g, '$10^5$');
-    solutionText = solutionText.replace(/10\s*\^\s*9/g, '$10^9$');
-    solutionText = solutionText.replace(/(\d+)\s*\^\s*(\d+)/g, function(match, p1, p2) {
-      if (!(p1 === '10' && (p2 === '4' || p2 === '5' || p2 === '9'))) {
-        return `$${p1}^${p2}$`;
-      }
-      return match;
-    });
-    // 处理下标表达式（例如 H_2 -> $H_2$ 或 H_{2} -> $H_{2}$）
-    solutionText = solutionText.replace(/([A-Za-z])_({?[0-9]+}?)/g, function(match, p1, p2) {
-      // 如果已经是{数字}格式，则直接使用，否则添加大括号
-      if (!p2.startsWith('{')) {
-        p2 = '{' + p2 + '}';
-      }
-      return `$${p1}_${p2}$`;
-    });
-    solutionText = solutionText.replace(/-\s*(\d+)\^(\d+)/g, '-\$$1^$2\$');
-    
-    // 清理多余的空白字符，但保留必要的换行
-    solutionText = solutionText.replace(/\n\s*\n\s*\n/g, '\n\n');
-    
-    markdown += solutionText;
+
+    // 直接使用题解的原始内容，不进行Markdown格式转换
+    // 保留HTML格式并处理特殊字符
+    let solutionContent = solution.content || '';
+
+    // 处理HTML实体，但保留HTML标签结构
+    // solutionContent = solutionContent.replace(/&lt;/g, '<').replace(/&gt;/g, '>');
+
+    // solutionContent = solutionContent.replace(/&lt;/g, '<').replace(/&gt;/g, '>');
+
+    markdown += solutionContent + '\n';
   } else {
     markdown += '\n## 题解\n\n';
     markdown += '没有找到题解\n\n';