@ww_nero/mini-cli 1.0.56

package/src/tools/python/html_to_pptx.py

@@ -0,0 +1,163 @@
+"""Convert multiple HTML files into a single PPTX via Playwright screenshots."""
+from __future__ import annotations
+
+import argparse
+import sys
+import tempfile
+from pathlib import Path
+from typing import Iterable, List
+
+from PIL import Image
+from playwright.sync_api import sync_playwright
+from pptx import Presentation
+from pptx.util import Inches
+
+
+SLIDE_SIZE_43 = (Inches(10), Inches(7.5))  # 4:3
+SLIDE_SIZE_169 = (Inches(13.3333), Inches(7.5))  # 16:9
+MIN_WIDTH = 320
+MIN_HEIGHT = 240
+DEVICE_SCALE_FACTOR = 4
+
+
+def _find_target_element(page):
+    body = page.query_selector('body')
+    if body is None:
+        raise ValueError('未找到 body 元素')
+
+    top_level_elements = body.query_selector_all(':scope > *')
+    if not top_level_elements:
+        raise ValueError('body 中未找到可截图元素')
+
+    # 单个最外层节点时直接使用该节点，否则使用整个 body
+    return top_level_elements[0] if len(top_level_elements) == 1 else body
+
+
+def _measure_element(element):
+    size = element.evaluate(
+        """
+        (el) => {
+            const rect = el.getBoundingClientRect();
+            const width = Math.max(rect.width || 0, el.scrollWidth || 0, el.offsetWidth || 0);
+            const height = Math.max(rect.height || 0, el.scrollHeight || 0, el.offsetHeight || 0);
+            return { width, height };
+        }
+        """
+    )
+    width = max(1, int(size.get('width') or 0))
+    height = max(1, int(size.get('height') or 0))
+    return width, height
+
+
+def _choose_slide_size(aspect_ratios: Iterable[float]):
+    ratios = [ratio for ratio in aspect_ratios if ratio > 0]
+    if not ratios:
+        return SLIDE_SIZE_43
+    average_ratio = sum(ratios) / len(ratios)
+    diff_43 = abs(average_ratio - (4 / 3))
+    diff_169 = abs(average_ratio - (16 / 9))
+    return SLIDE_SIZE_43 if diff_43 <= diff_169 else SLIDE_SIZE_169
+
+
+def capture_html_to_image(page, html_path: Path, target_path: Path, wait_ms: int) -> float:
+    file_url = html_path.as_uri()
+    page.goto(file_url)
+    page.wait_for_timeout(wait_ms)
+    target = _find_target_element(page)
+    element_width, element_height = _measure_element(target)
+    viewport_width = max(MIN_WIDTH, element_width)
+    viewport_height = max(MIN_HEIGHT, element_height)
+    page.set_viewport_size({'width': viewport_width, 'height': viewport_height})
+    page.wait_for_timeout(200)
+    target.screenshot(path=str(target_path))
+    return element_width / element_height if element_height else 1.0
+
+
+def build_presentation(images: Iterable[Path], output_file: Path, slide_size) -> Path:
+    slide_width, slide_height = slide_size
+    presentation = Presentation()
+    presentation.slide_width = slide_width
+    presentation.slide_height = slide_height
+
+    # Remove default slide if present
+    while len(presentation.slides) > 0:
+        slide_id = presentation.slides._sldIdLst[0].rId
+        presentation.part.drop_rel(slide_id)
+        del presentation.slides._sldIdLst[0]
+
+    layout = presentation.slide_layouts[6]
+    for image_path in images:
+        with Image.open(image_path) as image:
+            image_ratio = image.width / image.height if image.height else 1.0
+        slide_ratio = slide_width / slide_height if slide_height else image_ratio
+        if slide_ratio >= image_ratio:
+            target_height = slide_height
+            target_width = int(target_height * image_ratio)
+        else:
+            target_width = slide_width
+            target_height = int(target_width / image_ratio)
+        left = max(0, (slide_width - target_width) // 2)
+        top = max(0, (slide_height - target_height) // 2)
+        slide = presentation.slides.add_slide(layout)
+        slide.shapes.add_picture(str(image_path), left, top, width=target_width, height=target_height)
+
+    presentation.save(str(output_file))
+    return output_file
+
+
+def convert_html_list_to_pptx(html_files: Iterable[str | Path], output_file: str | Path, wait_ms: int = 1500) -> Path:
+    html_paths = [Path(item).expanduser().resolve() for item in html_files]
+    if not html_paths:
+        raise ValueError('请提供至少一个 HTML 文件')
+    for path_item in html_paths:
+        if not path_item.exists():
+            raise FileNotFoundError(f'HTML 文件不存在: {path_item}')
+
+    output_path = Path(output_file).expanduser().resolve()
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    screenshots: List[Path] = []
+    aspect_ratios: List[float] = []
+    with tempfile.TemporaryDirectory() as temp_dir:
+        temp_root = Path(temp_dir)
+        with sync_playwright() as playwright:
+            browser = playwright.chromium.launch(headless=True)
+            context = browser.new_context(
+                viewport={'width': MIN_WIDTH, 'height': MIN_HEIGHT},
+                device_scale_factor=DEVICE_SCALE_FACTOR
+            )
+            page = context.new_page()
+            try:
+                for index, html_path in enumerate(html_paths, start=1):
+                    target_file = temp_root / f'slide_{index:04d}.png'
+                    ratio = capture_html_to_image(page, html_path, target_file, wait_ms)
+                    screenshots.append(target_file)
+                    aspect_ratios.append(ratio)
+            finally:
+                context.close()
+                browser.close()
+        slide_size = _choose_slide_size(aspect_ratios)
+        build_presentation(screenshots, output_path, slide_size)
+    return output_path
+
+
+def _parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description='将多个 HTML 文件合并到单个 PPTX 中。')
+    parser.add_argument('--inputs', nargs='+', required=True, help='HTML 文件路径列表')
+    parser.add_argument('--output', required=True, help='输出 PPTX 文件路径')
+    parser.add_argument('--wait', type=int, default=1500, help='每个页面加载等待时间，单位毫秒，默认 1500')
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = _parse_args()
+    try:
+        result = convert_html_list_to_pptx(args.inputs, args.output, wait_ms=args.wait)
+        print(f'已生成 PPTX: {result}')
+    except Exception as error:
+        print(f'转换失败: {error}', file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()

package/src/tools/python/pdf_to_png.py

@@ -0,0 +1,58 @@
+"""Convert PDF pages to PNG files."""
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+from typing import List
+
+from pdf2image import convert_from_path
+
+
+def convert_pdf_to_png(input_file: str | Path, output_dir: str | Path, dpi: int = 300, fmt: str = 'png') -> List[Path]:
+    """Convert a PDF into PNG images and return saved file paths."""
+    input_path = Path(input_file).expanduser().resolve()
+    if not input_path.exists():
+        raise FileNotFoundError(f'PDF文件不存在: {input_path}')
+
+    output_path = Path(output_dir).expanduser().resolve()
+    output_path.mkdir(parents=True, exist_ok=True)
+
+    format_lower = fmt.lower() or 'png'
+    images = convert_from_path(str(input_path), dpi=dpi, fmt=format_lower)
+
+    saved_files: List[Path] = []
+    for index, image in enumerate(images, start=1):
+        file_name = f'page_{index:04d}.{format_lower}'
+        target = output_path / file_name
+        image.save(str(target), format_lower.upper())
+        saved_files.append(target)
+
+    return saved_files
+
+
+def _parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description='将 PDF 转换为 PNG 图片。')
+    parser.add_argument('--input', required=True, help='待转换的 PDF 文件路径')
+    parser.add_argument('--output-dir', required=True, help='保存图片的目录')
+    parser.add_argument('--dpi', type=int, default=300, help='输出图片的 DPI，默认 300')
+    parser.add_argument('--format', default='png', help='输出图片格式，默认 PNG')
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = _parse_args()
+    try:
+        results = convert_pdf_to_png(args.input, args.output_dir, dpi=args.dpi, fmt=args.format)
+        if not results:
+            print('未生成任何图片')
+            return
+        print(f'成功生成 {len(results)} 张图片:')
+        for path in results:
+            print(path)
+    except Exception as error:
+        print(f'转换失败: {error}', file=sys.stderr)
+        sys.exit(1)
+
+if __name__ == '__main__':
+    main()

package/src/tools/python/pptx_to_pdf.py

@@ -0,0 +1,107 @@
+"""使用 LibreOffice 无头模式将 PPT/PPTX 直接转换为 PDF。"""
+from __future__ import annotations
+
+import argparse
+import os
+import platform
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+
+def _detect_libreoffice() -> str:
+    """寻找 LibreOffice 可执行文件路径。"""
+    system = platform.system()
+    candidates: list[str] = []
+
+    if system == 'Darwin':
+        candidates.append('/Applications/LibreOffice.app/Contents/MacOS/soffice')
+    elif system == 'Windows':
+        program_dirs = [
+            os.environ.get('PROGRAMFILES', ''),
+            os.environ.get('PROGRAMFILES(X86)', '')
+        ]
+        for base in program_dirs:
+            if base:
+                candidates.append(str(Path(base) / 'LibreOffice' / 'program' / 'soffice.exe'))
+
+    # 通用命令放在末尾，优先尝试绝对路径
+    candidates.extend(['soffice', 'libreoffice'])
+
+    for candidate in candidates:
+        candidate_path = Path(candidate)
+        if candidate_path.exists():
+            return str(candidate_path)
+
+        resolved = shutil.which(candidate)
+        if resolved:
+            return resolved
+
+    return ''
+
+
+def pptx_to_pdf(input_file: str | Path, output_file: str | Path) -> Path:
+    pptx_path = Path(input_file).expanduser().resolve()
+    if not pptx_path.exists():
+        raise FileNotFoundError(f'PPT/PPTX 文件不存在: {pptx_path}')
+    if pptx_path.is_dir():
+        raise ValueError(f'输入路径不是文件: {pptx_path}')
+
+    output_path = Path(output_file).expanduser().resolve()
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    libreoffice_cmd = _detect_libreoffice()
+    if not libreoffice_cmd:
+        raise RuntimeError('未找到 LibreOffice，请先安装（例如 apt install libreoffice 或从官网安装包）。')
+
+    with tempfile.TemporaryDirectory(prefix='pptx_to_pdf_') as temp_dir:
+        cmd = [
+            libreoffice_cmd,
+            '--headless',
+            '--invisible',
+            '--convert-to', 'pdf',
+            '--outdir', temp_dir,
+            str(pptx_path)
+        ]
+
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        if result.returncode != 0:
+            message = result.stderr.strip() or result.stdout.strip() or 'LibreOffice 返回非零退出码'
+            raise RuntimeError(f'LibreOffice 转换失败: {message}')
+
+        generated = Path(temp_dir) / f'{pptx_path.stem}.pdf'
+        if not generated.exists():
+            pdf_candidates = list(Path(temp_dir).glob('*.pdf'))
+            if len(pdf_candidates) == 1:
+                generated = pdf_candidates[0]
+            else:
+                raise RuntimeError('未找到 LibreOffice 生成的 PDF 文件')
+
+        if output_path.exists():
+            output_path.unlink()
+
+        shutil.move(str(generated), str(output_path))
+        return output_path
+
+
+def _parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description='将 PPT/PPTX 转换为 PDF（调用 LibreOffice 无头模式）。')
+    parser.add_argument('--input', required=True, help='PPT/PPTX 文件路径')
+    parser.add_argument('--output', required=True, help='输出 PDF 文件路径')
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = _parse_args()
+    try:
+        result = pptx_to_pdf(args.input, args.output)
+        print(f'已生成 PDF: {result}')
+    except Exception as error:
+        print(f'转换失败: {error}', file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()

package/src/tools/read.js

@@ -0,0 +1,44 @@
+const { resolveWorkspacePath, readTextFile } = require('../utils/helpers');
+
+const readFile = async ({ filePath } = {}, context = {}) => {
+  if (!filePath || typeof filePath !== 'string') {
+    return 'filePath 参数不能为空';
+  }
+
+  let absolutePath;
+  try {
+    absolutePath = resolveWorkspacePath(context.workspaceRoot, filePath);
+  } catch (error) {
+    return `无效路径: ${error.message}`;
+  }
+
+  try {
+    return await readTextFile(absolutePath);
+  } catch (error) {
+    return `读取失败 ${filePath}: ${error.message}`;
+  }
+};
+
+const schema = {
+  type: 'function',
+  function: {
+    name: 'read_file',
+    description: '读取指定相对路径的文本类文件完整内容，不支持二进制文件',
+    parameters: {
+      type: 'object',
+      properties: {
+        filePath: {
+          type: 'string',
+          description: '文本文件的相对路径，例如 src/App.js'
+        }
+      },
+      required: ['filePath']
+    }
+  }
+};
+
+module.exports = {
+  name: 'read_file',
+  schema,
+  handler: readFile
+};

package/src/tools/replace.js

@@ -0,0 +1,135 @@
+const { diffLines } = require('diff');
+const {
+  resolveWorkspacePath,
+  readTextFile,
+  writeTextFile,
+  normalizeLineBreaks,
+  isCodeIdentical,
+  processContent
+} = require('../utils/helpers');
+
+const countLines = (text = '') => {
+  if (!text) return 0;
+  const normalized = text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+  const lines = normalized.split('\n');
+  if (lines[lines.length - 1] === '') {
+    lines.pop();
+  }
+  return lines.length;
+};
+
+const computeDiffStats = (before = '', after = '') => {
+  const parts = diffLines(before, after);
+  return parts.reduce((acc, part) => {
+    if (part.added) {
+      acc.added += countLines(part.value);
+    } else if (part.removed) {
+      acc.removed += countLines(part.value);
+    }
+    return acc;
+  }, { added: 0, removed: 0 });
+};
+
+const replaceInFile = async ({ filePath, search, replace } = {}, context = {}) => {
+  if (!filePath || typeof filePath !== 'string') {
+    return 'filePath 参数不能为空';
+  }
+  if (typeof search !== 'string' || search.trim() === '') {
+    return 'search 参数不能为空';
+  }
+  if (typeof replace !== 'string') {
+    return 'replace 参数必须是字符串，可为空字符串表示删除';
+  }
+
+  let absolutePath;
+  try {
+    absolutePath = resolveWorkspacePath(context.workspaceRoot, filePath);
+  } catch (error) {
+    return `无效路径: ${error.message}`;
+  }
+
+  let originCode;
+  try {
+    originCode = await readTextFile(absolutePath);
+  } catch (error) {
+    return `读取文件失败 ${filePath}: ${error.message}`;
+  }
+
+  const normalizedOrigin = normalizeLineBreaks(originCode);
+  const normalizedSearch = normalizeLineBreaks(search);
+  let normalizedReplace = normalizeLineBreaks(replace);
+
+  if (!normalizedSearch) {
+    return 'search 参数规范化后为空';
+  }
+
+  if (normalizedReplace) {
+    normalizedReplace = normalizedReplace.replace(/\n+$/, '');
+    if (/\n$/.test(replace)) {
+      normalizedReplace += '\n';
+    }
+  }
+
+  let searchPattern = normalizedSearch;
+  if (!normalizedReplace || normalizedReplace.trim() === '') {
+    if (normalizedOrigin.includes(normalizedSearch + '\n')) {
+      searchPattern = normalizedSearch + '\n';
+    } else if (normalizedOrigin.includes('\n' + normalizedSearch)) {
+      searchPattern = '\n' + normalizedSearch;
+    }
+  }
+
+  if (!normalizedOrigin.includes(searchPattern)) {
+    return `在文件 ${filePath} 中未找到要搜索的内容`;
+  }
+
+  const updated = normalizedOrigin.replaceAll(searchPattern, normalizedReplace);
+  if (isCodeIdentical(originCode, updated)) {
+    return `修改前后内容相同: ${filePath}`;
+  }
+
+  const processed = processContent(updated);
+  try {
+    await writeTextFile(absolutePath, processed);
+    const diffStats = computeDiffStats(normalizedOrigin, normalizeLineBreaks(processed));
+    return {
+      success: true,
+      message: `搜索替换成功: ${filePath}`,
+      diffStats
+    };
+  } catch (error) {
+    return `搜索替换失败 ${filePath}: ${error.message}`;
+  }
+};
+
+const schema = {
+  type: 'function',
+  function: {
+    name: 'search_and_replace',
+    description: '在文件中搜索并替换指定的代码片段（简单字符串匹配，非正则）',
+    parameters: {
+      type: 'object',
+      properties: {
+        filePath: {
+          type: 'string',
+          description: '文件的相对路径'
+        },
+        search: {
+          type: 'string',
+          description: '原始代码片段（完整拷贝，勿省略）'
+        },
+        replace: {
+          type: 'string',
+          description: '替换后的代码片段，可为空字符串表示删除'
+        }
+      },
+      required: ['filePath', 'search', 'replace']
+    }
+  }
+};
+
+module.exports = {
+  name: 'search_and_replace',
+  schema,
+  handler: replaceInFile
+};

package/src/tools/todos.js

@@ -0,0 +1,90 @@
+const chalk = require('chalk');
+
+const STATUS_EMOJI = {
+  pending: '⬜',
+  in_progress: '🕒',
+  completed: '✅'
+};
+
+const formatTodosList = (todos = []) => {
+  if (!Array.isArray(todos) || todos.length === 0) {
+    return '暂无待办事项';
+  }
+
+  const lines = todos.map(item => {
+    const emoji = STATUS_EMOJI[item.status] || STATUS_EMOJI.pending;
+    const content = String(item.content || '').replace(/\s+/g, ' ').trim();
+    return `${emoji} ${content}`;
+  });
+
+  return `${lines.join('\n')}`;
+};
+
+const validateTodos = (todos) => {
+  if (!Array.isArray(todos)) {
+    return 'todos 必须是数组';
+  }
+  for (const item of todos) {
+    if (!item || typeof item !== 'object') {
+      return 'todos 中的每一项必须是对象';
+    }
+    if (!item.id || !item.content || !item.status) {
+      return '每个待办事项必须包含 id/content/status';
+    }
+    if (!['pending', 'in_progress', 'completed'].includes(item.status)) {
+      return 'status 仅支持 pending/in_progress/completed';
+    }
+  }
+  return null;
+};
+
+let lastTodos = [];
+
+const writeTodos = async ({ todos } = {}) => {
+  const error = validateTodos(todos);
+  if (error) {
+    return error;
+  }
+  lastTodos = todos;
+  const formatted = formatTodosList(todos);
+  return formatted;
+};
+
+const schema = {
+  type: 'function',
+  function: {
+    name: 'write_todos',
+    description: '更新任务列表（创建、修改、完成）',
+    parameters: {
+      type: 'object',
+      properties: {
+        todos: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              id: { type: 'string' },
+              content: { type: 'string' },
+              status: {
+                type: 'string',
+                enum: ['pending', 'in_progress', 'completed']
+              }
+            },
+            required: ['id', 'content', 'status']
+          },
+          description: '完整的待办事项数组'
+        }
+      },
+      required: ['todos']
+    }
+  }
+};
+
+const getLastTodos = () => lastTodos;
+
+module.exports = {
+  name: 'write_todos',
+  schema,
+  handler: writeTodos,
+  getLastTodos
+};

package/src/tools/write.js

@@ -0,0 +1,52 @@
+const { resolveWorkspacePath, writeTextFile } = require('../utils/helpers');
+
+const writeFile = async ({ filePath, content } = {}, context = {}) => {
+  if (!filePath || typeof filePath !== 'string') {
+    return 'filePath 参数不能为空';
+  }
+  if (typeof content !== 'string') {
+    return 'content 必须是字符串';
+  }
+
+  let absolutePath;
+  try {
+    absolutePath = resolveWorkspacePath(context.workspaceRoot, filePath);
+  } catch (error) {
+    return `无效路径: ${error.message}`;
+  }
+
+  try {
+    await writeTextFile(absolutePath, content);
+    return `写入成功: ${filePath}`;
+  } catch (error) {
+    return `写入失败 ${filePath}: ${error.message}`;
+  }
+};
+
+const schema = {
+  type: 'function',
+  function: {
+    name: 'write_file',
+    description: '向文件写入完整内容（不存在则创建）',
+    parameters: {
+      type: 'object',
+      properties: {
+        filePath: {
+          type: 'string',
+          description: '文件的相对路径'
+        },
+        content: {
+          type: 'string',
+          description: '写入的完整内容'
+        }
+      },
+      required: ['filePath', 'content']
+    }
+  }
+};
+
+module.exports = {
+  name: 'write_file',
+  schema,
+  handler: writeFile
+};

package/src/utils/cliOptions.js

@@ -0,0 +1,8 @@
+const CLI_OPTIONS = [
+  { flags: '-i, --input <text>', description: '启动后先发送一条问题' },
+  { flags: '-m, --model <name>', description: '指定启动模型名称（等同于运行 /model <name>）' }
+];
+
+module.exports = {
+  CLI_OPTIONS
+};