closer-code 1.0.0

package/src/tools.js

@@ -0,0 +1,398 @@
+/**
+ * 工具执行引擎（使用 SDK）
+ *
+ * 使用 @anthropic-ai/sdk 的 betaZodTool 和 Zod 来定义工具
+ * 优势：
+ * - 类型安全的工具定义
+ * - 自动 schema 验证
+ * - SDK 自动处理工具调用循环（toolRunner）
+ * - 无需手工解析工具调用
+ */
+
+import { z } from 'zod';
+import { betaZodTool } from '@anthropic-ai/sdk/helpers/beta/zod';
+import fs from 'fs/promises';
+import path from 'path';
+import { executeBashCommand } from './bash-runner.js';
+import { glob } from 'glob';
+
+/**
+ * 创建一个配置上下文，用于工具执行器
+ */
+let toolExecutorContext = null;
+
+export function setToolExecutorContext(config) {
+  toolExecutorContext = {
+    workingDir: config.behavior.workingDir,
+    enabledTools: new Set(config.tools.enabled)
+  };
+}
+
+/**
+ * Bash 工具 - 执行 bash 命令
+ */
+export const bashTool = betaZodTool({
+  name: 'bash',
+  description: 'Execute a bash shell command. Use this IMMEDIATELY when user asks to: list/show directory contents (ls, dir), run commands, execute tests, check file info, run git commands, or ANY terminal operation. DO NOT just say "I will check" - CALL THIS TOOL.',
+  inputSchema: z.object({
+    command: z.string().describe('The bash command to execute (e.g., "ls -la", "cat file.txt", "npm test", "git status")'),
+    timeout: z.number().optional().describe('Timeout in milliseconds (default: 30000)')
+  }),
+  run: async (input) => {
+    if (!toolExecutorContext) {
+      throw new Error('Tool executor context not initialized');
+    }
+
+    const result = await executeBashCommand(input.command, {
+      cwd: toolExecutorContext.workingDir,
+      timeout: input.timeout || 30000
+    });
+
+    if (result.success) {
+      return JSON.stringify({
+        success: true,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        exitCode: result.exitCode
+      });
+    } else {
+      return JSON.stringify({
+        success: false,
+        error: result.error,
+        stdout: result.stdout,
+        stderr: result.stderr
+      });
+    }
+  }
+});
+
+/**
+ * 读取文件工具
+ */
+export const readFileTool = betaZodTool({
+  name: 'readFile',
+  description: 'Read the contents of a file',
+  inputSchema: z.object({
+    filePath: z.string().describe('Absolute or relative path to the file'),
+    encoding: z.string().optional().describe('File encoding (default: utf-8)')
+  }),
+  run: async (input) => {
+    if (!toolExecutorContext) {
+      throw new Error('Tool executor context not initialized');
+    }
+
+    const fullPath = path.resolve(toolExecutorContext.workingDir, input.filePath);
+    const content = await fs.readFile(fullPath, input.encoding || 'utf-8');
+
+    return JSON.stringify({
+      success: true,
+      content,
+      path: fullPath
+    });
+  }
+});
+
+/**
+ * 写入文件工具
+ */
+export const writeFileTool = betaZodTool({
+  name: 'writeFile',
+  description: 'Write content to a file (creates or overwrites). Supports both plain text content and base64-encoded content. Returns detailed error messages if the operation fails, allowing you to analyze and fix the issue.',
+  inputSchema: z.object({
+    filePath: z.string().describe('Absolute or relative path to the file'),
+    content: z.string().optional().describe('Content to write to the file (plain text)'),
+    contentBase64: z.string().optional().describe('Content to write to the file (base64 encoded, use this for binary data or special characters)'),
+    encoding: z.string().optional().describe('File encoding (default: utf-8)')
+  }),
+  run: async (input) => {
+    if (!toolExecutorContext) {
+      throw new Error('Tool executor context not initialized');
+    }
+
+    const fullPath = path.resolve(toolExecutorContext.workingDir, input.filePath);
+
+    // 优先使用 contentBase64，否则使用 content
+    let dataToWrite;
+    if (input.contentBase64) {
+      dataToWrite = Buffer.from(input.contentBase64, 'base64');
+    } else if (input.content !== undefined) {
+      dataToWrite = input.content;
+    } else {
+      return JSON.stringify({
+        success: false,
+        error: 'Either content or contentBase64 must be provided'
+      });
+    }
+
+    try {
+      await fs.writeFile(fullPath, dataToWrite, input.encoding || 'utf-8');
+
+      return JSON.stringify({
+        success: true,
+        path: fullPath,
+        size: dataToWrite.length,
+        encoding: input.contentBase64 ? 'base64' : (input.encoding || 'utf-8')
+      });
+    } catch (error) {
+      // 提供详细的错误信息和修复建议
+      let errorDetail = {
+        success: false,
+        error: error.code,
+        message: error.message,
+        path: fullPath
+      };
+
+      // 针对常见错误提供修复建议
+      if (error.code === 'ENOENT') {
+        const parentDir = path.dirname(fullPath);
+        errorDetail.suggestion = `Parent directory does not exist. Create it first using: bash tool with "mkdir -p ${parentDir}"`;
+        errorDetail.hint = 'The parent directory needs to be created before writing the file.';
+      } else if (error.code === 'EACCES') {
+        errorDetail.suggestion = 'Permission denied. Check if you have write permissions for this location.';
+        errorDetail.hint = 'Try writing to a different location or check file permissions.';
+      } else if (error.code === 'ENOSPC') {
+        errorDetail.suggestion = 'No space left on device. Free up some disk space and retry.';
+      }
+
+      return JSON.stringify(errorDetail);
+    }
+  }
+});
+
+/**
+ * 编辑文件工具（替换文本）
+ */
+export const editFileTool = betaZodTool({
+  name: 'editFile',
+  description: 'Edit a file by replacing exact string matches',
+  inputSchema: z.object({
+    filePath: z.string().describe('Path to the file to edit'),
+    oldText: z.string().describe('Exact text to replace (must be unique in the file)'),
+    newText: z.string().describe('New text to replace with'),
+    replaceAll: z.boolean().optional().describe('Replace all occurrences (default: false)')
+  }),
+  run: async (input) => {
+    if (!toolExecutorContext) {
+      throw new Error('Tool executor context not initialized');
+    }
+
+    const fullPath = path.resolve(toolExecutorContext.workingDir, input.filePath);
+    let content = await fs.readFile(fullPath, 'utf-8');
+
+    if (input.replaceAll) {
+      content = content.split(input.oldText).join(input.newText);
+    } else {
+      if (!content.includes(input.oldText)) {
+        return JSON.stringify({
+          success: false,
+          error: 'Old text not found in file'
+        });
+      }
+      content = content.replace(input.oldText, input.newText);
+    }
+
+    await fs.writeFile(fullPath, content, 'utf-8');
+
+    return JSON.stringify({
+      success: true,
+      path: fullPath,
+      replacements: 1
+    });
+  }
+});
+
+/**
+ * 搜索文件工具
+ */
+export const searchFilesTool = betaZodTool({
+  name: 'searchFiles',
+  description: 'Search for files by name pattern using glob',
+  inputSchema: z.object({
+    pattern: z.string().describe('Glob pattern (e.g., "**/*.js", "src/**/*.ts")'),
+    cwd: z.string().optional().describe('Working directory (default: current directory)')
+  }),
+  run: async (input) => {
+    if (!toolExecutorContext) {
+      throw new Error('Tool executor context not initialized');
+    }
+
+    const searchDir = input.cwd
+      ? path.resolve(toolExecutorContext.workingDir, input.cwd)
+      : toolExecutorContext.workingDir;
+
+    const files = await glob(input.pattern, { cwd: searchDir });
+
+    return JSON.stringify({
+      success: true,
+      files,
+      count: files.length
+    });
+  }
+});
+
+/**
+ * 搜索代码内容工具
+ */
+export const searchCodeTool = betaZodTool({
+  name: 'searchCode',
+  description: 'Search for text/patterns in file contents',
+  inputSchema: z.object({
+    pattern: z.string().describe('Regex pattern to search for'),
+    path: z.string().optional().describe('Directory to search in (default: current directory)'),
+    fileType: z.string().optional().describe('Filter by file type (e.g., "js", "py")')
+  }),
+  run: async (input) => {
+    if (!toolExecutorContext) {
+      throw new Error('Tool executor context not initialized');
+    }
+
+    const { searchCode } = await import('./search.js');
+    const results = await searchCode(input.pattern, {
+      path: input.path
+        ? path.resolve(toolExecutorContext.workingDir, input.path)
+        : toolExecutorContext.workingDir,
+      type: input.fileType
+    });
+
+    return JSON.stringify({
+      success: true,
+      ...results
+    });
+  }
+});
+
+/**
+ * 列出目录工具
+ */
+export const listFilesTool = betaZodTool({
+  name: 'listFiles',
+  description: 'List files and directories in a path',
+  inputSchema: z.object({
+    dirPath: z.string().optional().describe('Directory path (default: current directory)'),
+    recursive: z.boolean().optional().describe('List recursively (default: false)'),
+    showHidden: z.boolean().optional().describe('Show hidden files (default: false)')
+  }),
+  run: async (input) => {
+    if (!toolExecutorContext) {
+      throw new Error('Tool executor context not initialized');
+    }
+
+    const fullPath = input.dirPath
+      ? path.resolve(toolExecutorContext.workingDir, input.dirPath)
+      : toolExecutorContext.workingDir;
+
+    const files = await fs.readdir(fullPath, { withFileTypes: true });
+
+    const result = [];
+    for (const file of files) {
+      if (!input.showHidden && file.name.startsWith('.')) continue;
+      result.push({
+        name: file.name,
+        type: file.isDirectory() ? 'directory' : 'file',
+        path: path.join(fullPath, file.name)
+      });
+    }
+
+    return JSON.stringify({
+      success: true,
+      files: result,
+      path: fullPath
+    });
+  }
+});
+
+/**
+ * 所有工具的导出映射
+ */
+const TOOLS_MAP = {
+  bash: bashTool,
+  readFile: readFileTool,
+  writeFile: writeFileTool,
+  editFile: editFileTool,
+  searchFiles: searchFilesTool,
+  searchCode: searchCodeTool,
+  listFiles: listFilesTool
+};
+
+/**
+ * 获取启用工具的数组（用于 toolRunner）
+ * @param {Array<string>} enabledTools - 启用的工具名称数组
+ * @returns {Array} betaZodTool 对象数组
+ */
+export function getToolDefinitions(enabledTools) {
+  return enabledTools
+    .map(toolName => TOOLS_MAP[toolName])
+    .filter(tool => tool !== undefined);
+}
+
+/**
+ * 获取工具的 JSON Schema 定义（用于兼容性）
+ * @param {Array<string>} enabledTools - 启用的工具名称数组
+ * @returns {Array} JSON Schema 格式的工具定义
+ */
+export function getToolSchemaDefinitions(enabledTools) {
+  return enabledTools
+    .filter(toolName => TOOLS_MAP[toolName] !== undefined)
+    .map(toolName => {
+      const tool = TOOLS_MAP[toolName];
+      return {
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.input_schema
+      };
+    });
+}
+
+/**
+ * 生成工具执行的简短摘要
+ * @param {string} toolName - 工具名称
+ * @param {Object} input - 工具输入参数
+ * @param {Object} result - 工具执行结果
+ * @returns {string} 简短摘要
+ */
+export function generateToolSummary(toolName, input, result) {
+  const success = result?.success;
+
+  switch (toolName) {
+    case 'bash':
+      const cmd = input.command || '';
+      // 提取命令和第一个参数
+      const parts = cmd.trim().split(/\s+/);
+      const command = parts[0] || 'bash';
+      const arg1 = parts[1] ? parts[1].substring(0, 20) : '';
+      return success ? `✓ ${command} ${arg1}` : `✗ ${command}`;
+
+    case 'readFile':
+      const filePath = input.filePath || '';
+      const fileName = filePath.split('/').pop().substring(0, 20);
+      return success ? `📖 ${fileName}` : `✗ ${fileName}`;
+
+    case 'writeFile':
+      const writePath = input.filePath || '';
+      const writeFileName = writePath.split('/').pop().substring(0, 20);
+      return success ? `✍️ ${writeFileName}` : `✗ ${writeFileName}`;
+
+    case 'editFile':
+      const editPath = input.filePath || '';
+      const editFileName = editPath.split('/').pop().substring(0, 20);
+      return success ? `✏️ ${editFileName}` : `✗ ${editFileName}`;
+
+    case 'searchFiles':
+      const pattern = input.pattern || '';
+      const shortPattern = pattern.substring(0, 15);
+      return success ? `🔍 ${shortPattern}` : `✗ search`;
+
+    case 'searchCode':
+      const query = input.query || '';
+      const shortQuery = query.substring(0, 15);
+      return success ? `🔎 ${shortQuery}` : `✗ search`;
+
+    case 'listFiles':
+      const dirPath = input.path || '.';
+      const dirName = dirPath.split('/').pop() || '.';
+      return success ? `📁 ${dirName}` : `✗ ${dirName}`;
+
+    default:
+      return success ? `✓ ${toolName}` : `✗ ${toolName}`;
+  }
+}

package/src/utils/cli.js

@@ -0,0 +1,124 @@
+/**
+ * CLI 工具函数
+ * 提供命令行参数解析、输出格式化等功能
+ */
+
+// 特殊命令列表（不以 - 开头的非选项参数）
+export const SPECIAL_COMMANDS = ['config', 'setup', 'upgrade', 'help', 'version', 'workflow-tests'];
+
+/**
+ * 解析命令行参数
+ * @param {string[]} argv - 命令行参数数组（不包括 node 和脚本名）
+ * @returns {Object} 解析结果 { options, args, specialCommand }
+ */
+export function parseOptions(argv) {
+  const options = {
+    help: false,
+    version: false,
+    batch: false,
+    b: false,
+    json: false,
+    file: null,
+    verbose: false,
+    debug: false,
+    all: false,               // 运行所有 workflow 测试
+    workflow: null,           // workflow 模式：workflow 案例路径
+    maxIterations: null,      // 最大迭代次数
+  };
+  const args = [];
+  let specialCommand = null;
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+
+    // 处理选项
+    if (arg === '-h' || arg === '--help') {
+      options.help = true;
+    } else if (arg === '-v' || arg === '--version') {
+      options.version = true;
+    } else if (arg === '-b' || arg === '--batch') {
+      options.batch = true;
+      options.b = true;
+    } else if (arg === '-j' || arg === '--json') {
+      options.json = true;
+    } else if (arg === '-f' || arg === '--file') {
+      options.file = argv[++i] || null;
+    } else if (arg === '--verbose') {
+      options.verbose = true;
+    } else if (arg === '-d' || arg === '--debug') {
+      options.debug = true;
+    } else if (arg === '--all') {
+      // 运行所有 workflow 测试
+      options.all = true;
+    } else if (arg === '--workflow' || arg === '-w') {
+      // workflow 模式
+      options.workflow = argv[++i] || null;
+      // workflow 模式隐含 batch 模式
+      options.batch = true;
+      options.b = true;
+    } else if (arg === '--max-iterations') {
+      // 最大迭代次数
+      options.maxIterations = argv[++i] || null;
+    } else if (arg.startsWith('-')) {
+      // 其他选项（例如 --key value 或 -k value）
+      const key = arg.replace(/^-+/, '');
+      const nextArg = argv[i + 1];
+
+      // 如果下一个参数存在且不是选项，则作为值
+      if (nextArg !== undefined && !nextArg.startsWith('-')) {
+        options[key] = nextArg;
+        i++; // 跳过下一个参数
+      } else {
+        options[key] = true;
+      }
+    } else if (!specialCommand && SPECIAL_COMMANDS.includes(arg)) {
+      // 特殊命令（只在第一个非选项位置）
+      specialCommand = arg;
+    } else {
+      // 普通参数（提示词等）
+      args.push(arg);
+    }
+  }
+
+  return { options, args, specialCommand };
+}
+
+/**
+ * 显示错误信息
+ * @param {string} message - 错误信息
+ */
+export function showError(message) {
+  console.error(`❌ ${message}`);
+}
+
+/**
+ * 显示提示信息
+ * @param {string} message - 提示信息
+ */
+export function showTip(message) {
+  console.log(`💡 ${message}`);
+}
+
+/**
+ * 显示成功信息
+ * @param {string} message - 成功信息
+ */
+export function showSuccess(message) {
+  console.log(`✅ ${message}`);
+}
+
+/**
+ * 显示信息
+ * @param {string} message - 信息内容
+ */
+export function showInfo(message) {
+  console.log(`ℹ️  ${message}`);
+}
+
+/**
+ * 显示警告信息
+ * @param {string} message - 警告信息
+ */
+export function showWarning(message) {
+  console.warn(`⚠️  ${message}`);
+}

package/src/utils/validator.js

@@ -0,0 +1,184 @@
+/**
+ * 验收标准验证器
+ * 解析 expect.md 并验证验收标准
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+
+/**
+ * 解析验收标准
+ */
+function parseExpect(expectContent) {
+  // 移除 markdown 标题符号和空格
+  const checks = expectContent
+    .split('\n')
+    .map(line => line.trim())
+    .map(line => line.replace(/^#+\s*/, '')) // 移除 # 标题符号
+    .filter(line => line.length > 0);
+
+  return checks;
+}
+
+/**
+ * 检查单个条件
+ */
+async function checkSingleCondition(condition, workingDir) {
+  // 1. 文件存在性检查
+  // 匹配模式："有一个 [文件名] 程序" 或 "存在 [文件名]"
+  if (condition.includes('有一个') && condition.includes('程序')) {
+    const match = condition.match(/(\w+)\s*程序/);
+    if (match) {
+      const programName = match[1];
+      const programPath = path.join(workingDir, programName);
+
+      try {
+        await fs.access(programPath, fs.constants.X_OK); // 检查可执行权限
+        return {
+          passed: true,
+          check: condition,
+          reason: `程序 ${programName} 存在且可执行`
+        };
+      } catch {
+        return {
+          passed: false,
+          check: condition,
+          reason: `程序 ${programName} 不存在或不可执行`
+        };
+      }
+    }
+  }
+
+  // 2. 文件存在性检查
+  // 匹配模式："存在 [文件名]" 或 "有 [文件名]"
+  if (condition.includes('存在') || condition.includes('有')) {
+    // 尝试提取文件名
+    const match = condition.match(/(?:存在|有)\s+["']?([^"'\s]+)["']?/);
+    if (match) {
+      const fileName = match[1];
+      const filePath = path.join(workingDir, fileName);
+
+      try {
+        await fs.access(filePath, fs.constants.F_OK);
+        return {
+          passed: true,
+          check: condition,
+          reason: `文件 ${fileName} 存在`
+        };
+      } catch {
+        return {
+          passed: false,
+          check: condition,
+          reason: `文件 ${fileName} 不存在`
+        };
+      }
+    }
+  }
+
+  // 3. 可执行文件检查
+  // 匹配模式："可执行的 [文件名]" 或 "[文件名] 可执行"
+  if (condition.includes('可执行')) {
+    const match = condition.match(/可执行的?\s*(\w+)/);
+    if (match) {
+      const fileName = match[1];
+      const filePath = path.join(workingDir, fileName);
+
+      try {
+        await fs.access(filePath, fs.constants.X_OK);
+        return {
+          passed: true,
+          check: condition,
+          reason: `文件 ${fileName} 可执行`
+        };
+      } catch {
+        return {
+          passed: false,
+          check: condition,
+          reason: `文件 ${fileName} 不存在或不可执行`
+        };
+      }
+    }
+  }
+
+  // 4. 目录存在性检查
+  // 匹配模式："[目录名] 目录" 或 "目录 [目录名]"
+  if (condition.includes('目录')) {
+    const match = condition.match(/(\w+)\s*目录/);
+    if (match) {
+      const dirName = match[1];
+      const dirPath = path.join(workingDir, dirName);
+
+      try {
+        const stat = await fs.stat(dirPath);
+        if (stat.isDirectory()) {
+          return {
+            passed: true,
+            check: condition,
+            reason: `目录 ${dirName} 存在`
+          };
+        } else {
+          return {
+            passed: false,
+            check: condition,
+            reason: `${dirName} 不是目录`
+          };
+        }
+      } catch {
+        return {
+          passed: false,
+          check: condition,
+          reason: `目录 ${dirName} 不存在`
+        };
+      }
+    }
+  }
+
+  // 5. 默认：无法识别的条件，假设通过
+  // 这允许 future 扩展更多验证逻辑
+  return {
+    passed: true,
+    check: condition,
+    reason: '未实现验证逻辑，默认通过'
+  };
+}
+
+/**
+ * 验证验收标准
+ */
+export async function validateExpect(expectContent, workingDir, verbose = false) {
+  const checks = parseExpect(expectContent);
+
+  if (verbose) {
+    console.log(`\n解析到 ${checks.length} 条验收标准:`);
+    checks.forEach((check, index) => {
+      console.log(`  ${index + 1}. ${check}`);
+    });
+  }
+
+  const results = [];
+  let allPassed = true;
+
+  for (const check of checks) {
+    const result = await checkSingleCondition(check, workingDir);
+    results.push(result);
+
+    if (verbose) {
+      console.log(`  ${result.passed ? '✓' : '✗'} ${check}`);
+      if (!result.passed) {
+        console.log(`    原因: ${result.reason}`);
+      }
+    }
+
+    if (!result.passed) {
+      allPassed = false;
+      // 遇到第一个失败就停止（AND 逻辑）
+      break;
+    }
+  }
+
+  return {
+    passed: allPassed,
+    reason: allPassed ? '所有验收标准已满足' : results.find(r => !r.passed)?.reason || '验证失败',
+    details: results
+  };
+}