getmdfromleetcode 1.1.1 → 1.1.3

package/README.md

@@ -13,6 +13,7 @@
 - 支持多种编程语言的代码展示
 - 数学公式自动转换为 LaTeX 格式
 - 支持将生成内容复制到系统剪贴板
+- 支持只输出题目内容或只输出题解内容
 
 ## 安装
 
@@ -62,6 +63,8 @@ getmdfromleetcode -u <leetcode-problem-url>
 - `-e, --english`: 切换到英文内容显示
 - `-r, --raw`: 输出原始 HTML 格式内容
 - `-c, --clipboard`: 将输出内容复制到系统剪贴板
+- `-s, --solution-only`: 只输出题解内容
+- `-p, --problem-only`: 只输出题目内容
 
 示例：
 ```bash
@@ -77,6 +80,12 @@ 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/ -s
+
+# 只获取题目内容
+getmdfromleetcode -u https://leetcode.cn/problems/two-sum/ -p
+
 # 组合使用多个参数
 getmdfromleetcode -u https://leetcode.cn/problems/two-sum/ -e -c
 ```

package/index.js

@@ -11,7 +11,12 @@ 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';
+import { writeFileSync, readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 
 // 解析命令行参数
 const argv = yargs(hideBin(process.argv))
@@ -39,13 +44,42 @@ const argv = yargs(hideBin(process.argv))
     description: 'Copy output to clipboard',
     default: false
   })
+  .option('username', {
+    alias: 'n',
+    type: 'string',
+    description: 'Username for specific solution author',
+    default: 'endlesscheng'
+  })
+  .option('solutionOnly', {
+    alias: 's',
+    type: 'boolean',
+    description: 'Output solution only',
+    default: false
+  })
+  .option('problemOnly', {
+    alias: 'p',
+    type: 'boolean',
+    description: 'Output problem content only',
+    default: false
+  })
+  .option('flag', {
+    alias: 'f',
+    type: 'boolean',
+    description: 'Output tags and difficulty only',
+    default: false
+  })
+  .option('output', {
+    alias: 'o',
+    type: 'string',
+    description: 'Output file path'
+  })
   .help()
   .alias('help', 'h')
   .argv;
 
 // 主函数
 async function main() {
-  const { url, english, raw, clipboard } = argv;
+  const { url, english, raw, clipboard, username, solutionOnly, problemOnly, flag, output } = argv;
   const language = english ? 'english' : 'chinese';
   const rawOutput = raw;
   
@@ -54,24 +88,78 @@ async function main() {
     
     // 首先尝试通过GraphQL API获取数据
     try {
-      questionData = await fetchProblemDataViaGraphQL(url, language);
+      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);
+      questionData = await fetchProblemDataFromPage(url, language, username);
     }
     
     // 添加语言信息到 questionData
     questionData.isEnglish = english;
     
-    // 格式化为Markdown
-    const markdownContent = formatAsMarkdown(questionData, rawOutput);
+    // 根据solutionOnly或problemOnly参数决定输出内容
+    let outputContent;
+    if (solutionOnly && problemOnly) {
+      console.log('Cannot use both solutionOnly and problemOnly at the same time.');
+      return;
+    } else if (solutionOnly) {
+      // 只输出题解
+      if (questionData.solution) {
+        outputContent = formatAsMarkdown(questionData, rawOutput, true);
+      } else {
+        console.log('No solution found for the given problem.');
+        return;
+      }
+    } else if (problemOnly) {
+      // 只输出题目内容
+      outputContent = formatAsMarkdown(questionData, rawOutput, false, true);
+    } else if (flag) {
+      // 只输出标签和难度
+      let result = '';
+      
+      // 添加难度
+      if (questionData.difficulty) {
+        const difficultyLabel = questionData.isEnglish ? 'Difficulty: ' : '难度: ';
+        result += `${difficultyLabel}${questionData.difficulty}`;
+      }
+      
+      // 添加标签
+      if (questionData.topicTags && questionData.topicTags.length > 0) {
+        if (result) result += '\n'; // 如果已经有内容了，添加换行
+        const tagsLabel = questionData.isEnglish ? 'Tags: ' : '标签: ';
+        const tags = questionData.topicTags.map(tag =>
+          questionData.isEnglish ? tag.name : (tag.translatedName || tag.name)
+        ).join(', ');
+        result += `${tagsLabel}${tags}`;
+      } else {
+        if (result) result += '\n'; // 如果已经有内容了，添加换行
+        const noTagsMessage = questionData.isEnglish ? 'No tags found.' : '未找到标签.';
+        result += noTagsMessage;
+      }
+      
+      outputContent = result;
+    } else {
+      // 正常输出完整内容
+      outputContent = formatAsMarkdown(questionData, rawOutput);
+    }
+    
+    // 如果用户指定了输出文件，则写入文件
+    if (output) {
+      try {
+        writeFileSync(output, outputContent, 'utf8');
+        console.log(`Content successfully written to: ${output}`);
+      } catch (fileError) {
+        console.error('Failed to write to file:', fileError.message);
+        // 即使写入文件失败，仍然输出内容
+        console.log(outputContent);
+      }
+    }
     
     // 如果用户指定了复制到剪贴板的选项，则复制内容
     if (clipboard) {
       try {
         // 将内容写入临时文件
-        writeFileSync('/tmp/leetcode_content.txt', markdownContent);
+        writeFileSync('/tmp/leetcode_content.txt', outputContent);
         
         // 根据操作系统使用不同的命令复制到剪贴板
         if (process.platform === 'darwin') {
@@ -88,12 +176,12 @@ async function main() {
         console.log('Content copied to clipboard successfully!');
       } catch (clipboardError) {
         console.error('Failed to copy content to clipboard:', clipboardError.message);
-        // 即使复制到剪贴板失败，仍然输出内容
-        console.log(markdownContent);
       }
-    } else {
-      // 正常输出内容
-      console.log(markdownContent);
+    }
+    
+    // 如果没有指定输出文件或剪贴板，则输出到控制台
+    if (!output && !clipboard) {
+      console.log(outputContent);
     }
   } catch (error) {
     console.error('Error fetching or processing problem data:', error.message);

package/lib/markdownFormatter.js

@@ -5,15 +5,15 @@
 import * as cheerio from 'cheerio';
 
 // 将题目内容格式化为Markdown
-function formatAsMarkdown(question, rawOutput = false) {
+function formatAsMarkdown(question, rawOutput = false, solutionOnly = false, problemOnly = 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);
+  const url = question.url || '';
+  
   // 如果需要原始输出，则返回包含标题和难度的原始HTML内容
   if (rawOutput) {
     let rawResult = '';
@@ -25,108 +25,71 @@ function formatAsMarkdown(question, rawOutput = false) {
     }
     rawResult += content;
 
-    // 添加题解内容（如果存在）
-    if (solution && solution.content) {
-      rawResult += `\n\n<h2>题解</h2>\n`;
-      rawResult += solution.content || '';
-    } else {
-      rawResult += `\n\n<h2>题解</h2>\n`;
-      rawResult += `<p>没有找到题解</p>\n`;
+    // 如果不是只输出题目内容，才添加题解
+    if (!problemOnly) {
+      // 添加题解内容（如果存在）
+      if (solution && solution.content) {
+        rawResult += `\n\n<h2>题解</h2>\n`;
+        rawResult += solution.content || '';
+      } else {
+        rawResult += `\n\n<h2>题解</h2>\n`;
+        rawResult += `<p>没有找到题解</p>\n`;
+      }
     }
 
     return rawResult;
   }
 
-  // 使用cheerio处理HTML格式的描述
-  const $ = cheerio.load(content, { decodeEntities: false });
+  // 如果只输出题解
+  if (solutionOnly) {
+    if (solution && solution.content) {
+      // 检查 content 是否已经是 Markdown 格式
+      // 如果包含 Markdown 标记（如 ##, ```），则直接返回
+      if (isMarkdownContent(solution.content)) {
+        let result = '';
+        if (solution.title) {
+          result += `### ${solution.title}\n\n`;
+        }
+        result += solution.content;
+        return result;
+      } else {
+        // 使用 cheerio 处理题解的 HTML 内容
+        const $ = cheerio.load(solution.content, { decodeEntities: false });
+        return convertHtmlToMarkdown($, solution.title || '题解');
+      }
+    } else {
+      return '没有找到题解';
+    }
+  }
 
-  // 提取文本内容并格式化
-  let description = '';
+  // 如果只输出题目内容
+  if (problemOnly) {
+    // 使用cheerio处理HTML格式的描述
+    const $ = cheerio.load(content, { decodeEntities: false });
 
-  // 按照HTML中的顺序处理所有元素
-  $('body').children().each((i, elem) => {
-    const $elem = $(elem);
+    // 提取文本内容并格式化
+    let description = '';
 
-    if (elem.tagName === 'p') {
-      // 处理段落中的内联元素
-      let text = '';
-      $elem.contents().each((j, child) => {
-        const $child = $(child);
-        if (child.type === 'text') {
-          text += child.data;
-        } else if (child.tagName === 'strong') {
-          text += ` **${$child.text()}** `;
-        } else if (child.tagName === 'em') {
-          text += ` *${$child.text()}* `;
-        } else if (child.tagName === 'code') {
-          text += `\`${$child.text()}\``;
-        } else if (child.tagName === 'sup') {
-          // 处理上标（数学公式中的幂）
-          text += `^{${$child.text()}}`;
-        } else if (child.tagName === 'sub') {
-          // 处理下标
-          text += `_${$child.text()}`;
-        } else {
-          // 其他标签直接获取文本
-          text += $child.text();
-        }
-      });
-      text = text.trim();
-      if (text) {
-        // 特殊处理示例标题
-        if (text.startsWith('**示例') || text.startsWith('**Example')) {
-          // 去掉前后的**
-          text = text.replace(/^\*\*(.*)\*\*$/, '$1');
-          description += `\n\n## ${text}\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';
-        }
-      }
-    } else if (elem.tagName === 'pre') {
-      const codeText = $elem.text();
-      if (codeText) {
-        description += '```\n' + codeText + '```\n\n';
-      }
-    } else if (elem.tagName === 'ul' || elem.tagName === 'ol') {
-      $elem.children('li').each((j, li) => {
+    // 按照HTML中的顺序处理所有元素
+    $('body').children().each((i, elem) => {
+      const $elem = $(elem);
+
+      if (elem.tagName === 'p') {
+        // 处理段落中的内联元素
         let text = '';
-        // 保留li元素中的所有内容，包括strong标签
-        $(li).contents().each((k, child) => {
+        $elem.contents().each((j, child) => {
           const $child = $(child);
           if (child.type === 'text') {
             text += child.data;
           } else if (child.tagName === 'strong') {
             text += ` **${$child.text()}** `;
+          } else if (child.tagName === 'em') {
+            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}\``;
+            text += `\`${$child.text()}\``;
           } else if (child.tagName === 'sup') {
             // 处理上标（数学公式中的幂）
-            text += `^${$child.text()}`;
+            text += `^{${$child.text()}}`;
           } else if (child.tagName === 'sub') {
             // 处理下标
             text += `_${$child.text()}`;
@@ -135,16 +98,120 @@ function formatAsMarkdown(question, rawOutput = false) {
             text += $child.text();
           }
         });
-        if (text.trim()) {
-          // 处理列表项中的数学表达式
-          description += `- ${text.trim()}\n`;
+        text = text.trim();
+        if (text) {
+          // 特殊处理示例标题
+          if (text.startsWith('**示例') || text.startsWith('**Example')) {
+            // 去掉前后的**
+            text = text.replace(/^\*\*(.*)\*\*$/, '$1');
+            description += `\n\n## ${text}\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';
+          }
         }
-      });
-      description += '\n';
+      } else if (elem.tagName === 'pre') {
+        const codeText = $elem.text();
+        if (codeText) {
+          description += '```\n' + codeText + '```\n\n';
+        }
+      } else if (elem.tagName === 'ul' || elem.tagName === 'ol') {
+        $elem.children('li').each((j, li) => {
+          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') {
+                  codeText += `^${$(codeChild).text()}`;
+                } else if (codeChild.tagName === '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';
+      }
+    });
+
+    // 构建Markdown输出，只包含题目相关信息
+    let markdown = '';
+    if (title) {
+      markdown += `# ${title}\n\n`;
     }
-  });
 
-  // 构建Markdown输出
+    if (difficulty) {
+      markdown += `**Difficulty:** ${difficulty}\n\n`;
+    } else {
+      markdown += `**Difficulty:** 未找到\n\n`;
+    }
+
+    // 添加题目标签
+    if (topicTags.length > 0) {
+      const tags = topicTags.map(tag =>
+        tag.translatedName || tag.name
+      ).join(', ');
+      markdown += `**Tags:** ${tags}\n\n`;
+    }
+
+    if (description) {
+      // 格式化描述内容
+      let formattedDescription = description;
+
+      // 仅保留解释部分的处理
+      formattedDescription = formattedDescription.replace(/解释：/g, '\n**解释:** ');
+      formattedDescription = formattedDescription.replace(/Explanation:/g, '\n**Explanation:** ');
+
+      // 清理多余的空白字符
+      formattedDescription = formattedDescription.replace(/\n\s*\n\s*\n/g, '\n\n');
+      formattedDescription = formattedDescription.replace(/^ +/gm, '');
+
+      // 根据语言显示不同的标题
+      const descriptionTitle = isEnglish ? "Description" : "题目描述";
+      markdown += `## ${descriptionTitle}\n\n${formattedDescription}\n`;
+    } else {
+      const descriptionTitle = isEnglish ? "Description" : "题目描述";
+      markdown += `## ${descriptionTitle}\n\n未能提取到题目描述\n\n`;
+    }
+    
+    // 添加题目来源
+    if (url) {
+      markdown += `\n\n## SOURCE\n\n[${title}](${url})\n\n`;
+    }
+    
+    return markdown;
+  }
+
+  // 构建完整Markdown输出（包含题解）
   let markdown = '';
   if (title) {
     markdown += `# ${title}\n\n`;
@@ -164,12 +231,110 @@ function formatAsMarkdown(question, rawOutput = false) {
     markdown += `**Tags:** ${tags}\n\n`;
   }
 
-  if (description) {
+  if (content) {
+    // 使用cheerio处理HTML格式的描述
+    const $ = cheerio.load(content, { decodeEntities: false });
+
+    // 提取文本内容并格式化
+    let description = '';
+
+    // 按照HTML中的顺序处理所有元素
+    $('body').children().each((i, elem) => {
+      const $elem = $(elem);
+
+      if (elem.tagName === 'p') {
+        // 处理段落中的内联元素
+        let text = '';
+        $elem.contents().each((j, child) => {
+          const $child = $(child);
+          if (child.type === 'text') {
+            text += child.data;
+          } else if (child.tagName === 'strong') {
+            text += ` **${$child.text()}** `;
+          } else if (child.tagName === 'em') {
+            text += ` *${$child.text()}* `;
+          } else if (child.tagName === 'code') {
+            text += `\`${$child.text()}\``;
+          } else if (child.tagName === 'sup') {
+            // 处理上标（数学公式中的幂）
+            text += `^{${$child.text()}}`;
+          } else if (child.tagName === 'sub') {
+            // 处理下标
+            text += `_${$child.text()}`;
+          } else {
+            // 其他标签直接获取文本
+            text += $child.text();
+          }
+        });
+        text = text.trim();
+        if (text) {
+          // 特殊处理示例标题
+          if (text.startsWith('**示例') || text.startsWith('**Example')) {
+            // 去掉前后的**
+            text = text.replace(/^\*\*(.*)\*\*$/, '$1');
+            description += `\n\n## ${text}\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';
+          }
+        }
+      } else if (elem.tagName === 'pre') {
+        const codeText = $elem.text();
+        if (codeText) {
+          description += '```\n' + codeText + '```\n\n';
+        }
+      } else if (elem.tagName === 'ul' || elem.tagName === 'ol') {
+        $elem.children('li').each((j, li) => {
+          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') {
+                  codeText += `^${$(codeChild).text()}`;
+                } else if (codeChild.tagName === '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';
+      }
+    });
+
     // 格式化描述内容
     let formattedDescription = description;
 
     // 仅保留解释部分的处理
-    // 处理解释部分
     formattedDescription = formattedDescription.replace(/解释：/g, '\n**解释:** ');
     formattedDescription = formattedDescription.replace(/Explanation:/g, '\n**Explanation:** ');
 
@@ -181,32 +346,290 @@ function formatAsMarkdown(question, rawOutput = false) {
     const descriptionTitle = isEnglish ? "Description" : "题目描述";
     markdown += `## ${descriptionTitle}\n\n${formattedDescription}\n`;
   } else {
-    // 根据语言显示不同的标题
     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';
-
-    // 直接使用题解的原始内容，不进行Markdown格式转换
-    // 保留HTML格式并处理特殊字符
-    let solutionContent = solution.content || '';
+  
+  // 添加题解内容（如果存在且不是只输出题目内容）
+  if (!problemOnly) {
+    if (solution && solution.content) {
+      markdown += '\n## 题解\n\n';
+      // 检查 content 是否已经是 Markdown 格式
+      if (isMarkdownContent(solution.content)) {
+        if (solution.title) {
+          markdown += `### ${solution.title}\n\n`;
+        }
+        markdown += solution.content + '\n';
+      } else {
+        const $ = cheerio.load(solution.content, { decodeEntities: false });
+        markdown += convertHtmlToMarkdown($, solution.title || '题解') + '\n';
+      }
+    } else {
+      markdown += '\n## 题解\n\n';
+      markdown += '没有找到题解\n\n';
+    }
+  }
 
-    // 处理HTML实体，但保留HTML标签结构
-    // solutionContent = solutionContent.replace(/&lt;/g, '<').replace(/&gt;/g, '>');
+  return markdown;
+}
 
-    markdown += solutionContent + '\n';
-  } else {
-    markdown += '\n## 题解\n\n';
-    markdown += '没有找到题解\n\n';
+// 检查内容是否已经是 Markdown 格式
+function isMarkdownContent(content) {
+  // 检查是否包含常见的 Markdown 标记
+  const markdownPatterns = [
+    /^#{1,6}\s+/m,      // 标题
+    /\`\`\`/,            // 代码块
+    /\[.+\]\(.+\)/,      // 链接
+    /\*\*.+\*\*/,        // 粗体
+    /\*.+\*/,            // 斜体
+    /^-\s+/m,            // 无序列表
+    /^\d+\.\s+/m,        // 有序列表
+    /^\> /m,             // 引用
+    /\$\$?.+\$\$?/      // 数学公式
+  ];
+  
+  for (const pattern of markdownPatterns) {
+    if (pattern.test(content)) {
+      return true;
+    }
   }
+  
+  return false;
+}
 
+// 将 HTML 内容转换为 Markdown
+function convertHtmlToMarkdown($, title = '') {
+  let markdown = '';
+  
+  // 如果有标题，添加标题
+  if (title) {
+    markdown += `### ${title}\n\n`;
+  }
+  
+  // 递归处理每个元素
+  function processElement(elem) {
+    const $elem = $(elem);
+    const tagName = elem.tagName?.toLowerCase() || '';
+    
+    // 跳过注释和脚本
+    if (elem.type === 'comment' || tagName === 'script' || tagName === 'style') {
+      return '';
+    }
+    
+    let result = '';
+    
+    switch (tagName) {
+      case 'h1':
+      case 'h2':
+      case 'h3':
+      case 'h4':
+      case 'h5':
+      case 'h6':
+        const level = parseInt(tagName.charAt(1));
+        result = '\n' + '#'.repeat(level) + ' ' + processInlineElements($elem).trim() + '\n\n';
+        break;
+        
+      case 'p':
+        result = processInlineElements($elem) + '\n\n';
+        break;
+        
+      case 'strong':
+      case 'b':
+        result = '**' + processInlineElements($elem) + '**';
+        break;
+        
+      case 'em':
+      case 'i':
+        result = '*' + processInlineElements($elem) + '*';
+        break;
+        
+      case 'code':
+        const codeText = $elem.text();
+        // 检查是否是多行代码块
+        if (codeText.includes('\n')) {
+          result = '```\n' + codeText + '\n```\n\n';
+        } else {
+          result = '`' + codeText + '`';
+        }
+        break;
+        
+      case 'pre':
+        // 处理代码块
+        const $code = $elem.find('code').first();
+        const langClass = $code.attr('class') || '';
+        const langMatch = langClass.match(/language-(\w+)/);
+        const lang = langMatch ? langMatch[1] : '';
+        const preContent = $code.length > 0 ? $code.text() : $elem.text();
+        result = `\`\`\`${lang}\n${preContent}\n\`\`\`\n\n`;
+        break;
+        
+      case 'ul':
+        $elem.children('li').each((i, li) => {
+          result += '- ' + processInlineElements($(li)) + '\n';
+        });
+        result += '\n';
+        break;
+        
+      case 'ol':
+        $elem.children('li').each((i, li) => {
+          result += `${i + 1}. ` + processInlineElements($(li)) + '\n';
+        });
+        result += '\n';
+        break;
+        
+      case 'li':
+        result = processInlineElements($elem) + '\n';
+        break;
+        
+      case 'a':
+        const href = $elem.attr('href') || '';
+        const linkText = processInlineElements($elem);
+        result = `[${linkText}](${href})`;
+        break;
+        
+      case 'blockquote':
+        result = '> ' + processInlineElements($elem).replace(/\n/g, '\n> ') + '\n\n';
+        break;
+        
+      case 'br':
+        result = '\n';
+        break;
+        
+      case 'hr':
+        result = '\n---\n\n';
+        break;
+        
+      case 'table':
+        result = '\n' + processTable($elem) + '\n';
+        break;
+        
+      case 'img':
+        const src = $elem.attr('src') || '';
+        const alt = $elem.attr('alt') || '';
+        result = `![${alt}](${src})\n\n`;
+        break;
+        
+      case 'div':
+      case 'section':
+      case 'article':
+      case 'span':
+        $elem.contents().each((i, child) => {
+          if (child.type === 'text') {
+            const text = child.data.trim();
+            if (text) {
+              result += text + ' ';
+            }
+          } else if (child.tagName) {
+            result += processElement(child);
+          }
+        });
+        if (result.trim()) {
+          result += '\n\n';
+        }
+        break;
+        
+      default:
+        // 处理其他标签，递归处理其子元素
+        $elem.contents().each((i, child) => {
+          if (child.type === 'text') {
+            result += child.data;
+          } else if (child.tagName) {
+            result += processElement(child);
+          }
+        });
+        break;
+    }
+    
+    return result;
+  }
+  
+  // 处理内联元素
+  function processInlineElements($elem) {
+    let result = '';
+    $elem.contents().each((i, child) => {
+      if (child.type === 'text') {
+        result += child.data;
+      } else if (child.tagName) {
+        const tagName = child.tagName?.toLowerCase() || '';
+        if (['sup', 'sub'].includes(tagName)) {
+          const content = processInlineElements($(child));
+          result += tagName === 'sup' ? `^${content}` : `_${content}`;
+        } else {
+          result += processElement(child);
+        }
+      }
+    });
+    return result;
+  }
+  
+  // 处理表格
+  function processTable($table) {
+    let tableMarkdown = '';
+    
+    // 收集所有行
+    const rows = [];
+    
+    // 处理表头
+    const $thead = $table.find('thead').first();
+    if ($thead.length) {
+      $thead.find('tr').each((i, tr) => {
+        const $tr = $(tr);
+        const $cells = $tr.find('th');
+        if ($cells.length) {
+          rows.push({
+            cells: $cells.map((j, cell) => processInlineElements($(cell))).get(),
+            isHeader: true
+          });
+        }
+      });
+    }
+    
+    // 处理表体
+    const $tbody = $table.find('tbody').first();
+    const $rows = $tbody.length ? $tbody.find('tr') : $table.find('tr');
+    $rows.each((i, tr) => {
+      const $tr = $(tr);
+      const $cells = $tr.find('td, th');
+      if ($cells.length) {
+        rows.push({
+          cells: $cells.map((j, cell) => processInlineElements($(cell))).get(),
+          isHeader: false
+        });
+      }
+    });
+    
+    if (rows.length > 0) {
+      // 添加表头行
+      const headerRow = rows[0];
+      tableMarkdown += '| ' + headerRow.cells.join(' | ') + ' |\n';
+      
+      // 添加分隔行
+      tableMarkdown += '| ' + headerRow.cells.map(() => '---').join(' | ') + ' |\n';
+      
+      // 添加数据行
+      for (let i = headerRow.isHeader ? 1 : 0; i < rows.length; i++) {
+        const row = rows[i];
+        tableMarkdown += '| ' + row.cells.join(' | ') + ' |\n';
+      }
+    }
+    
+    return tableMarkdown;
+  }
+  
+  // 处理 body 中的所有内容
+  $('body').contents().each((i, elem) => {
+    markdown += processElement(elem);
+  });
+  
+  // 清理多余的空行
+  markdown = markdown.replace(/\n{3,}/g, '\n\n');
+  
   return markdown;
 }
 
-export { formatAsMarkdown };
+export { formatAsMarkdown };

package/lib/problemDataFetcher.js

@@ -3,7 +3,7 @@
  */
 
 // 使用GraphQL API获取LeetCode题目数据
-async function fetchProblemDataViaGraphQL(url, language = 'chinese') {
+async function fetchProblemDataViaGraphQL(url, language = 'chinese', username = null) {
   // 从URL中提取题目slug
   const match = url.match(/\/problems\/([^/]+)/);
   const slug = match ? match[1] : null;
@@ -35,8 +35,8 @@ async function fetchProblemDataViaGraphQL(url, language = 'chinese') {
   `;
   
   const solutionQuery = `
-    query solutionData($slug: String!) {
-      questionSolutionArticles(first: 1, questionSlug: $slug) {
+    query solutionData($slug: String!, $first: Int) {
+      questionSolutionArticles(first: $first, questionSlug: $slug) {
         edges {
           node {
             title
@@ -85,7 +85,7 @@ async function fetchProblemDataViaGraphQL(url, language = 'chinese') {
     },
     body: JSON.stringify({
       query: solutionQuery,
-      variables: { slug: slug }
+      variables: { slug: slug, first: 20 } // 增加数量以查找特定用户
     })
   });
   
@@ -114,7 +114,23 @@ async function fetchProblemDataViaGraphQL(url, language = 'chinese') {
   if (solutionData && solutionData.data && solutionData.data.questionSolutionArticles && 
       solutionData.data.questionSolutionArticles.edges && 
       solutionData.data.questionSolutionArticles.edges.length > 0) {
-    question.solution = solutionData.data.questionSolutionArticles.edges[0].node;
+      
+    if (username) {
+      // 尝试查找指定用户名的题解
+      const userSolution = solutionData.data.questionSolutionArticles.edges.find(edge => 
+        edge.node.author && edge.node.author.username === username
+      );
+      
+      // 如果找到了指定用户的题解，则使用它；否则使用第一个题解
+      if (userSolution) {
+        question.solution = userSolution.node;
+      } else if (solutionData.data.questionSolutionArticles.edges.length > 0) {
+        question.solution = solutionData.data.questionSolutionArticles.edges[0].node;
+      }
+    } else {
+      // 如果没有指定用户名，则使用第一个题解
+      question.solution = solutionData.data.questionSolutionArticles.edges[0].node;
+    }
   }
   
   // 添加URL到question对象
@@ -124,7 +140,7 @@ async function fetchProblemDataViaGraphQL(url, language = 'chinese') {
 }
 
 // 从页面的__NEXT_DATA__中提取题目数据
-async function fetchProblemDataFromPage(url, language = 'chinese') {
+async function fetchProblemDataFromPage(url, language = 'chinese', username = null) {
   // 从URL中提取题目slug
   const match = url.match(/\/problems\/([^/]+)/);
   const slug = match ? match[1] : null;
@@ -183,7 +199,7 @@ async function fetchProblemDataFromPage(url, language = 'chinese') {
     
     // 单独获取题解数据，因为页面中可能不包含题解数据
     try {
-      const solutionData = await fetchSolutionData(slug);
+      const solutionData = await fetchSolutionData(slug, username);
       if (solutionData) {
         question.solution = solutionData;
       }
@@ -201,12 +217,12 @@ async function fetchProblemDataFromPage(url, language = 'chinese') {
 }
 
 // 单独获取题解数据
-async function fetchSolutionData(slug) {
+async function fetchSolutionData(slug, username = null) {
   const graphqlUrl = 'https://leetcode.cn/graphql';
   
   const solutionQuery = `
-    query solutionData($slug: String!) {
-      questionSolutionArticles(first: 1, questionSlug: $slug) {
+    query solutionData($slug: String!, $first: Int) {
+      questionSolutionArticles(first: $first, questionSlug: $slug) {
         edges {
           node {
             title
@@ -230,7 +246,7 @@ async function fetchSolutionData(slug) {
     },
     body: JSON.stringify({
       query: solutionQuery,
-      variables: { slug: slug }
+      variables: { slug: slug, first: 20 }  // 增加数量以查找特定用户
     })
   });
   
@@ -247,7 +263,23 @@ async function fetchSolutionData(slug) {
   if (solutionData.data && solutionData.data.questionSolutionArticles && 
       solutionData.data.questionSolutionArticles.edges && 
       solutionData.data.questionSolutionArticles.edges.length > 0) {
-    return solutionData.data.questionSolutionArticles.edges[0].node;
+      
+    if (username) {
+      // 尝试查找指定用户名的题解
+      const userSolution = solutionData.data.questionSolutionArticles.edges.find(edge => 
+        edge.node.author && edge.node.author.username === username
+      );
+      
+      // 如果找到了指定用户的题解，则使用它；否则使用第一个题解
+      if (userSolution) {
+        return userSolution.node;
+      } else {
+        return solutionData.data.questionSolutionArticles.edges[0].node;
+      }
+    } else {
+      // 如果没有指定用户名，则返回第一个题解
+      return solutionData.data.questionSolutionArticles.edges[0].node;
+    }
   }
   
   return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "getmdfromleetcode",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "A command line tool to fetch LeetCode problem content and convert it to Markdown",
   "main": "index.js",
   "type": "module",
@@ -10,7 +10,13 @@
   "scripts": {
     "start": "node index.js"
   },
-  "keywords": ["leetcode", "markdown", "cli", "solution", "algorithm"],
+  "keywords": [
+    "leetcode",
+    "markdown",
+    "cli",
+    "solution",
+    "algorithm"
+  ],
   "author": "User",
   "license": "MIT",
   "dependencies": {
@@ -28,4 +34,4 @@
   "engines": {
     "node": ">=14.0.0"
   }
-}
+}