コード生成API

コード生成APIは、強力なAI駆動のコード生成機能を提供し、拡張機能がコードを自動的に生成、変更、リファクタリングできるようにします。

概要

コード生成APIでは以下のことができます：

自然言語の説明からコードを生成
コードスニペットの自動補完
既存のコードのリファクタリング
テストとドキュメントの生成
ボイラープレートコードの作成
言語間でのコード変換

基本的な使用方法

シンプルなコード生成

typescript

import { TraeAPI } from '@trae/api';

// 説明からコードを生成
const generatedCode = await TraeAPI.ai.codeGeneration.generate({
  prompt: '数値の階乗を計算する関数を作成',
  language: 'typescript',
  context: {
    fileName: 'math-utils.ts',
    existingCode: '// 数学ユーティリティ関数'
  }
});

console.log('生成されたコード:', generatedCode.code);
console.log('説明:', generatedCode.explanation);

コード補完

typescript

// コード補完の提案を取得
const editor = TraeAPI.window.activeTextEditor;
if (editor) {
  const position = editor.selection.active;
  const document = editor.document;
  
  const completion = await TraeAPI.ai.codeGeneration.complete({
    document: document.getText(),
    position,
    language: document.languageId,
    maxSuggestions: 5
  });
  
  // 最適な提案を適用
  if (completion.suggestions.length > 0) {
    const bestSuggestion = completion.suggestions[0];
    await editor.edit(editBuilder => {
      editBuilder.insert(position, bestSuggestion.code);
    });
  }
}

コードリファクタリング

typescript

// 選択されたコードをリファクタリング
async function refactorSelection() {
  const editor = TraeAPI.window.activeTextEditor;
  if (!editor || editor.selection.isEmpty) {
    return;
  }

  const selectedCode = editor.document.getText(editor.selection);
  
  const refactored = await TraeAPI.ai.codeGeneration.refactor({
    code: selectedCode,
    language: editor.document.languageId,
    refactorType: 'optimize', // 'optimize' | 'simplify' | 'modernize' | 'extract'
    instructions: 'このコードをより効率的で読みやすくする'
  });

  // 選択されたコードをリファクタリング版に置き換え
  await editor.edit(editBuilder => {
    editBuilder.replace(editor.selection, refactored.code);
  });

  // 説明を表示
  TraeAPI.window.showInformationMessage(
    `リファクタリング完了: ${refactored.explanation}`
  );
}

高度な機能

テンプレートベースの生成

typescript

// テンプレートを使用してコードを生成
const componentCode = await TraeAPI.ai.codeGeneration.generateFromTemplate({
  template: 'react-component',
  parameters: {
    componentName: 'UserProfile',
    props: ['name', 'email', 'avatar'],
    hooks: ['useState', 'useEffect'],
    styling: 'tailwind'
  },
  language: 'typescript'
});

// APIエンドポイントを生成
const apiCode = await TraeAPI.ai.codeGeneration.generateFromTemplate({
  template: 'express-endpoint',
  parameters: {
    method: 'POST',
    path: '/api/users',
    validation: true,
    database: 'mongodb'
  },
  language: 'typescript'
});

複数ファイル生成

typescript

// 関連する複数のファイルを生成
const projectFiles = await TraeAPI.ai.codeGeneration.generateProject({
  description: 'ReactとNode.jsを使用したシンプルなTodoアプリを作成',
  structure: {
    frontend: 'react-typescript',
    backend: 'node-express',
    database: 'mongodb',
    styling: 'tailwind'
  },
  features: ['authentication', 'crud-operations', 'real-time-updates']
});

// 生成されたすべてのファイルを作成
for (const file of projectFiles.files) {
  const uri = TraeAPI.Uri.file(file.path);
  const content = Buffer.from(file.content, 'utf8');
  await TraeAPI.workspace.fs.writeFile(uri, content);
}

テスト生成

typescript

// 関数のユニットテストを生成
async function generateTests() {
  const editor = TraeAPI.window.activeTextEditor;
  if (!editor) {
    return;
  }

  const selectedCode = editor.document.getText(editor.selection);
  
  const tests = await TraeAPI.ai.codeGeneration.generateTests({
    code: selectedCode,
    language: editor.document.languageId,
    testFramework: 'jest', // 'jest' | 'mocha' | 'vitest' | 'pytest'
    testTypes: ['unit', 'edge-cases', 'error-handling'],
    coverage: 'comprehensive'
  });

  // テストファイルを作成
  const testFileName = editor.document.fileName.replace(/\.(ts|js)$/, '.test.$1');
  const testUri = TraeAPI.Uri.file(testFileName);
  const testContent = Buffer.from(tests.code, 'utf8');
  
  await TraeAPI.workspace.fs.writeFile(testUri, testContent);
  
  // テストファイルを開く
  const testDocument = await TraeAPI.workspace.openTextDocument(testUri);
  await TraeAPI.window.showTextDocument(testDocument);
}

ドキュメント生成

typescript

// コードのドキュメントを生成
const documentation = await TraeAPI.ai.codeGeneration.generateDocumentation({
  code: selectedCode,
  language: 'typescript',
  format: 'jsdoc', // 'jsdoc' | 'markdown' | 'sphinx' | 'rustdoc'
  includeExamples: true,
  includeTypes: true
});

// ドキュメントを挿入
const editor = TraeAPI.window.activeTextEditor;
if (editor) {
  const position = editor.selection.start;
  await editor.edit(editBuilder => {
    editBuilder.insert(position, documentation.code + '\n');
  });
}

言語変換

コード翻訳

typescript

// 言語間でコードを翻訳
const translatedCode = await TraeAPI.ai.codeGeneration.translate({
  code: pythonCode,
  fromLanguage: 'python',
  toLanguage: 'typescript',
  preserveComments: true,
  adaptIdioms: true
});

// フレームワーク間で変換
const convertedComponent = await TraeAPI.ai.codeGeneration.convertFramework({
  code: reactComponent,
  fromFramework: 'react',
  toFramework: 'vue',
  version: '3.x'
});

コードの現代化

typescript

// レガシーコードを現代化
const modernizedCode = await TraeAPI.ai.codeGeneration.modernize({
  code: legacyJavaScript,
  language: 'javascript',
  targetVersion: 'es2022',
  features: ['async-await', 'destructuring', 'arrow-functions', 'modules']
});

// フレームワークバージョンをアップグレード
const upgradedCode = await TraeAPI.ai.codeGeneration.upgradeFramework({
  code: reactClassComponent,
  framework: 'react',
  fromVersion: '16.x',
  toVersion: '18.x',
  useHooks: true
});

カスタムコード生成

カスタムジェネレーターの作成

typescript

class CustomCodeGenerator {
  async generateCRUDOperations(entityName: string, fields: string[]) {
    const operations = ['create', 'read', 'update', 'delete'];
    const generatedFiles: { [key: string]: string } = {};

    for (const operation of operations) {
      const code = await TraeAPI.ai.codeGeneration.generate({
        prompt: `フィールド: ${fields.join(', ')}を持つ${entityName}エンティティの${operation}操作を生成`,
        language: 'typescript',
        context: {
          pattern: 'repository-pattern',
          database: 'mongodb',
          validation: true
        }
      });

      generatedFiles[`${entityName}${operation.charAt(0).toUpperCase() + operation.slice(1)}.ts`] = code.code;
    }

    return generatedFiles;
  }

  async generateAPIClient(openApiSpec: any) {
    const client = await TraeAPI.ai.codeGeneration.generateFromSpec({
      specification: openApiSpec,
      type: 'openapi',
      language: 'typescript',
      clientType: 'axios',
      includeTypes: true
    });

    return client;
  }
}

バッチコード生成

typescript

// 複数のコードスニペットをバッチで生成
const batchResults = await TraeAPI.ai.codeGeneration.generateBatch([
  {
    prompt: 'ユーザー認証サービスを作成',
    language: 'typescript',
    context: { pattern: 'service-layer' }
  },
  {
    prompt: 'バリデーション付きユーザーモデルを作成',
    language: 'typescript',
    context: { pattern: 'model-validation' }
  },
  {
    prompt: 'CRUD操作付きユーザーコントローラーを作成',
    language: 'typescript',
    context: { pattern: 'controller-pattern' }
  }
]);

// 結果を処理
batchResults.forEach((result, index) => {
  console.log(`生成されたコード ${index + 1}:`, result.code);
});

エディターとの統合

インラインコード提案

typescript

// インラインコード提案プロバイダーを登録
const provider = TraeAPI.languages.registerInlineCompletionItemProvider(
  { scheme: 'file', language: 'typescript' },
  {
    async provideInlineCompletionItems(document, position, context, token) {
      const lineText = document.lineAt(position.line).text;
      const prefix = lineText.substring(0, position.character);

      if (prefix.trim().startsWith('//')) {
        // コメントからコードを生成
        const comment = prefix.trim().substring(2).trim();
        const generated = await TraeAPI.ai.codeGeneration.generate({
          prompt: comment,
          language: document.languageId,
          context: {
            surroundingCode: getSurroundingCode(document, position)
          }
        });

        return {
          items: [{
            insertText: '\n' + generated.code,
            range: new TraeAPI.Range(position, position)
          }]
        };
      }

      return { items: [] };
    }
  }
);

コードアクション

typescript

// 生成用のコードアクションプロバイダーを登録
const codeActionProvider = TraeAPI.languages.registerCodeActionsProvider(
  { scheme: 'file' },
  {
    async provideCodeActions(document, range, context, token) {
      const actions: TraeAPI.CodeAction[] = [];

      // "テストを生成"アクションを追加
      const generateTestsAction = new TraeAPI.CodeAction(
        'テストを生成',
        TraeAPI.CodeActionKind.Refactor
      );
      generateTestsAction.command = {
        command: 'myExtension.generateTests',
        title: 'テストを生成',
        arguments: [document.uri, range]
      };
      actions.push(generateTestsAction);

      // "ドキュメントを生成"アクションを追加
      const generateDocsAction = new TraeAPI.CodeAction(
        'ドキュメントを生成',
        TraeAPI.CodeActionKind.Refactor
      );
      generateDocsAction.command = {
        command: 'myExtension.generateDocs',
        title: 'ドキュメントを生成',
        arguments: [document.uri, range]
      };
      actions.push(generateDocsAction);

      return actions;
    }
  }
);

APIリファレンス

生成メソッド

`generate()`

typescript

generate(options: {
  prompt: string;
  language: string;
  context?: GenerationContext;
  maxTokens?: number;
  temperature?: number;
}): Promise<GenerationResult>;

`complete()`

typescript

complete(options: {
  document: string;
  position: Position;
  language: string;
  maxSuggestions?: number;
}): Promise<CompletionResult>;

`refactor()`

typescript

refactor(options: {
  code: string;
  language: string;
  refactorType: RefactorType;
  instructions?: string;
}): Promise<RefactorResult>;

型定義

typescript

interface GenerationResult {
  code: string;
  explanation: string;
  confidence: number;
  suggestions?: string[];
}

interface CompletionResult {
  suggestions: CompletionSuggestion[];
  context: CompletionContext;
}

interface RefactorResult {
  code: string;
  explanation: string;
  changes: CodeChange[];
}

ベストプラクティス

明確で具体的なプロンプトを提供して、より良い生成結果を得る
関連するコンテキストを含める（既存のコード、ファイル構造、パターン）
生成されたコードを適用前に検証する
適切な温度設定を使用（正確なコードには低く、創造的なソリューションには高く）
生成が失敗した場合のエラーハンドリングを適切に行う
頻繁に使用される生成をキャッシュしてパフォーマンスを向上
コードスタイルとパターンのユーザー設定を尊重する
可能な場合は生成されたコードを自動テストする

エラーハンドリング

typescript

try {
  const result = await TraeAPI.ai.codeGeneration.generate({
    prompt: '複雑なアルゴリズムを作成',
    language: 'typescript'
  });
  
  // 生成されたコードを検証
  const isValid = await validateGeneratedCode(result.code);
  if (!isValid) {
    throw new Error('生成されたコードが無効です');
  }
  
  return result;
} catch (error) {
  if (error instanceof TraeAPI.GenerationError) {
    TraeAPI.window.showErrorMessage(`コード生成に失敗しました: ${error.message}`);
  } else if (error instanceof TraeAPI.ValidationError) {
    TraeAPI.window.showWarningMessage('生成されたコードは手動レビューが必要です');
  } else {
    console.error('予期しないエラー:', error);
  }
}

パフォーマンス最適化

typescript

// 繰り返し生成にキャッシュを使用
const cache = new Map<string, GenerationResult>();

async function generateWithCache(prompt: string, language: string) {
  const cacheKey = `${prompt}:${language}`;
  
  if (cache.has(cacheKey)) {
    return cache.get(cacheKey)!;
  }
  
  const result = await TraeAPI.ai.codeGeneration.generate({ prompt, language });
  cache.set(cacheKey, result);
  
  return result;
}

// 高速生成リクエストをデバウンス
const debouncedGenerate = debounce(async (prompt: string) => {
  return await TraeAPI.ai.codeGeneration.generate({ prompt, language: 'typescript' });
}, 300);

コード生成API ​

概要 ​

基本的な使用方法 ​

シンプルなコード生成 ​

コード補完 ​

コードリファクタリング ​

高度な機能 ​

テンプレートベースの生成 ​

複数ファイル生成 ​

テスト生成 ​

ドキュメント生成 ​

言語変換 ​

コード翻訳 ​

コードの現代化 ​

カスタムコード生成 ​

カスタムジェネレーターの作成 ​

バッチコード生成 ​

エディターとの統合 ​

インラインコード提案 ​

コードアクション ​

APIリファレンス ​

生成メソッド ​

generate() ​

complete() ​

refactor() ​

型定義 ​

ベストプラクティス ​

エラーハンドリング ​

パフォーマンス最適化 ​

関連API ​

コード生成API

概要

基本的な使用方法

シンプルなコード生成

コード補完

コードリファクタリング

高度な機能

テンプレートベースの生成

複数ファイル生成

テスト生成

ドキュメント生成

言語変換

コード翻訳

コードの現代化

カスタムコード生成

カスタムジェネレーターの作成

バッチコード生成

エディターとの統合

インラインコード提案

コードアクション

APIリファレンス

生成メソッド

`generate()`

`complete()`

`refactor()`

型定義

ベストプラクティス

エラーハンドリング

パフォーマンス最適化

関連API