deeper-cli 1.0.0

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

@@ -0,0 +1,66 @@
+import { execSync } from 'node:child_process';
+import type { Tool } from '../../tool-types.js';
+
+export const db_schema: Tool = {
+  name: 'db_schema',
+  description: '查看数据库表结构',
+  category: 'database',
+  parameters: {
+    type: 'object',
+    properties: {
+      connection: { type: 'string', description: '数据库连接字符串' },
+      engine: { type: 'string', description: '数据库引擎: mysql, postgresql, sqlite, mssql', enum: ['mysql', 'postgresql', 'sqlite', 'mssql'] },
+      table: { type: 'string', description: '表名（可选）' },
+    },
+    required: ['engine'],
+  },
+  dangerous: false,
+  requiresApproval: false,
+  async execute(params) {
+    try {
+      const engine = params.engine as string;
+      const table = params.table as string | undefined;
+      const connection = params.connection as string | undefined;
+
+      let output = `数据库 Schema 查询\n引擎: ${engine}\n\n`;
+
+      switch (engine) {
+        case 'sqlite': {
+          if (!connection) {
+            return { success: false, error: 'sqlite 需要 connection 参数（文件路径）', output: '' };
+          }
+          try {
+            const result = execSync(`sqlite3 "${connection}" ".schema ${table || ''}"`, {
+              encoding: 'utf-8', timeout: 10000, stdio: 'pipe',
+            });
+            output += result;
+          } catch {
+            output += 'sqlite3 命令行不可用，请安装 sqlite3 或使用文件路径直接查看数据库。\n';
+            output += `文件: ${connection}`;
+          }
+          break;
+        }
+        case 'mysql': {
+          output += table
+            ? `使用: mysql -e "DESCRIBE ${table};" ${connection ? connection : ''}`
+            : `使用: mysql -e "SHOW TABLES;" ${connection ? connection : ''}`;
+          output += '\n（请确保 mysql 客户端已安装）';
+          break;
+        }
+        case 'postgresql': {
+          output += table
+            ? `使用: psql ${connection || ''} -c "\\d ${table}"`
+            : `使用: psql ${connection || ''} -c "\\dt"`;
+          output += '\n（请确保 psql 客户端已安装）';
+          break;
+        }
+        default:
+          output += `请使用 ${engine} CLI 或 GUI 工具查看数据库 schema。`;
+      }
+
+      return { success: true, output, metadata: { engine, table } };
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};

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

@@ -0,0 +1,50 @@
+import { execSync } from 'node:child_process';
+import { readFileSync, existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type { Tool } from '../../tool-types.js';
+
+export const nosql_query: Tool = {
+  name: 'nosql_query',
+  description: '执行 NoSQL 数据库操作（MongoDB shell）',
+  category: 'database',
+  parameters: {
+    type: 'object',
+    properties: {
+      query: { type: 'string', description: '查询语句（MongoDB shell 语法）' },
+      connection: { type: 'string', description: '连接字符串 mongodb://...' },
+      collection: { type: 'string', description: '集合名称' },
+      timeout_ms: { type: 'number', description: '超时毫秒数' },
+    },
+    required: ['query'],
+  },
+  dangerous: false,
+  requiresApproval: true,
+  async execute(params) {
+    try {
+      const query = params.query as string;
+      const connection = (params.connection as string) ?? 'mongodb://localhost:27017';
+      const collection = params.collection as string | undefined;
+      const timeout = (params.timeout_ms as number) ?? 30000;
+
+      const queryScript = collection
+        ? `db.${collection}.${query}`
+        : query;
+
+      try {
+        const output = execSync(
+          `mongosh "${connection}" --eval "${queryScript.replace(/"/g, '\\"')}"`,
+          { encoding: 'utf-8', timeout, maxBuffer: 50 * 1024 * 1024, stdio: 'pipe' }
+        );
+        return { success: true, output, metadata: { connection, collection } };
+      } catch {
+        return {
+          success: true,
+          output: `MongoDB 查询请求:\n连接: ${connection}\n集合: ${collection || '(未指定)'}\n查询: ${queryScript}\n\n注意: mongosh 命令行不可用。请确保已安装 MongoDB Shell，或将查询语句直接在 mongosh 中执行。`,
+          metadata: { connection, fallback: true },
+        };
+      }
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};

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

@@ -0,0 +1,66 @@
+import { readFileSync, existsSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type { Tool } from '../../tool-types.js';
+
+export const orm_generate: Tool = {
+  name: 'orm_generate',
+  description: '生成 ORM 模型代码（基于数据库 schema）',
+  category: 'database',
+  parameters: {
+    type: 'object',
+    properties: {
+      engine: { type: 'string', description: '数据库引擎', enum: ['mysql', 'postgresql', 'sqlite', 'mssql'] },
+      connection: { type: 'string', description: '连接字符串' },
+      output_dir: { type: 'string', description: '输出目录' },
+      orm: { type: 'string', description: 'ORM 框架: prisma, typeorm, drizzle, sequelize', enum: ['prisma', 'typeorm', 'drizzle', 'sequelize'] },
+    },
+    required: ['engine', 'orm'],
+  },
+  dangerous: false,
+  requiresApproval: true,
+  async execute(params) {
+    try {
+      const engine = params.engine as string;
+      const connection = params.connection as string | undefined;
+      const outputDir = (params.output_dir as string) ?? './models';
+      const orm = params.orm as string;
+
+      const tips: Record<string, string[]> = {
+        prisma: [
+          `npx prisma init --datasource-provider ${engine}`,
+          '将上述 schema 写入 prisma/schema.prisma',
+          'npx prisma db pull  # 从数据库拉取 schema',
+          'npx prisma generate   # 生成 Prisma Client',
+        ],
+        typeorm: [
+          'npx typeorm-model-generator -h host -d database -p port -u user -x password -e engine -o outputDir',
+          '或使用: npx typeorm entity:create',
+        ],
+        drizzle: [
+          'npx drizzle-kit introspect:pg  # PostgreSQL',
+          'npx drizzle-kit introspect:mysql  # MySQL',
+          'npx drizzle-kit generate',
+        ],
+        sequelize: [
+          'npx sequelize-auto -h host -d database -u user -x password -p port --dialect engine -o outputDir',
+        ],
+      };
+
+      const output = [
+        `ORM 模型生成方案`,
+        `数据库引擎: ${engine}`,
+        `ORM 框架: ${orm}`,
+        `输出目录: ${outputDir}`,
+        '',
+        '操作步骤:',
+        ...(tips[orm] || []).map(t => `  ${t}`),
+        '',
+        '提示: 生成模型代码后，请根据项目需要手动调整字段类型和关联关系。',
+      ].join('\n');
+
+      return { success: true, output, metadata: { engine, orm, outputDir } };
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};

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

@@ -0,0 +1,46 @@
+import { execSync } from 'node:child_process';
+import type { Tool } from '../../tool-types.js';
+
+export const redis_command: Tool = {
+  name: 'redis_command',
+  description: '执行 Redis 命令',
+  category: 'database',
+  parameters: {
+    type: 'object',
+    properties: {
+      host: { type: 'string', description: 'Redis 主机' },
+      port: { type: 'number', description: 'Redis 端口' },
+      password: { type: 'string', description: '认证密码' },
+      command: { type: 'string', description: 'Redis 命令' },
+    },
+    required: ['command'],
+  },
+  dangerous: false,
+  requiresApproval: true,
+  async execute(params) {
+    try {
+      const host = (params.host as string) ?? 'localhost';
+      const port = (params.port as number) ?? 6379;
+      const password = params.password as string | undefined;
+      const command = params.command as string;
+
+      let cmd = `redis-cli -h ${host} -p ${port}`;
+      if (password) cmd += ` -a "${password}"`;
+      cmd += ` ${command}`;
+
+      try {
+        const output = execSync(cmd, { encoding: 'utf-8', timeout: 15000, stdio: 'pipe' });
+        return { success: true, output, metadata: { host, port } };
+      } catch (err: unknown) {
+        const e = err as { message?: string; stdout?: string; stderr?: string };
+        return {
+          success: false,
+          error: `Redis 命令失败: ${e.message || String(err)}`,
+          output: (e.stdout || '') + (e.stderr || ''),
+        };
+      }
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};

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

@@ -0,0 +1,55 @@
+import { execSync } from 'node:child_process';
+import type { Tool } from '../../tool-types.js';
+
+export const sql_migrate: Tool = {
+  name: 'sql_migrate',
+  description: '执行数据库迁移',
+  category: 'database',
+  parameters: {
+    type: 'object',
+    properties: {
+      command: { type: 'string', description: '迁移命令或 SQL 文件路径' },
+      connection: { type: 'string', description: '数据库连接字符串' },
+      engine: { type: 'string', description: '数据库引擎', enum: ['mysql', 'postgresql', 'sqlite', 'mssql'] },
+    },
+    required: ['command'],
+  },
+  dangerous: false,
+  requiresApproval: true,
+  async execute(params) {
+    try {
+      const command = params.command as string;
+      const connection = params.connection as string | undefined;
+      const engine = (params.engine as string) ?? 'sqlite';
+
+      let cmd = '';
+      switch (engine) {
+        case 'sqlite':
+          cmd = `sqlite3 "${connection || 'database.db'}" < "${command}"`;
+          break;
+        case 'mysql':
+          cmd = `mysql ${connection || ''} < "${command}"`;
+          break;
+        case 'postgresql':
+          cmd = `psql ${connection || ''} -f "${command}"`;
+          break;
+        default:
+          return { success: false, error: `不支持的数据库引擎: ${engine}`, output: '' };
+      }
+
+      try {
+        const output = execSync(cmd, { encoding: 'utf-8', timeout: 60000, stdio: 'pipe' });
+        return { success: true, output: output || '迁移执行成功', metadata: { engine, command } };
+      } catch (err: unknown) {
+        const e = err as { message?: string; stdout?: string; stderr?: string };
+        return {
+          success: false,
+          error: `迁移失败: ${e.message || String(err)}`,
+          output: (e.stdout || '') + (e.stderr || ''),
+        };
+      }
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};

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

@@ -0,0 +1,60 @@
+import { execSync } from 'node:child_process';
+import type { Tool } from '../../tool-types.js';
+
+export const sql_query: Tool = {
+  name: 'sql_query',
+  description: '执行 SQL 查询',
+  category: 'database',
+  parameters: {
+    type: 'object',
+    properties: {
+      query: { type: 'string', description: 'SQL 查询语句' },
+      connection: { type: 'string', description: '数据库连接字符串' },
+      engine: { type: 'string', description: '数据库引擎: mysql, postgresql, sqlite, mssql', enum: ['mysql', 'postgresql', 'sqlite', 'mssql'] },
+      timeout_ms: { type: 'number', description: '超时毫秒数' },
+    },
+    required: ['query', 'engine'],
+  },
+  dangerous: false,
+  requiresApproval: true,
+  async execute(params) {
+    try {
+      const query = params.query as string;
+      const engine = params.engine as string;
+      const connection = params.connection as string | undefined;
+      const timeout = (params.timeout_ms as number) ?? 30000;
+
+      let cmd = '';
+      switch (engine) {
+        case 'sqlite':
+          cmd = `sqlite3 "${connection || 'database.db'}" "${query.replace(/"/g, '\\"')}"`;
+          break;
+        case 'mysql':
+          cmd = `mysql ${connection || ''} -e "${query.replace(/"/g, '\\"')}"`;
+          break;
+        case 'postgresql':
+          cmd = `psql ${connection || ''} -c "${query.replace(/"/g, '\\"')}"`;
+          break;
+        case 'mssql':
+          cmd = `sqlcmd ${connection ? connection : ''} -Q "${query.replace(/"/g, '\\"')}"`;
+          break;
+        default:
+          return { success: false, error: `不支持的数据库引擎: ${engine}`, output: '' };
+      }
+
+      try {
+        const output = execSync(cmd, { encoding: 'utf-8', timeout, maxBuffer: 50 * 1024 * 1024, stdio: 'pipe' });
+        return { success: true, output, metadata: { engine } };
+      } catch (err: unknown) {
+        const e = err as { message?: string; stdout?: string; stderr?: string };
+        return {
+          success: false,
+          error: `查询失败: ${e.message || String(err)}`,
+          output: (e.stdout || '') + (e.stderr || ''),
+        };
+      }
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};

package/src/tools/builtin/filesystem/batch_read.ts

@@ -0,0 +1,56 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type { Tool } from '../../tool-types.js';
+
+export const batch_read: Tool = {
+  name: 'batch_read',
+  description: '批量读取多个文件',
+  category: 'filesystem',
+  parameters: {
+    type: 'object',
+    properties: {
+      file_paths: { type: 'array', items: { type: 'string' }, description: '文件路径列表' },
+      max_size_per_file: { type: 'number', description: '单文件最大字节数' },
+    },
+    required: ['file_paths'],
+  },
+  dangerous: false,
+  requiresApproval: false,
+  async execute(params) {
+    try {
+      const paths = params.file_paths as string[];
+      const maxSize = (params.max_size_per_file as number) ?? 1024 * 1024;
+      const results: Record<string, { content: string; error?: string }> = {};
+      for (const p of paths) {
+        const abs = resolve(p);
+        try {
+          if (!existsSync(abs)) {
+            results[p] = { content: '', error: '文件不存在' };
+            continue;
+          }
+          const stat = await import('node:fs').then(m => m.statSync(abs));
+          if (stat.size > maxSize) {
+            results[p] = { content: '', error: `文件过大 (${stat.size} > ${maxSize})` };
+            continue;
+          }
+          results[p] = { content: readFileSync(abs, 'utf-8') };
+        } catch (e) {
+          results[p] = { content: '', error: (e as Error).message };
+        }
+      }
+      const output = Object.entries(results)
+        .map(([path, r]) => {
+          if (r.error) return `--- ${path} (ERROR: ${r.error}) ---`;
+          return `--- ${path} ---\n${r.content}`;
+        })
+        .join('\n\n');
+      return {
+        success: true,
+        output,
+        metadata: { files: paths.length, read: Object.values(results).filter(r => !r.error).length },
+      };
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};

package/src/tools/builtin/filesystem/batch_write.ts

@@ -0,0 +1,67 @@
+import { existsSync, mkdirSync } from 'node:fs';
+import { writeFile } from 'node:fs/promises';
+import { resolve, dirname } from 'node:path';
+import type { Tool } from '../../tool-types.js';
+
+export const batch_write: Tool = {
+  name: 'batch_write',
+  description: '批量写入多个文件，自动创建父目录，跳过空内容文件',
+  category: 'filesystem',
+  parameters: {
+    type: 'object',
+    properties: {
+      files: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            file_path: { type: 'string' },
+            content: { type: 'string' },
+          },
+        },
+        description: '文件列表 [{file_path, content}]',
+      },
+    },
+    required: ['files'],
+  },
+  dangerous: false,
+  requiresApproval: false,
+  async execute(params) {
+    try {
+      const files = params.files as { file_path: string; content: string }[];
+      if (!files || !files.length) {
+        return { success: false, error: '文件列表为空', output: '' };
+      }
+      const results: string[] = [];
+      const skipped: string[] = [];
+      for (const f of files) {
+        const abs = resolve(f.file_path);
+        const content = f.content || '';
+        if (!content.trim()) {
+          skipped.push(abs);
+          continue;
+        }
+        if (content.length > 524_288) {
+          skipped.push(`${abs} (内容过大)`);
+          continue;
+        }
+        const dir = dirname(abs);
+        if (!existsSync(dir)) {
+          mkdirSync(dir, { recursive: true });
+        }
+        await writeFile(abs, content, 'utf-8');
+        results.push(abs);
+      }
+      let output = `已写入 ${results.length} 个文件`;
+      if (skipped.length > 0) output += `，跳过 ${skipped.length} 个(空内容)`;
+      if (results.length > 0) output += ':\n' + results.join('\n');
+      return {
+        success: results.length > 0,
+        output,
+        metadata: { count: results.length, skipped: skipped.length },
+      };
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};

package/src/tools/builtin/filesystem/copy_file.ts

@@ -0,0 +1,36 @@
+import { copyFileSync, existsSync, mkdirSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import type { Tool } from '../../tool-types.js';
+
+export const copy_file: Tool = {
+  name: 'copy_file',
+  description: '复制文件',
+  category: 'filesystem',
+  parameters: {
+    type: 'object',
+    properties: {
+      source: { type: 'string', description: '源文件路径' },
+      destination: { type: 'string', description: '目标文件路径' },
+    },
+    required: ['source', 'destination'],
+  },
+  dangerous: false,
+  requiresApproval: true,
+  async execute(params) {
+    try {
+      const source = resolve(params.source as string);
+      const dest = resolve(params.destination as string);
+      if (!existsSync(source)) {
+        return { success: false, error: `源文件不存在: ${source}`, output: '' };
+      }
+      const destDir = dirname(dest);
+      if (!existsSync(destDir)) {
+        mkdirSync(destDir, { recursive: true });
+      }
+      copyFileSync(source, dest);
+      return { success: true, output: `已复制: ${source} -> ${dest}` };
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};

package/src/tools/builtin/filesystem/create_dir.ts

@@ -0,0 +1,30 @@
+import { mkdirSync, existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type { Tool } from '../../tool-types.js';
+
+export const create_dir: Tool = {
+  name: 'create_dir',
+  description: '创建目录（递归创建父目录）',
+  category: 'filesystem',
+  parameters: {
+    type: 'object',
+    properties: {
+      dir_path: { type: 'string', description: '目录绝对路径' },
+    },
+    required: ['dir_path'],
+  },
+  dangerous: false,
+  requiresApproval: false,
+  async execute(params) {
+    try {
+      const dirPath = resolve(params.dir_path as string);
+      if (existsSync(dirPath)) {
+        return { success: true, output: `目录已存在: ${dirPath}` };
+      }
+      mkdirSync(dirPath, { recursive: true });
+      return { success: true, output: `目录已创建: ${dirPath}` };
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};

package/src/tools/builtin/filesystem/delete_file.ts

@@ -0,0 +1,30 @@
+import { unlinkSync, existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type { Tool } from '../../tool-types.js';
+
+export const delete_file: Tool = {
+  name: 'delete_file',
+  description: '删除指定文件',
+  category: 'filesystem',
+  parameters: {
+    type: 'object',
+    properties: {
+      file_path: { type: 'string', description: '文件绝对路径' },
+    },
+    required: ['file_path'],
+  },
+  dangerous: false,
+  requiresApproval: true,
+  async execute(params) {
+    try {
+      const filePath = resolve(params.file_path as string);
+      if (!existsSync(filePath)) {
+        return { success: false, error: `文件不存在: ${filePath}`, output: '' };
+      }
+      unlinkSync(filePath);
+      return { success: true, output: `已删除: ${filePath}` };
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};

package/src/tools/builtin/filesystem/diff_files.ts

@@ -0,0 +1,47 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type { Tool } from '../../tool-types.js';
+
+export const diff_files: Tool = {
+  name: 'diff_files',
+  description: '比较两个文件的差异',
+  category: 'filesystem',
+  parameters: {
+    type: 'object',
+    properties: {
+      file_a: { type: 'string', description: '文件A路径' },
+      file_b: { type: 'string', description: '文件B路径' },
+      context_lines: { type: 'number', description: '上下文行数' },
+    },
+    required: ['file_a', 'file_b'],
+  },
+  dangerous: false,
+  requiresApproval: true,
+  async execute(params) {
+    try {
+      const fileA = resolve(params.file_a as string);
+      const fileB = resolve(params.file_b as string);
+      const contextLines = (params.context_lines as number) ?? 3;
+      if (!existsSync(fileA)) return { success: false, error: `文件A不存在: ${fileA}`, output: '' };
+      if (!existsSync(fileB)) return { success: false, error: `文件B不存在: ${fileB}`, output: '' };
+      const contentA = readFileSync(fileA, 'utf-8');
+      const contentB = readFileSync(fileB, 'utf-8');
+      const Diff = await import('diff');
+      const patch = Diff.structuredPatch(
+        fileA, fileB, contentA, contentB,
+        'a', 'b',
+        { context: contextLines }
+      );
+      let output = '';
+      for (const hunk of patch.hunks) {
+        output += `@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@\n`;
+        for (const line of hunk.lines) {
+          output += line + '\n';
+        }
+      }
+      return { success: true, output: output || '文件内容相同' };
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};

package/src/tools/builtin/filesystem/edit_file.ts

@@ -0,0 +1,47 @@
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type { Tool } from '../../tool-types.js';
+
+export const edit_file: Tool = {
+  name: 'edit_file',
+  description: '通过搜索替换编辑文件内容',
+  category: 'filesystem',
+  parameters: {
+    type: 'object',
+    properties: {
+      file_path: { type: 'string', description: '文件绝对路径' },
+      old_str: { type: 'string', description: '要替换的源字符串' },
+      new_str: { type: 'string', description: '替换后的字符串' },
+      replace_all: { type: 'boolean', description: '是否替换所有匹配项' },
+    },
+    required: ['file_path', 'old_str', 'new_str'],
+  },
+  dangerous: false,
+  requiresApproval: false,
+  async execute(params) {
+    try {
+      const filePath = resolve(params.file_path as string);
+      const oldStr = params.old_str as string;
+      const newStr = params.new_str as string;
+      const replaceAll = (params.replace_all as boolean) ?? false;
+      if (!existsSync(filePath)) return { success: false, error: `文件不存在: ${filePath}`, output: '' };
+      const content = readFileSync(filePath, 'utf-8');
+      const index = content.indexOf(oldStr);
+      if (index === -1) return { success: false, error: '未找到匹配的字符串', output: '' };
+      let replaced: string; let count: number;
+      if (replaceAll) {
+        const regex = new RegExp(oldStr.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g');
+        const before = content;
+        replaced = content.replace(regex, newStr.replace(/\$/g, '$$$$'));
+        count = (before.match(regex) || []).length;
+      } else {
+        replaced = content.slice(0, index) + newStr + content.slice(index + oldStr.length);
+        count = 1;
+      }
+      writeFileSync(filePath, replaced, 'utf-8');
+      return { success: true, output: `已替换 ${count} 处匹配: ${filePath}` };
+    } catch (err: unknown) {
+      return { success: false, error: (err as Error).message, output: '' };
+    }
+  },
+};