deeper-cli 1.0.0

package/src/tools/builtin/data/data_diff.ts

@@ -0,0 +1,79 @@
+import type { Tool } from '../../tool-types.js';
+
+export const data_diff: Tool = {
+  name: 'data_diff',
+  description: '比较两个数据集的差异',
+  category: 'data',
+  parameters: {
+    type: 'object',
+    properties: {
+      data_a: { type: 'string', description: '数据集 A (JSON)' },
+      data_b: { type: 'string', description: '数据集 B (JSON)' },
+    },
+    required: ['data_a', 'data_b'],
+  },
+  dangerous: false,
+  requiresApproval: false,
+  async execute(params) {
+    try {
+      const a = JSON.parse(params.data_a as string);
+      const b = JSON.parse(params.data_b as string);
+
+      const diff = computeDiff(a, b, '');
+      const output = diff.length > 0 ? diff.join('\n') : '两个数据集完全相同';
+
+      return { success: true, output, metadata: { differences: diff.length } };
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};
+
+function computeDiff(a: unknown, b: unknown, path: string): string[] {
+  const results: string[] = [];
+
+  if (a === b) return results;
+
+  if (typeof a !== typeof b) {
+    results.push(`${path || 'root'}: 类型不同 (${typeof a} vs ${typeof b})`);
+    return results;
+  }
+
+  if (a === null || b === null || typeof a !== 'object') {
+    if (JSON.stringify(a) !== JSON.stringify(b)) {
+      results.push(`${path || 'root'}: ${JSON.stringify(a)} → ${JSON.stringify(b)}`);
+    }
+    return results;
+  }
+
+  if (Array.isArray(a) && Array.isArray(b)) {
+    const maxLen = Math.max(a.length, b.length);
+    for (let i = 0; i < maxLen; i++) {
+      results.push(...computeDiff(a[i], b[i], `${path}[${i}]`));
+    }
+    return results;
+  }
+
+  const keysA = Object.keys(a as Record<string, unknown>);
+  const keysB = Object.keys(b as Record<string, unknown>);
+  const allKeys = new Set([...keysA, ...keysB]);
+
+  for (const key of allKeys) {
+    const valA = (a as Record<string, unknown>)[key];
+    const valB = (b as Record<string, unknown>)[key];
+
+    if (!(key in (a as object))) {
+      results.push(`${path}.${key}: 新增 → ${JSON.stringify(valB)}`);
+    } else if (!(key in (b as object))) {
+      results.push(`${path}.${key}: 已删除 (原值: ${JSON.stringify(valA)})`);
+    } else {
+      if (typeof valA === 'object' && typeof valB === 'object' && valA !== null && valB !== null) {
+        results.push(...computeDiff(valA, valB, `${path}.${key}`));
+      } else if (valA !== valB) {
+        results.push(`${path}.${key}: ${JSON.stringify(valA)} → ${JSON.stringify(valB)}`);
+      }
+    }
+  }
+
+  return results;
+}

package/src/tools/builtin/data/data_transform.ts

@@ -0,0 +1,74 @@
+import type { Tool } from '../../tool-types.js';
+
+export const data_transform: Tool = {
+  name: 'data_transform',
+  description: '数据格式转换（JSON/CSV/YAML/XML 互转）',
+  category: 'data',
+  parameters: {
+    type: 'object',
+    properties: {
+      data: { type: 'string', description: '输入数据' },
+      from: { type: 'string', description: '源格式: json, csv, yaml, xml', enum: ['json', 'csv', 'yaml', 'xml'] },
+      to: { type: 'string', description: '目标格式: json, csv, yaml, xml', enum: ['json', 'csv', 'yaml', 'xml'] },
+      file_path: { type: 'string', description: '文件路径' },
+      output: { type: 'string', description: '输出文件路径' },
+    },
+    required: ['from', 'to'],
+  },
+  dangerous: false,
+  requiresApproval: true,
+  async execute(params) {
+    try {
+      const from = params.from as string;
+      const to = params.to as string;
+      const data = params.data as string | undefined;
+      const filePath = params.file_path as string | undefined;
+      const output = params.output as string | undefined;
+
+      let inputStr = '';
+      if (filePath) {
+        const { readFileSync, existsSync } = await import('node:fs');
+        const { resolve } = await import('node:path');
+        const abs = resolve(filePath);
+        if (!existsSync(abs)) return { success: false, error: `文件不存在: ${abs}`, output: '' };
+        inputStr = readFileSync(abs, 'utf-8');
+      } else if (data) {
+        inputStr = data;
+      } else {
+        return { success: false, error: '请提供 data 或 file_path 参数', output: '' };
+      }
+
+      let parsed: unknown;
+      switch (from) {
+        case 'json': parsed = JSON.parse(inputStr); break;
+        case 'yaml': { const yaml = await import('yaml'); parsed = yaml.parse(inputStr); break; }
+        case 'csv': {
+          const { parse } = await import('csv-parse/sync');
+          parsed = parse(inputStr, { columns: true, skip_empty_lines: true });
+          break;
+        }
+        case 'xml': parsed = inputStr; break;
+        default: return { success: false, error: `不支持的源格式: ${from}`, output: '' };
+      }
+
+      let outputStr = '';
+      switch (to) {
+        case 'json': outputStr = JSON.stringify(parsed, null, 2); break;
+        case 'yaml': { const yaml = await import('yaml'); outputStr = yaml.stringify(parsed); break; }
+        case 'xml': outputStr = typeof parsed === 'string' ? parsed : `<root>${JSON.stringify(parsed)}</root>`; break;
+        case 'csv': outputStr = JSON.stringify(parsed); break;
+        default: return { success: false, error: `不支持的目标格式: ${to}`, output: '' };
+      }
+
+      if (output) {
+        const { writeFileSync } = await import('node:fs');
+        writeFileSync(output, outputStr, 'utf-8');
+        return { success: true, output: `转换完成并写入: ${output}`, metadata: { from, to } };
+      }
+
+      return { success: true, output: outputStr, metadata: { from, to } };
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};

package/src/tools/builtin/data/data_validate.ts

@@ -0,0 +1,75 @@
+import type { Tool } from '../../tool-types.js';
+
+export const data_validate: Tool = {
+  name: 'data_validate',
+  description: '根据 schema 验证数据',
+  category: 'data',
+  parameters: {
+    type: 'object',
+    properties: {
+      data: { type: 'string', description: 'JSON 数据' },
+      schema: { type: 'string', description: 'JSON Schema 用于验证' },
+    },
+    required: ['data', 'schema'],
+  },
+  dangerous: false,
+  requiresApproval: false,
+  async execute(params) {
+    try {
+      const data = JSON.parse(params.data as string);
+      const schema = JSON.parse(params.schema as string);
+
+      const errors = validateAgainstSchema(data, schema);
+
+      if (errors.length === 0) {
+        return { success: true, output: '数据验证通过！' };
+      }
+      return {
+        success: false,
+        error: `数据验证失败 (${errors.length} 个问题)`,
+        output: errors.map((e, i) => `  ${i + 1}. ${e}`).join('\n'),
+      };
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};
+
+function validateAgainstSchema(data: unknown, schema: Record<string, unknown>, path = '$'): string[] {
+  const errors: string[] = [];
+
+  if (schema.type) {
+    const expectedType = schema.type as string;
+    const actualType = Array.isArray(data) ? 'array' : typeof data;
+    if (expectedType !== actualType) {
+      errors.push(`${path}: 期望类型 "${expectedType}"，实际类型 "${actualType}"`);
+      return errors;
+    }
+  }
+
+  if (schema.required && Array.isArray(schema.required) && data && typeof data === 'object') {
+    for (const key of schema.required as string[]) {
+      if (!(key in (data as Record<string, unknown>))) {
+        errors.push(`${path}: 缺少必需字段 "${key}"`);
+      }
+    }
+  }
+
+  if (schema.properties && data && typeof data === 'object' && !Array.isArray(data)) {
+    const props = schema.properties as Record<string, Record<string, unknown>>;
+    for (const [key, propSchema] of Object.entries(props)) {
+      if (key in data) {
+        errors.push(...validateAgainstSchema((data as Record<string, unknown>)[key], propSchema, `${path}.${key}`));
+      }
+    }
+  }
+
+  if (schema.enum && Array.isArray(schema.enum)) {
+    const enumValues = schema.enum;
+    if (!enumValues.includes(data)) {
+      errors.push(`${path}: 值 "${data}" 不在允许的范围: [${enumValues.join(', ')}]`);
+    }
+  }
+
+  return errors;
+}

package/src/tools/builtin/data/json_parse.ts

@@ -0,0 +1,71 @@
+import type { Tool } from '../../tool-types.js';
+
+export const json_parse: Tool = {
+  name: 'json_parse',
+  description: '解析和格式化 JSON 内容',
+  category: 'data',
+  parameters: {
+    type: 'object',
+    properties: {
+      content: { type: 'string', description: 'JSON 字符串' },
+      file_path: { type: 'string', description: 'JSON 文件路径' },
+      pretty: { type: 'boolean', description: '是否美化输出' },
+      query: { type: 'string', description: 'JSONPath 查询' },
+    },
+    required: [],
+  },
+  dangerous: false,
+  requiresApproval: false,
+  async execute(params) {
+    try {
+      const content = params.content as string | undefined;
+      const filePath = params.file_path as string | undefined;
+      const pretty = (params.pretty as boolean) ?? true;
+      const query = params.query as string | undefined;
+
+      let jsonContent = '';
+      if (filePath) {
+        const { readFileSync, existsSync } = await import('node:fs');
+        const { resolve } = await import('node:path');
+        const abs = resolve(filePath);
+        if (!existsSync(abs)) return { success: false, error: `文件不存在: ${abs}`, output: '' };
+        jsonContent = readFileSync(abs, 'utf-8');
+      } else if (content) {
+        jsonContent = content;
+      } else {
+        return { success: false, error: '请提供 content 或 file_path 参数', output: '' };
+      }
+
+      const parsed = JSON.parse(jsonContent);
+
+      if (query) {
+        const value = resolveJsonPath(parsed, query);
+        return {
+          success: true,
+          output: JSON.stringify(value, null, pretty ? 2 : 0),
+          metadata: { query },
+        };
+      }
+
+      return { success: true, output: JSON.stringify(parsed, null, pretty ? 2 : 0) };
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};
+
+function resolveJsonPath(obj: unknown, path: string): unknown {
+  const parts = path.replace(/^\$\.?/, '').split('.');
+  let current: unknown = obj;
+  for (const part of parts) {
+    if (current === null || typeof current !== 'object') return undefined;
+    const bracketMatch = part.match(/^(\w+)\[(\d+)\]$/);
+    if (bracketMatch) {
+      current = (current as Record<string, unknown>)[bracketMatch[1]];
+      current = (current as unknown[])?.[parseInt(bracketMatch[2])];
+    } else {
+      current = (current as Record<string, unknown>)[part];
+    }
+  }
+  return current;
+}

package/src/tools/builtin/data/template_render.ts

@@ -0,0 +1,58 @@
+import { readFileSync, existsSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type { Tool } from '../../tool-types.js';
+
+export const template_render: Tool = {
+  name: 'template_render',
+  description: '渲染模板字符串或文件',
+  category: 'data',
+  parameters: {
+    type: 'object',
+    properties: {
+      template: { type: 'string', description: '模板字符串，使用 {{key}} 占位' },
+      file_path: { type: 'string', description: '模板文件路径' },
+      values: { type: 'object', description: '模板变量值' },
+      output: { type: 'string', description: '输出文件路径' },
+    },
+    required: ['values'],
+  },
+  dangerous: false,
+  requiresApproval: true,
+  async execute(params) {
+    try {
+      const templateStr = params.template as string | undefined;
+      const filePath = params.file_path as string | undefined;
+      const values = params.values as Record<string, unknown>;
+      const output = params.output as string | undefined;
+
+      let template = '';
+      if (filePath) {
+        const abs = resolve(filePath);
+        if (!existsSync(abs)) return { success: false, error: `模板文件不存在: ${abs}`, output: '' };
+        template = readFileSync(abs, 'utf-8');
+      } else if (templateStr) {
+        template = templateStr;
+      } else {
+        return { success: false, error: '请提供 template 或 file_path 参数', output: '' };
+      }
+
+      let rendered = template;
+      for (const [key, value] of Object.entries(values)) {
+        rendered = rendered.replace(new RegExp(`\\{\\{\\s*${escapeRegex(key)}\\s*\\}\\}`, 'g'), String(value));
+      }
+
+      if (output) {
+        writeFileSync(output, rendered, 'utf-8');
+        return { success: true, output: `模板已渲染并写入: ${output}`, metadata: { keys: Object.keys(values).length } };
+      }
+
+      return { success: true, output: rendered, metadata: { keys: Object.keys(values).length } };
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};
+
+function escapeRegex(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/src/tools/builtin/data/toml_parse.ts

@@ -0,0 +1,42 @@
+import type { Tool } from '../../tool-types.js';
+
+export const toml_parse: Tool = {
+  name: 'toml_parse',
+  description: '解析 TOML 内容',
+  category: 'data',
+  parameters: {
+    type: 'object',
+    properties: {
+      content: { type: 'string', description: 'TOML 字符串内容' },
+      file_path: { type: 'string', description: 'TOML 文件路径' },
+    },
+    required: [],
+  },
+  dangerous: false,
+  requiresApproval: false,
+  async execute(params) {
+    try {
+      const content = params.content as string | undefined;
+      const filePath = params.file_path as string | undefined;
+
+      let tomlContent = '';
+      if (filePath) {
+        const { readFileSync, existsSync } = await import('node:fs');
+        const { resolve } = await import('node:path');
+        const abs = resolve(filePath);
+        if (!existsSync(abs)) return { success: false, error: `文件不存在: ${abs}`, output: '' };
+        tomlContent = readFileSync(abs, 'utf-8');
+      } else if (content) {
+        tomlContent = content;
+      } else {
+        return { success: false, error: '请提供 content 或 file_path 参数', output: '' };
+      }
+
+      const { parse } = await import('toml');
+      const parsed = parse(tomlContent);
+      return { success: true, output: JSON.stringify(parsed, null, 2) };
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};

package/src/tools/builtin/data/xml_parse.ts

@@ -0,0 +1,79 @@
+import type { Tool } from '../../tool-types.js';
+
+export const xml_parse: Tool = {
+  name: 'xml_parse',
+  description: '解析 XML 内容',
+  category: 'data',
+  parameters: {
+    type: 'object',
+    properties: {
+      content: { type: 'string', description: 'XML 字符串' },
+      file_path: { type: 'string', description: 'XML 文件路径' },
+    },
+    required: [],
+  },
+  dangerous: false,
+  requiresApproval: false,
+  async execute(params) {
+    try {
+      let xmlContent = '';
+      const filePath = params.file_path as string | undefined;
+      const content = params.content as string | undefined;
+
+      if (filePath) {
+        const { readFileSync, existsSync } = await import('node:fs');
+        const { resolve } = await import('node:path');
+        const abs = resolve(filePath);
+        if (!existsSync(abs)) return { success: false, error: `文件不存在: ${abs}`, output: '' };
+        xmlContent = readFileSync(abs, 'utf-8');
+      } else if (content) {
+        xmlContent = content;
+      } else {
+        return { success: false, error: '请提供 content 或 file_path 参数', output: '' };
+      }
+
+      const parsed = parseXml(xmlContent);
+      return { success: true, output: JSON.stringify(parsed, null, 2) };
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};
+
+function parseXml(xml: string): Record<string, unknown> {
+  const result: Record<string, unknown> = {};
+  const tagRegex = /<([\w:.-]+)([^>]*)>([\s\S]*?)<\/\1>/g;
+  const selfClosingRegex = /<([\w:.-]+)([^>]*)\/>/g;
+  let match;
+
+  while ((match = tagRegex.exec(xml)) !== null) {
+    const tagName = match[1];
+    const attrs = match[2];
+    const inner = match[3];
+
+    const attrsObj: Record<string, string> = {};
+    const attrRegex = /(\w+)=["']([^"']*)["']/g;
+    let attrMatch;
+    while ((attrMatch = attrRegex.exec(attrs)) !== null) {
+      attrsObj[attrMatch[1]] = attrMatch[2];
+    }
+
+    if (/<[\w]/.test(inner)) {
+      result[tagName] = { ...attrsObj, ...parseXml(inner) };
+    } else {
+      result[tagName] = { _text: inner.trim(), ...attrsObj };
+    }
+  }
+
+  while ((match = selfClosingRegex.exec(xml)) !== null) {
+    const attrsObj: Record<string, string> = {};
+    const attrRegex = /(\w+)=["']([^"']*)["']/g;
+    let attrMatch;
+    while ((attrMatch = attrRegex.exec(match[2])) !== null) {
+      attrsObj[attrMatch[1]] = attrMatch[2];
+    }
+    result[match[1]] = attrsObj;
+  }
+
+  return result;
+}

package/src/tools/builtin/data/yaml_parse.ts

@@ -0,0 +1,42 @@
+import type { Tool } from '../../tool-types.js';
+
+export const yaml_parse: Tool = {
+  name: 'yaml_parse',
+  description: '解析 YAML 内容',
+  category: 'data',
+  parameters: {
+    type: 'object',
+    properties: {
+      content: { type: 'string', description: 'YAML 字符串' },
+      file_path: { type: 'string', description: 'YAML 文件路径' },
+    },
+    required: [],
+  },
+  dangerous: false,
+  requiresApproval: false,
+  async execute(params) {
+    try {
+      let yamlContent = '';
+      const filePath = params.file_path as string | undefined;
+      const content = params.content as string | undefined;
+
+      if (filePath) {
+        const { readFileSync, existsSync } = await import('node:fs');
+        const { resolve } = await import('node:path');
+        const abs = resolve(filePath);
+        if (!existsSync(abs)) return { success: false, error: `文件不存在: ${abs}`, output: '' };
+        yamlContent = readFileSync(abs, 'utf-8');
+      } else if (content) {
+        yamlContent = content;
+      } else {
+        return { success: false, error: '请提供 content 或 file_path 参数', output: '' };
+      }
+
+      const { parse } = await import('yaml');
+      const parsed = parse(yamlContent);
+      return { success: true, output: JSON.stringify(parsed, null, 2) };
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};

package/src/tools/builtin/database/db_backup.ts

@@ -0,0 +1,53 @@
+import { execSync } from 'node:child_process';
+import type { Tool } from '../../tool-types.js';
+
+export const db_backup: Tool = {
+  name: 'db_backup',
+  description: '数据库备份',
+  category: 'database',
+  parameters: {
+    type: 'object',
+    properties: {
+      engine: { type: 'string', description: '数据库引擎', enum: ['mysql', 'postgresql', 'sqlite'] },
+      connection: { type: 'string', description: '连接字符串/数据库名称' },
+      output_file: { type: 'string', description: '备份输出文件路径' },
+      tables: { type: 'array', items: { type: 'string' }, description: '指定表名列表' },
+    },
+    required: ['engine', 'output_file'],
+  },
+  dangerous: false,
+  requiresApproval: true,
+  async execute(params) {
+    try {
+      const engine = params.engine as string;
+      const connection = params.connection as string | undefined;
+      const outputFile = params.output_file as string;
+      const tables = params.tables as string[] | undefined;
+
+      let cmd = '';
+      switch (engine) {
+        case 'sqlite':
+          cmd = `sqlite3 "${connection || 'database.db'}" .dump > "${outputFile}"`;
+          break;
+        case 'mysql':
+          cmd = `mysqldump ${connection || ''} ${(tables || []).join(' ')} > "${outputFile}"`;
+          break;
+        case 'postgresql':
+          cmd = `pg_dump ${connection || ''} > "${outputFile}"`;
+          break;
+        default:
+          return { success: false, error: `不支持的数据库引擎: ${engine}`, output: '' };
+      }
+
+      try {
+        execSync(cmd, { encoding: 'utf-8', timeout: 120000, stdio: 'pipe' });
+        return { success: true, output: `备份完成: ${outputFile}`, metadata: { engine, outputFile } };
+      } catch (err: unknown) {
+        const e = err as { message?: string };
+        return { success: false, error: `备份失败: ${e.message || String(err)}`, output: '' };
+      }
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};

package/src/tools/builtin/database/db_restore.ts

@@ -0,0 +1,51 @@
+import { execSync } from 'node:child_process';
+import type { Tool } from '../../tool-types.js';
+
+export const db_restore: Tool = {
+  name: 'db_restore',
+  description: '数据库恢复',
+  category: 'database',
+  parameters: {
+    type: 'object',
+    properties: {
+      engine: { type: 'string', description: '数据库引擎', enum: ['mysql', 'postgresql', 'sqlite'] },
+      connection: { type: 'string', description: '连接字符串' },
+      backup_file: { type: 'string', description: '备份文件路径' },
+    },
+    required: ['engine', 'backup_file'],
+  },
+  dangerous: false,
+  requiresApproval: true,
+  async execute(params) {
+    try {
+      const engine = params.engine as string;
+      const connection = params.connection as string | undefined;
+      const backupFile = params.backup_file as string;
+
+      let cmd = '';
+      switch (engine) {
+        case 'sqlite':
+          cmd = `sqlite3 "${connection || 'database.db'}" < "${backupFile}"`;
+          break;
+        case 'mysql':
+          cmd = `mysql ${connection || ''} < "${backupFile}"`;
+          break;
+        case 'postgresql':
+          cmd = `psql ${connection || ''} < "${backupFile}"`;
+          break;
+        default:
+          return { success: false, error: `不支持的数据库引擎: ${engine}`, output: '' };
+      }
+
+      try {
+        const output = execSync(cmd, { encoding: 'utf-8', timeout: 120000, stdio: 'pipe' });
+        return { success: true, output: `恢复完成: ${backupFile}\n${output || ''}`, metadata: { engine, backupFile } };
+      } catch (err: unknown) {
+        const e = err as { message?: string };
+        return { success: false, error: `恢复失败: ${e.message || String(err)}`, output: '' };
+      }
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};