AirCoding/packages/runtime/src/tools/BuiltInToolRegistrar.ts

/**
 * BuiltInToolRegistrar - Registers all built-in tools into ToolRegistry
 *
 * Implements T-214: Registers T-206..T-213 tools into ToolRegistry
 *
 * @module packages/runtime/src/tools/BuiltInToolRegistrar
 */

import { ToolRegistry } from './ToolRegistry.js'
import { fs_read, fs_write, fs_edit, fs_patch, fs_list, createFsExecutors } from './fs/index.js'
import { shell_run, createShellExecutor } from './shell/index.js'
import { git_status, git_diff, git_commit, git_branch, git_merge, createGitExecutor } from './git/index.js'
import { project_rules, project_context, createProjectExecutor } from './project/index.js'
import { artifact_create, artifact_read, createArtifactExecutor } from './artifact/index.js'
import { context_assemble, context_compact, createContextExecutor } from './context/index.js'
import { permission_check, permission_prompt, createPermissionExecutor } from './permission/index.js'
import { doctor_check, doctor_fix, createDoctorExecutor } from './doctor/index.js'

/**
 * Register all built-in tools into a ToolRegistry instance.
 */
export class BuiltInToolRegistrar {
  private registry: ToolRegistry

  constructor(registry: ToolRegistry) {
    this.registry = registry
  }

  /**
   * Register all built-in tools.
   */
  register_all(project_root: string): void {
    // FS Tools (T-206)
    this.register_tool(fs_read, createFsExecutors(project_root)['fs.read'])
    this.register_tool(fs_write, createFsExecutors(project_root)['fs.write'])
    this.register_tool(fs_edit, createFsExecutors(project_root)['fs.edit'])
    this.register_tool(fs_patch, createFsExecutors(project_root)['fs.patch'])
    this.register_tool(fs_list, createFsExecutors(project_root)['fs.list'])

    // Shell Tool (T-207)
    this.register_tool(shell_run, createShellExecutor(project_root)['shell.run'])

    // Git Tools (T-208)
    this.register_tool(git_status, createGitExecutor(project_root)['git.status'])
    this.register_tool(git_diff, createGitExecutor(project_root)['git.diff'])
    this.register_tool(git_commit, createGitExecutor(project_root)['git.commit'])
    this.register_tool(git_branch, createGitExecutor(project_root)['git.branch'])
    this.register_tool(git_merge, createGitExecutor(project_root)['git.merge'])

    // Project Tools (T-209)
    this.register_tool(project_rules, createProjectExecutor(project_root)['project.rules'])
    this.register_tool(project_context, createProjectExecutor(project_root)['project.context'])

    // Artifact Tools (T-210)
    this.register_tool(artifact_create, createArtifactExecutor()['artifact.create'])
    this.register_tool(artifact_read, createArtifactExecutor()['artifact.read'])

    // Context Tools (T-211)
    this.register_tool(context_assemble, createContextExecutor()['context.assemble'])
    this.register_tool(context_compact, createContextExecutor()['context.compact'])

    // Permission Tools (T-212)
    this.register_tool(permission_check, createPermissionExecutor()['permission.check'])
    this.register_tool(permission_prompt, createPermissionExecutor()['permission.prompt'])

    // Doctor Tools (T-213)
    this.register_tool(doctor_check, createDoctorExecutor()['doctor.check'])
    this.register_tool(doctor_fix, createDoctorExecutor()['doctor.fix'])

    // Stub Tools - high-priority registrations (Alpha scope)
    const stub_definitions = this.create_stub_definitions()
    for (const [name, definition] of Object.entries(stub_definitions)) {
      this.register_tool(definition as any, this.create_stub_executor(name))
    }
  }

  /**
   * Register a single tool with its executor.
   */
  private register_tool(definition: typeof fs_read, executor: (call: any) => any): void {
    this.registry.register(definition.name, definition, executor)
  }

  /**
   * Create stub tool definitions for high-priority tools (Alpha scope).
   */
  private create_stub_definitions(): Record<string, typeof fs_read> {
    return {
      'fs.stat': {
        name: 'fs.stat',
        category: 'filesystem',
        description: 'Get filesystem stat info for a path',
        input_schema: {
          type: 'object',
          properties: {
            path: { type: 'string', description: 'File or directory path to stat' }
          },
          required: ['path']
        },
        permissions: { read: true, write: false, network: false },
        streaming: false
      } as any,

      'cpp.build': {
        name: 'cpp.build',
        category: 'build',
        description: 'Build C++ project',
        input_schema: {
          type: 'object',
          properties: {
            target: { type: 'string', description: 'Build target' },
            config: { type: 'string', description: 'Build configuration (debug/release)' }
          },
          required: []
        },
        permissions: { read: true, write: false, network: false },
        streaming: false
      } as any,

      'cpp.test': {
        name: 'cpp.test',
        category: 'test',
        description: 'Run C++ tests',
        input_schema: {
          type: 'object',
          properties: {
            filter: { type: 'string', description: 'Test filter pattern' }
          },
          required: []
        },
        permissions: { read: true, write: false, network: false },
        streaming: false
      } as any,

      'cpp.static.cppcheck': {
        name: 'cpp.static.cppcheck',
        category: 'static_analysis',
        description: 'Run cppcheck static analysis on C++ code',
        input_schema: {
          type: 'object',
          properties: {
            path: { type: 'string', description: 'Path to analyze' },
            severity: { type: 'string', description: 'Minimum severity level' }
          },
          required: []
        },
        permissions: { read: true, write: false, network: false },
        streaming: false
      } as any,

      'debug.run': {
        name: 'debug.run',
        category: 'debug',
        description: 'Run debugger on a target process or binary',
        input_schema: {
          type: 'object',
          properties: {
            target: { type: 'string', description: 'Binary or process to debug' },
            breakpoints: { type: 'array', items: { type: 'string' }, description: 'Breakpoint locations' }
          },
          required: ['target']
        },
        permissions: { read: true, write: false, network: false },
        streaming: false
      } as any,
    }
  }

  /**
   * Create a stub executor that returns a not_implemented error.
   */
  private create_stub_executor(tool_name: string): (call: any) => any {
    return (call: any) => {
      return {
        call_id: '',
        tool_name: tool_name,
        type: 'error',
        content: { error_type: 'not_implemented', message: 'TODO: implement' },
        metadata: { timestamp: new Date().toISOString() }
      }
    }
  }
}

export function register_builtin_tools(registry: ToolRegistry, project_root: string): BuiltInToolRegistrar {
  const registrar = new BuiltInToolRegistrar(registry)
  registrar.register_all(project_root)
  return registrar
}