// 良い例
async function processRequest(request: string): Promise<Result<Output, ToolError>> {
    if (!request) {
        return err({
            code: "INVALID_INPUT",
            message: "リクエストが空です",
            recoverable: true,
            suggestions: ["有効なリクエストを入力してください"]
        });
    }
    
    try {
        const result = await internalProcess(request);
        return ok(result);
    } catch (error) {
        return err({
            code: "PROCESSING_ERROR",
            message: `処理中にエラーが発生しました: ${error}`,
            recoverable: false
        });
    }
}

/**
 * Tool: tool_name
 * Purpose: ツールの目的を簡潔に記述
 * Author: 開発者名
 * Date: YYYY-MM-DD
 */

import type { Result } from 'neverthrow';
import { ok, err } from 'neverthrow';
import type { z } from 'zod';

// 入力型定義
export const ToolInputSchema = z.object({
  requiredField: z.string().min(1),
  optionalField: z.string().optional(),
});

export type ToolInput = z.infer<typeof ToolInputSchema>;

// 出力型定義
export interface ToolOutput {
  result: string;
  metadata: Record<string, unknown>;
  warnings?: string[];
}

// エラー型定義
export interface ToolError {
  code: string;
  message: string;
  toolName: string;
  recoverable: boolean;
  suggestions?: string[];
}

// メインツールクラス
export class ToolName {
  /**
   * ツールの説明
   */
  constructor(private readonly config: Record<string, unknown> = {}) {
    this.setup();
  }

  private setup(): void {
    // 初期設定
  }

  /**
   * ツールのメイン実行メソッド
   * @param inputData - 入力データ
   * @returns 成功時は出力、失敗時はエラー
   */
  async execute(inputData: unknown): Promise<Result<ToolOutput, ToolError>> {
    // 入力検証
    const parseResult = ToolInputSchema.safeParse(inputData);
    if (!parseResult.success) {
      return err({
        code: 'INVALID_INPUT',
        message: parseResult.error.message,
        toolName: this.constructor.name,
        recoverable: true,
      });
    }

    const validInput = parseResult.data;

    try {
      // メイン処理
      const result = await this.process(validInput);

      // 出力構築
      const output: ToolOutput = {
        result,
        metadata: { processedAt: new Date().toISOString() },
      };

      console.log(`Successfully processed: ${validInput.requiredField}`);
      return ok(output);
    } catch (error) {
      console.error('Processing failed:', error);
      return err({
        code: 'PROCESSING_ERROR',
        message: error instanceof Error ? error.message : String(error),
        toolName: this.constructor.name,
        recoverable: false,
      });
    }
  }

  private async process(inputData: ToolInput): Promise<string> {
    // ここに具体的な処理を実装
    return 'processed';
  }
}

import type { Result } from 'neverthrow';
import { ok, err } from 'neverthrow';

export class AsyncToolName {
  /**
   * 非同期処理をサポートするツール
   */
  
  /**
   * 非同期実行
   */
  async executeAsync(inputData: unknown): Promise<Result<ToolOutput, ToolError>> {
    const parseResult = ToolInputSchema.safeParse(inputData);
    if (!parseResult.success) {
      return err({
        code: 'INVALID_INPUT',
        message: parseResult.error.message,
        toolName: this.constructor.name,
        recoverable: true,
      });
    }

    const validInput = parseResult.data;

    try {
      const client = await this.getClient();
      try {
        const result = await this.processAsync(client, validInput);
        return ok({ result, metadata: {} });
      } finally {
        await client.close();
      }
    } catch (error) {
      return err({
        code: 'ASYNC_ERROR',
        message: error instanceof Error ? error.message : String(error),
        toolName: this.constructor.name,
        recoverable: true,
      });
    }
  }

  /**
   * ストリーミング実行
   */
  async *executeStream(
    inputData: ToolInput,
  ): AsyncGenerator<Result<string, ToolError>> {
    try {
      for await (const chunk of this.streamProcess(inputData)) {
        yield ok(chunk);
      }
    } catch (error) {
      yield err({
        code: 'STREAM_ERROR',
        message: error instanceof Error ? error.message : String(error),
        toolName: this.constructor.name,
        recoverable: false,
      });
    }
  }

  private async getClient(): Promise<any> {
    // クライアント取得ロジック
    return {};
  }

  private async processAsync(client: any, input: ToolInput): Promise<string> {
    // 非同期処理ロジック
    return 'processed';
  }

  private async *streamProcess(input: ToolInput): AsyncGenerator<string> {
    // ストリーミング処理ロジック
    yield 'chunk1';
    yield 'chunk2';
  }
}

import { describe, it, expect, beforeEach, vi } from 'vitest';
import { ToolName } from './tool-name';
import type { ToolInput } from './tool-name';

describe('ToolName', () => {
  let tool: ToolName;

  beforeEach(() => {
    tool = new ToolName({ testMode: true });
  });

  describe('execute', () => {
    it('正常系: 有効な入力で成功する', async () => {
      // Arrange
      const inputData: ToolInput = {
        requiredField: 'test',
        optionalField: 'optional',
      };

      // Act
      const result = await tool.execute(inputData);

      // Assert
      expect(result.isOk()).toBe(true);
      if (result.isOk()) {
        expect(result.value.result).toBe('expected_output');
      }
    });

    it('異常系: 無効な入力でエラーを返す', async () => {
      // Arrange
      const inputData = {}; // 必須フィールドが欠落

      // Act
      const result = await tool.execute(inputData);

      // Assert
      expect(result.isErr()).toBe(true);
      if (result.isErr()) {
        expect(result.error.code).toBe('INVALID_INPUT');
      }
    });

    it('外部サービスのモック', async () => {
      // Arrange
      const mockService = vi.fn().mockResolvedValue({ status: 'success' });
      vi.spyOn(tool as any, 'externalService').mockImplementation(mockService);
      
      const inputData: ToolInput = {
        requiredField: 'test',
      };

      // Act
      const result = await tool.execute(inputData);

      // Assert
      expect(mockService).toHaveBeenCalledOnce();
      expect(result.isOk()).toBe(true);
    });
  });
});

import { describe, it, expect } from 'vitest';
import { AnalyzeRequest } from './analyze-request';
import { GenerateWorkflowStructure } from './generate-workflow-structure';
import { CreateDslYaml } from './create-dsl-yaml';

describe('Tool Integration', () => {
  it('複数ツールの連携テスト', async () => {
    // Tool 1: 要求分析
    const analyzer = new AnalyzeRequest();
    const analysisResult = await analyzer.execute({
      request: 'FAQボットを作りたい',
    });
    expect(analysisResult.isOk()).toBe(true);
    if (!analysisResult.isOk()) return;

    // Tool 2: ワークフロー構造生成
    const generator = new GenerateWorkflowStructure();
    const structureResult = await generator.execute(analysisResult.value);
    expect(structureResult.isOk()).toBe(true);
    if (!structureResult.isOk()) return;

    // Tool 3: DSL YAML生成
    const creator = new CreateDslYaml();
    const yamlResult = await creator.execute(structureResult.value);
    expect(yamlResult.isOk()).toBe(true);
    if (!yamlResult.isOk()) return;

    // 最終出力の検証
    const yamlContent = yamlResult.value.yaml_content;
    expect(yamlContent).toContain('version: 0.3.0');
    expect(yamlContent).toContain('kind: app');
  });
});

import { createHash } from 'crypto';
import { LRUCache } from 'lru-cache';

export class CachedTool {
  /**
   * キャッシュを活用するツール
   */
  private cache: LRUCache<string, ToolOutput>;
  private memoCache = new Map<string, string>();

  constructor() {
    this.cache = new LRUCache<string, ToolOutput>({
      max: 500,
      ttl: 1000 * 60 * 5, // 5分間のTTL
    });
  }

  async execute(inputData: ToolInput): Promise<Result<ToolOutput, ToolError>> {
    // キャッシュキーの生成
    const cacheKey = this.generateCacheKey(inputData);

    // キャッシュチェック
    const cached = this.cache.get(cacheKey);
    if (cached) {
      console.log(`Cache hit for key: ${cacheKey}`);
      return ok(cached);
    }

    // 実際の処理
    const result = await this.process(inputData);
    if (result.isOk()) {
      this.cache.set(cacheKey, result.value);
    }

    return result;
  }

  private generateCacheKey(inputData: ToolInput): string {
    /**
     * 安定したキャッシュキーの生成
     */
    const keyData = `${inputData.requiredField}:${inputData.optionalField || ''}`;
    return createHash('sha256').update(keyData).digest('hex').substring(0, 16);
  }

  private memoize<T extends (...args: any[]) => any>(
    fn: T,
    keyFn?: (...args: Parameters<T>) => string,
  ): T {
    /**
     * 高コストな操作のメモ化
     */
    return ((...args: Parameters<T>) => {
      const key = keyFn ? keyFn(...args) : JSON.stringify(args);
      if (this.memoCache.has(key)) {
        return this.memoCache.get(key);
      }
      const result = fn(...args);
      this.memoCache.set(key, result);
      return result;
    }) as T;
  }

  private async process(inputData: ToolInput): Promise<Result<ToolOutput, ToolError>> {
    // 実装
    return ok({ result: 'processed', metadata: {} });
  }
}

import { Worker } from 'worker_threads';
import pLimit from 'p-limit';

export class ParallelTool {
  /**
   * 並列処理をサポートするツール
   */
  private limit: pLimit.Limit;

  constructor() {
    // 同時実行数を制限
    this.limit = pLimit(4);
  }

  /**
   * 複数アイテムの並列処理
   */
  async executeParallel(
    items: ToolInput[],
  ): Promise<Result<ToolOutput, ToolError>[]> {
    // I/Oバウンドなタスク
    if (this.isIoBound()) {
      const promises = items.map((item) =>
        this.limit(() => this.processAsync(item)),
      );
      return Promise.all(promises);
    }

    // CPUバウンドなタスク（Worker Threads使用）
    const workers = await Promise.all(
      items.map((item) => this.processWithWorker(item)),
    );
    return workers;
  }

  private isIoBound(): boolean {
    // I/Oバウンドかどうかの判定ロジック
    return true;
  }

  private async processAsync(
    input: ToolInput,
  ): Promise<Result<ToolOutput, ToolError>> {
    // 非同期処理
    return ok({ result: 'processed', metadata: {} });
  }

  private async processWithWorker(
    input: ToolInput,
  ): Promise<Result<ToolOutput, ToolError>> {
    return new Promise((resolve) => {
      const worker = new Worker('./worker.js', {
        workerData: { input },
      });

      worker.on('message', (result) => {
        resolve(ok(result));
      });

      worker.on('error', (error) => {
        resolve(
          err({
            code: 'WORKER_ERROR',
            message: error.message,
            toolName: 'ParallelTool',
            recoverable: false,
          }),
        );
      });
    });
  }
}

// worker.js
import { parentPort, workerData } from 'worker_threads';

// CPU集約的な処理
const result = heavyComputation(workerData.input);
parentPort?.postMessage(result);