@ww_nero/mini-cli 1.0.56

package/src/tools/convert.js

@@ -0,0 +1,297 @@
+const { spawn } = require('child_process');
+const fs = require('fs');
+const fsPromises = require('fs/promises');
+const path = require('path');
+const { resolveWorkspacePath } = require('../utils/helpers');
+
+const EXECUTION_TIMEOUT = 300000;
+const PYTHON_SCRIPT_ROOT = path.join(__dirname, 'python');
+
+const TYPE_META = {
+  pdf_to_png: {
+    inputType: 'file',
+    outputType: 'directory',
+    description: '将 PDF 每一页转成 PNG 图片'
+  },
+  html_to_pptx: {
+    inputType: 'list',
+    outputType: 'file',
+    description: '多个 HTML 截屏后合并为单 PPTX，保持原顺序'
+  },
+  html_to_png: {
+    inputType: 'file',
+    outputType: 'file',
+    description: '将单个 HTML 文件转换为 PNG 图片'
+  },
+  pptx_to_pdf: {
+    inputType: 'file',
+    outputType: 'file',
+    description: '通过 LibreOffice 直接将 PPT/PPTX 导出为 PDF'
+  }
+};
+
+const PYTHON_SCRIPTS = {
+  pdf_to_png: 'pdf_to_png.py',
+  html_to_pptx: 'html_to_pptx.py',
+  html_to_png: 'html_to_png.py',
+  pptx_to_pdf: 'pptx_to_pdf.py'
+};
+
+const TYPE_ENUM = Object.keys(TYPE_META);
+
+const shellQuote = (value = '') => {
+  const str = String(value);
+  const escaped = str.replace(/(["$`\\])/g, '\\$1');
+  return `"${escaped}"`;
+};
+
+const normalizeListInput = (input) => {
+  if (Array.isArray(input)) {
+    return input;
+  }
+  if (typeof input === 'string' && input.trim()) {
+    const trimmed = input.trim();
+    if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (Array.isArray(parsed)) {
+          return parsed;
+        }
+      } catch (error) {
+        // fall through to treating as single path
+      }
+    }
+    return [trimmed];
+  }
+  return [];
+};
+
+const ensureOutputLocation = async (targetPath, kind) => {
+  if (kind === 'directory') {
+    await fsPromises.mkdir(targetPath, { recursive: true });
+    return;
+  }
+  await fsPromises.mkdir(path.dirname(targetPath), { recursive: true });
+};
+
+const runBashCommand = (command, cwd) => new Promise((resolve, reject) => {
+  const child = spawn('bash', ['-lc', command], {
+    cwd,
+    env: process.env,
+    stdio: ['ignore', 'pipe', 'pipe']
+  });
+
+  let stdout = '';
+  let stderr = '';
+  let finished = false;
+
+  const finalize = (error) => {
+    if (finished) return;
+    finished = true;
+    clearTimeout(timeoutId);
+    if (error) {
+      reject(error);
+    } else {
+      resolve(stdout.trim());
+    }
+  };
+
+  child.stdout.on('data', (chunk) => {
+    stdout += chunk.toString();
+  });
+
+  child.stderr.on('data', (chunk) => {
+    stderr += chunk.toString();
+  });
+
+  child.on('error', (error) => {
+    finalize(error);
+  });
+
+  child.on('close', (code) => {
+    if (code === 0) {
+      finalize();
+      return;
+    }
+    const message = stderr.trim() || stdout.trim() || `命令执行失败，退出码 ${code}`;
+    finalize(new Error(message));
+  });
+
+  const timeoutId = setTimeout(() => {
+    child.kill('SIGTERM');
+    finalize(new Error('命令执行超时 (超过 300s)'));
+  }, EXECUTION_TIMEOUT);
+});
+
+const runPythonScript = async (scriptPath, scriptArgs = [], workspaceRoot) => {
+  const quotedScript = shellQuote(scriptPath);
+  const argsString = scriptArgs.join(' ');
+  const appendArgs = argsString ? ` ${argsString}` : '';
+
+  try {
+    return await runBashCommand(`python3 ${quotedScript}${appendArgs}`, workspaceRoot);
+  } catch (error) {
+    const message = error?.message || '';
+    if (/python3: command not found/.test(message) || /python3: not found/.test(message)) {
+      return runBashCommand(`python ${quotedScript}${appendArgs}`, workspaceRoot);
+    }
+    throw error;
+  }
+};
+
+const resolveInputPaths = (inputType, input, workspaceRoot, typeName) => {
+  if (inputType === 'list') {
+    const list = normalizeListInput(input);
+    if (list.length === 0) {
+      throw new Error(`${typeName} 需要至少一个输入路径`);
+    }
+    const resolvedList = list.map((item, index) => {
+      if (typeof item !== 'string' || !item.trim()) {
+        throw new Error(`第 ${index + 1} 个输入路径无效`);
+      }
+      const resolved = resolveWorkspacePath(workspaceRoot, item.trim());
+      if (!fs.existsSync(resolved)) {
+        throw new Error(`输入文件不存在: ${resolved}`);
+      }
+      return resolved;
+    });
+    return { list: resolvedList };
+  }
+
+  if (typeof input !== 'string' || !input.trim()) {
+    throw new Error(`${typeName} 需要传入单个输入文件路径`);
+  }
+  const resolved = resolveWorkspacePath(workspaceRoot, input.trim());
+  if (!fs.existsSync(resolved)) {
+    throw new Error(`输入文件不存在: ${resolved}`);
+  }
+  return { file: resolved };
+};
+
+const formatInputPreview = (input) => {
+  if (Array.isArray(input)) {
+    return input.join(', ');
+  }
+  return typeof input === 'string' ? input : '';
+};
+
+const convertHandler = async ({ type, input, output } = {}, context = {}) => {
+  const { workspaceRoot } = context;
+  if (!workspaceRoot) {
+    return '转换失败: 未找到工作区目录';
+  }
+
+  if (!type || typeof type !== 'string') {
+    return '转换失败: type 参数无效';
+  }
+
+  const config = TYPE_META[type];
+  if (!config) {
+    return `转换失败: 不支持的 type ${type}`;
+  }
+
+  if (typeof output !== 'string' || !output.trim()) {
+    return '转换失败: output 必须是非空字符串路径';
+  }
+
+  let outputPath;
+  try {
+    outputPath = resolveWorkspacePath(workspaceRoot, output.trim());
+  } catch (error) {
+    return `转换失败: ${error.message}`;
+  }
+
+  const pptxTypes = new Set(['html_to_pptx']);
+  if (pptxTypes.has(type) && path.extname(outputPath).toLowerCase() !== '.pptx') {
+    return `转换失败: ${type} 的 output 必须是 .pptx 文件`;
+  }
+
+  let inputResolution;
+  try {
+    inputResolution = resolveInputPaths(config.inputType, input, workspaceRoot, type);
+  } catch (error) {
+    return `转换失败: ${error.message}`;
+  }
+
+  const inputPreview = formatInputPreview(input);
+
+  try {
+    await ensureOutputLocation(outputPath, config.outputType);
+
+    if (PYTHON_SCRIPTS[type]) {
+      const scriptPath = path.join(PYTHON_SCRIPT_ROOT, PYTHON_SCRIPTS[type]);
+      if (!fs.existsSync(scriptPath)) {
+        throw new Error(`找不到 Python 脚本: ${PYTHON_SCRIPTS[type]}`);
+      }
+
+      let scriptArgs = [];
+      if (config.inputType === 'list') {
+        scriptArgs = [
+          '--inputs',
+          ...inputResolution.list.map(item => shellQuote(item)),
+          '--output',
+          shellQuote(outputPath)
+        ];
+      } else {
+        scriptArgs = [
+          '--input',
+          shellQuote(inputResolution.file),
+          config.outputType === 'directory' ? '--output-dir' : '--output',
+          shellQuote(outputPath)
+        ];
+      }
+      await runPythonScript(scriptPath, scriptArgs, workspaceRoot);
+    } else {
+      throw new Error('未知的转换模式');
+    }
+
+    return [
+      '转换完成',
+      `type: ${type}`,
+      `input: ${inputPreview}`,
+      `output: ${output}`
+    ].join('\n');
+  } catch (error) {
+    const message = error?.message || String(error);
+    return `转换失败: ${message}`;
+  }
+};
+
+const schema = {
+  type: 'function',
+  function: {
+    name: 'convert',
+    description: [
+      `统一文件转换工具。type 支持：${TYPE_ENUM.join('、')}。`,
+      '所有路径都是指相对项目根目录的路径，例如：src/index.md、README.md、src/outputs等。'
+    ].join(' '),
+    parameters: {
+      type: 'object',
+      properties: {
+        type: {
+          type: 'string',
+          enum: TYPE_ENUM,
+          description: `转换类型，可选值: ${TYPE_ENUM.join(', ')}`
+        },
+        input: {
+          description: '输入路径：当 inputType 为 list（如 html_to_pptx）时为路径列表，否则为单文件路径。',
+          oneOf: [
+            { type: 'string' },
+            { type: 'array', items: { type: 'string' } }
+          ]
+        },
+        output: {
+          type: 'string',
+          description: '输出路径：PDF->PNG 时为目录路径，其余类型为单文件路径。'
+        }
+      },
+      required: ['type', 'input', 'output']
+    }
+  }
+};
+
+module.exports = {
+  name: 'convert',
+  schema,
+  handler: convertHandler
+};

package/src/tools/index.js

@@ -0,0 +1,66 @@
+const bash = require('./bash');
+const read = require('./read');
+const write = require('./write');
+const replace = require('./replace');
+const todos = require('./todos');
+const convert = require('./convert');
+const { createMcpManager } = require('./mcp');
+const { loadSettings } = require('../config');
+
+const TOOL_MODULES = [bash, read, write, replace, todos, convert];
+
+const createToolRuntime = async (workspaceRoot, options = {}) => {
+  const defaultToolNames = TOOL_MODULES.map((tool) => tool.name);
+  const { settings } = loadSettings({ defaultTools: defaultToolNames });
+  const enabledTools = new Set(settings.tools && settings.tools.length > 0 ? settings.tools : defaultToolNames);
+  const enabledMcps = Array.isArray(settings.mcps) ? settings.mcps : [];
+  const allowedCommands = settings.allowedCommands;
+
+  const context = { workspaceRoot, allowedCommands, ...options };
+
+  const tools = [];
+  const handlers = {};
+  const enabledToolNames = []; // 记录实际启用的工具名称
+
+  const registerTool = (toolModule) => {
+    if (!enabledTools.has(toolModule.name)) {
+      return;
+    }
+    const schema = typeof toolModule.schema === 'function' ? toolModule.schema(context) : toolModule.schema;
+    if (schema) {
+      tools.push(schema);
+      enabledToolNames.push(toolModule.name); // 记录启用的工具
+    }
+    handlers[toolModule.name] = async (params = {}) => toolModule.handler(params, context);
+  };
+
+  TOOL_MODULES.forEach(registerTool);
+
+  const mcpManager = await createMcpManager(workspaceRoot, enabledMcps);
+  let mcpConfigPath = null;
+  const mcpToolNames = new Set(); // 记录所有 MCP 工具名称
+  const enabledMcpNames = []; // 记录启用的 MCP 服务器名称
+  if (mcpManager) {
+    mcpManager.getTools().forEach((mcpTool) => {
+      tools.push(mcpTool.schema);
+      handlers[mcpTool.name] = mcpTool.handler;
+      if (mcpTool.isMcpTool) {
+        mcpToolNames.add(mcpTool.name);
+      }
+    });
+    mcpConfigPath = mcpManager.getConfigPath();
+    enabledMcpNames.push(...mcpManager.getEnabledServerNames()); // 获取启用的 MCP 名称
+  }
+
+  const dispose = async () => {
+    if (mcpManager && typeof mcpManager.dispose === 'function') {
+      await mcpManager.dispose();
+    }
+  };
+
+  return { tools, handlers, dispose, mcpConfigPath, mcpToolNames, enabledToolNames, enabledMcpNames };
+};
+
+module.exports = {
+  createToolRuntime
+};