@dommaker/harness 0.19.0 → 1.0.0

package/src/tools/core/index.ts

@@ -1,201 +0,0 @@
-/**
- * 核心工具定义
- *
- * 内置工具：file / git / npm / shell
- */
-
-import type { ToolDefinition } from '../types';
-
-export const FILE_TOOLS: ToolDefinition[] = [
-  {
-    id: 'read_file',
-    name: 'Read File',
-    description: '读取文件内容',
-    category: 'core',
-    parameters: {
-      type: 'object',
-      properties: {
-        path: { type: 'string', description: '文件路径' },
-        offset: { type: 'number', description: '起始行号' },
-        limit: { type: 'number', description: '读取行数' },
-      },
-      required: ['path'],
-    },
-    sandboxLevel: 1,
-  },
-  {
-    id: 'write_file',
-    name: 'Write File',
-    description: '写入文件内容',
-    category: 'core',
-    parameters: {
-      type: 'object',
-      properties: {
-        path: { type: 'string', description: '文件路径' },
-        content: { type: 'string', description: '文件内容' },
-      },
-      required: ['path', 'content'],
-    },
-    sandboxLevel: 3,
-  },
-  {
-    id: 'edit_file',
-    name: 'Edit File',
-    description: '编辑文件（精确替换）',
-    category: 'core',
-    parameters: {
-      type: 'object',
-      properties: {
-        path: { type: 'string', description: '文件路径' },
-        old_string: { type: 'string', description: '要替换的文本' },
-        new_string: { type: 'string', description: '替换后的文本' },
-      },
-      required: ['path', 'old_string', 'new_string'],
-    },
-    sandboxLevel: 3,
-  },
-  {
-    id: 'list_directory',
-    name: 'List Directory',
-    description: '列出目录内容',
-    category: 'core',
-    parameters: {
-      type: 'object',
-      properties: {
-        path: { type: 'string', description: '目录路径' },
-      },
-      required: ['path'],
-    },
-    sandboxLevel: 1,
-  },
-];
-
-export const GIT_TOOLS: ToolDefinition[] = [
-  {
-    id: 'git_status',
-    name: 'Git Status',
-    description: '查看 git 工作区状态',
-    category: 'core',
-    parameters: { type: 'object', properties: {} },
-    sandboxLevel: 1,
-  },
-  {
-    id: 'git_diff',
-    name: 'Git Diff',
-    description: '查看 git 差异',
-    category: 'core',
-    parameters: {
-      type: 'object',
-      properties: {
-        staged: { type: 'boolean', description: '是否查看暂存区' },
-        file: { type: 'string', description: '指定文件' },
-      },
-    },
-    sandboxLevel: 1,
-  },
-  {
-    id: 'git_commit',
-    name: 'Git Commit',
-    description: '创建 git 提交',
-    category: 'core',
-    parameters: {
-      type: 'object',
-      properties: {
-        message: { type: 'string', description: '提交信息' },
-        files: { type: 'array', items: { type: 'string' }, description: '要提交的文件' },
-      },
-      required: ['message'],
-    },
-    sandboxLevel: 3,
-    requiresConfirmation: true,
-  },
-  {
-    id: 'git_log',
-    name: 'Git Log',
-    description: '查看 git 提交历史',
-    category: 'core',
-    parameters: {
-      type: 'object',
-      properties: {
-        limit: { type: 'number', description: '显示条数' },
-        file: { type: 'string', description: '指定文件' },
-      },
-    },
-    sandboxLevel: 1,
-  },
-];
-
-export const NPM_TOOLS: ToolDefinition[] = [
-  {
-    id: 'npm_install',
-    name: 'NPM Install',
-    description: '安装依赖',
-    category: 'core',
-    parameters: {
-      type: 'object',
-      properties: {
-        packages: { type: 'array', items: { type: 'string' }, description: '包名列表' },
-        dev: { type: 'boolean', description: '是否为开发依赖' },
-      },
-    },
-    sandboxLevel: 3,
-    rateLimit: 10,
-  },
-  {
-    id: 'npm_run',
-    name: 'NPM Run',
-    description: '执行 npm 脚本',
-    category: 'core',
-    parameters: {
-      type: 'object',
-      properties: {
-        script: { type: 'string', description: '脚本名称' },
-        args: { type: 'array', items: { type: 'string' }, description: '参数' },
-      },
-      required: ['script'],
-    },
-    sandboxLevel: 3,
-  },
-  {
-    id: 'npm_test',
-    name: 'NPM Test',
-    description: '运行测试',
-    category: 'core',
-    parameters: {
-      type: 'object',
-      properties: {
-        pattern: { type: 'string', description: '测试文件匹配模式' },
-        coverage: { type: 'boolean', description: '是否生成覆盖率报告' },
-      },
-    },
-    sandboxLevel: 3,
-  },
-];
-
-export const SHELL_TOOLS: ToolDefinition[] = [
-  {
-    id: 'shell_exec',
-    name: 'Shell Execute',
-    description: '执行 shell 命令',
-    category: 'core',
-    parameters: {
-      type: 'object',
-      properties: {
-        command: { type: 'string', description: '命令' },
-        cwd: { type: 'string', description: '工作目录' },
-        timeout: { type: 'number', description: '超时（ms）' },
-      },
-      required: ['command'],
-    },
-    sandboxLevel: 3,
-    rateLimit: 30,
-  },
-];
-
-/** 所有核心工具 */
-export const CORE_TOOLS: ToolDefinition[] = [
-  ...FILE_TOOLS,
-  ...GIT_TOOLS,
-  ...NPM_TOOLS,
-  ...SHELL_TOOLS,
-];

package/src/tools/loader.ts

@@ -1,216 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import * as yaml from 'js-yaml';
-import { ToolDefinition, ToolCategory } from './types';
-
-// Maps the type strings found in tool YAMLs to JSON Schema types
-const TYPE_MAP: Record<string, string> = {
-  string: 'string',
-  path: 'string',
-  integer: 'integer',
-  number: 'number',
-  boolean: 'boolean',
-  array: 'array',
-  object: 'object',
-};
-
-interface RawToolYaml {
-  id?: string;
-  name?: string;
-  description?: string;
-  category?: string;
-  stage?: string;
-  input?: Record<string, {
-    type?: string;
-    required?: boolean;
-    description?: string;
-    default?: unknown;
-    items?: unknown;
-    enum?: unknown[];
-  }>;
-  inputs?: Array<{
-    name: string;
-    type?: string;
-    required?: boolean;
-    description?: string;
-    default?: unknown;
-  }> | Record<string, {
-    type?: string;
-    required?: boolean;
-    description?: string;
-    default?: unknown;
-  }>;
-  output?: unknown;
-  outputs?: unknown;
-  script?: string;
-  prompt?: string;
-  agent?: string;
-  tools?: unknown;
-  execute?: unknown;
-  handler?: string;
-  temperature?: number;
-  timeout?: number;
-}
-
-function buildJsonSchema(params: Record<string, { type?: string; required?: boolean; description?: string; default?: unknown; items?: unknown; enum?: unknown[] }>): Record<string, unknown> {
-  const properties: Record<string, unknown> = {};
-  const required: string[] = [];
-
-  for (const [key, def] of Object.entries(params)) {
-    const prop: Record<string, unknown> = {};
-    const schemaType = TYPE_MAP[def.type ?? 'string'] ?? 'string';
-    prop.type = schemaType;
-    if (def.description) prop.description = def.description;
-    if (def.default !== undefined) prop.default = def.default;
-    if (def.items) prop.items = def.items;
-    if (def.enum) prop.enum = def.enum;
-    properties[key] = prop;
-    if (def.required) required.push(key);
-  }
-
-  const schema: Record<string, unknown> = {
-    type: 'object',
-    properties,
-  };
-  if (required.length > 0) schema.required = required;
-  return schema;
-}
-
-function normalizeInputs(raw: RawToolYaml): Record<string, { type?: string; required?: boolean; description?: string; default?: unknown; items?: unknown; enum?: unknown[] }> {
-  // Pattern A: `input` is a map (core/ext tools)
-  if (raw.input && typeof raw.input === 'object' && !Array.isArray(raw.input)) {
-    return raw.input;
-  }
-
-  // Pattern B: `inputs` is a list (some std tools)
-  if (Array.isArray(raw.inputs)) {
-    const result: Record<string, { type?: string; required?: boolean; description?: string; default?: unknown }> = {};
-    for (const item of raw.inputs) {
-      if (item.name) {
-        result[item.name] = {
-          type: item.type,
-          required: item.required,
-          description: item.description,
-          default: item.default,
-        };
-      }
-    }
-    return result;
-  }
-
-  // Pattern C: `inputs` is a map (some std tools)
-  if (raw.inputs && typeof raw.inputs === 'object' && !Array.isArray(raw.inputs)) {
-    return raw.inputs as Record<string, { type?: string; required?: boolean; description?: string; default?: unknown }>;
-  }
-
-  return {};
-}
-
-function deriveToolId(filePath: string, definitionsDir: string): string {
-  // Convert file path to ID: definitions/std/quick/implement.yml → std/quick/implement
-  const relative = path.relative(definitionsDir, filePath);
-  const withoutExt = relative.replace(/\.yml$/, '').replace(/\.yaml$/, '');
-  return withoutExt;
-}
-
-function detectCategory(filePath: string, definitionsDir: string): ToolCategory {
-  const relative = path.relative(definitionsDir, filePath);
-  const topDir = relative.split(path.sep)[0];
-  if (topDir === 'core') return 'core';
-  if (topDir === 'ext') return 'ext';
-  return 'std';
-}
-
-/**
- * Parse a single YAML file into a ToolDefinition.
- */
-export function parseToolYaml(yamlContent: string, filePath: string, definitionsDir: string): ToolDefinition {
-  const raw = yaml.load(yamlContent) as RawToolYaml;
-
-  const id = raw.id || deriveToolId(filePath, definitionsDir);
-  const name = raw.name || id;
-  const description = raw.description || '';
-  const category = detectCategory(filePath, definitionsDir);
-  const params = normalizeInputs(raw);
-  const parameters = buildJsonSchema(params);
-
-  const def: ToolDefinition = {
-    id,
-    name,
-    description,
-    category,
-    parameters,
-  };
-
-  return def;
-}
-
-/**
- * Scan a directory recursively for .yml/.yaml files and return all file paths.
- */
-function findYamlFiles(dir: string): string[] {
-  const results: string[] = [];
-  if (!fs.existsSync(dir)) return results;
-
-  const entries = fs.readdirSync(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      results.push(...findYamlFiles(fullPath));
-    } else if (entry.isFile() && (entry.name.endsWith('.yml') || entry.name.endsWith('.yaml'))) {
-      results.push(fullPath);
-    }
-  }
-  return results;
-}
-
-/**
- * Load all tool definitions from the definitions directory (core/, std/, ext/).
- */
-export function loadToolsFromDir(definitionsDir: string): ToolDefinition[] {
-  const tools: ToolDefinition[] = [];
-
-  for (const category of ['core', 'std', 'ext'] as ToolCategory[]) {
-    const categoryDir = path.join(definitionsDir, category);
-    const yamlFiles = findYamlFiles(categoryDir);
-
-    for (const filePath of yamlFiles) {
-      try {
-        const content = fs.readFileSync(filePath, 'utf-8');
-        const tool = parseToolYaml(content, filePath, definitionsDir);
-        tools.push(tool);
-      } catch (err) {
-        // Skip files that fail to parse
-        console.warn(`[harness] Failed to load tool YAML: ${filePath}`, err);
-      }
-    }
-  }
-
-  return tools;
-}
-
-/**
- * Load the registry.json and fix absolute paths to relative (from definitions dir).
- * Filters out workflow entries, keeping only tool entries.
- */
-export function loadRegistry(registryPath: string): Array<{
-  name: string;
-  category: string;
-  type: string;
-  description: string;
-  path: string;
-}> {
-  const content = fs.readFileSync(registryPath, 'utf-8');
-  const registry = JSON.parse(content);
-  const definitionsDir = path.dirname(registryPath);
-
-  if (!Array.isArray(registry.tools)) return [];
-
-  return registry.tools
-    .filter((entry: { type?: string }) => entry.type === 'tool')
-    .map((entry: { name: string; category: string; type: string; description: string; path: string }) => ({
-      ...entry,
-      // Fix absolute paths to relative (from definitions dir); keep already-relative paths as-is
-      path: path.isAbsolute(entry.path) ? path.relative(definitionsDir, entry.path) : entry.path,
-    }));
-}

package/src/tools/registry.ts

@@ -1,128 +0,0 @@
-/**
- * 工具注册表
- *
- * 工具注册/发现/执行
- */
-
-import type { ToolDefinition, ToolCategory, ToolResult } from './types';
-
-export class ToolRegistry {
-  private tools: Map<string, ToolDefinition>;
-
-  constructor() {
-    this.tools = new Map();
-  }
-
-  /**
-   * 注册工具
-   */
-  register(tool: ToolDefinition): void {
-    this.tools.set(tool.id, tool);
-  }
-
-  /**
-   * 批量注册
-   */
-  registerAll(tools: ToolDefinition[]): void {
-    for (const tool of tools) {
-      this.register(tool);
-    }
-  }
-
-  /**
-   * 获取工具
-   */
-  get(id: string): ToolDefinition | undefined {
-    return this.tools.get(id);
-  }
-
-  /**
-   * 获取所有工具
-   */
-  getAll(): ToolDefinition[] {
-    return Array.from(this.tools.values());
-  }
-
-  /**
-   * 按分类获取
-   */
-  getByCategory(category: ToolCategory): ToolDefinition[] {
-    return this.getAll().filter(t => t.category === category);
-  }
-
-  /**
-   * 搜索工具（名称/描述模糊匹配）
-   */
-  search(query: string): ToolDefinition[] {
-    const lower = query.toLowerCase();
-    return this.getAll().filter(t =>
-      t.name.toLowerCase().includes(lower) ||
-      t.description.toLowerCase().includes(lower) ||
-      t.id.toLowerCase().includes(lower),
-    );
-  }
-
-  /**
-   * 执行工具
-   */
-  async execute(id: string, params: Record<string, unknown>): Promise<ToolResult> {
-    const tool = this.tools.get(id);
-    if (!tool) {
-      return {
-        success: false,
-        output: '',
-        error: `工具未找到: ${id}`,
-      };
-    }
-
-    if (!tool.handler) {
-      return {
-        success: false,
-        output: '',
-        error: `工具 ${id} 未注册处理函数`,
-      };
-    }
-
-    try {
-      return await tool.handler(params);
-    } catch (error) {
-      return {
-        success: false,
-        output: '',
-        error: `工具执行失败: ${error instanceof Error ? error.message : String(error)}`,
-      };
-    }
-  }
-
-  /**
-   * 移除工具
-   */
-  remove(id: string): boolean {
-    return this.tools.delete(id);
-  }
-
-  /**
-   * 工具数量
-   */
-  size(): number {
-    return this.tools.size;
-  }
-
-  /**
-   * 检查工具是否存在
-   */
-  has(id: string): boolean {
-    return this.tools.has(id);
-  }
-
-  /**
-   * 导出为 tool definitions（用于 LLM function calling）
-   */
-  toToolDefinitions(): Array<{ name: string; description: string; parameters: Record<string, unknown> }> {
-    return this.getAll().map(t => ({
-      name: t.id,
-      description: t.description,
-      parameters: t.parameters,
-    }));
-  }
-}

package/src/tools/types.ts

@@ -1,46 +0,0 @@
-/**
- * 工具注册表类型定义
- */
-
-// ── 工具定义 ─────────────────────────────────────────────
-
-export type ToolCategory = 'core' | 'std' | 'ext';
-
-export interface ToolDefinition {
-  /** 工具唯一 ID */
-  id: string;
-  /** 工具名称 */
-  name: string;
-  /** 工具描述 */
-  description: string;
-  /** 工具分类 */
-  category: ToolCategory;
-  /** 参数 schema (JSON Schema) */
-  parameters: Record<string, unknown>;
-  /** 所需 sandbox 级别 */
-  sandboxLevel?: 1 | 2 | 3 | 4;
-  /** 是否需要确认 */
-  requiresConfirmation?: boolean;
-  /** 速率限制（每分钟） */
-  rateLimit?: number;
-  /** 工具处理函数 */
-  handler?: ToolHandler;
-}
-
-export type ToolHandler = (params: Record<string, unknown>) => Promise<ToolResult>;
-
-export interface ToolResult {
-  success: boolean;
-  output: string;
-  error?: string;
-  metadata?: Record<string, unknown>;
-}
-
-// ── 注册表配置 ───────────────────────────────────────────
-
-export interface ToolRegistryConfig {
-  /** 自动注册核心工具 */
-  autoRegisterCore?: boolean;
-  /** 工具搜索路径 */
-  searchPaths?: string[];
-}