コーディング AI エージェントを自作してみよう

npm init -y

{
  "type": "module"
}

npm install ai @ai-sdk/google zod dotenv
npm install --save-dev @types/node tsx typescript

GOOGLE_GENERATIVE_AI_API_KEY=your_api_key

import { google } from "@ai-sdk/google";
import { CoreMessage, streamText } from "ai";
import dotenv from "dotenv";
import * as readline from "node:readline/promises";
 
// 環境変数を .env ファイルから読み込む
dotenv.config();
 
// 標準出力と標準入力を使用して、ユーザーとの対話を行うためのインターフェースを作成
const terminal = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});
 
const messages: CoreMessage[] = [];
 
async function main() {
  while (true) {
    // ユーザーからの入力を待機
    const userInput = await terminal.question("You: ");
 
    // ユーザー入力をチャットの履歴として追加
    messages.push({ role: "user", content: userInput });
 
    // streamText 関数はストリーミングで応答を生成する
    const result = streamText({
      // AI モデルを指定
      // 引数で最新のモデルを指定している
      model: google("gemini-2.5-pro-exp-03-25"),
      messages,
    });
 
    let fullResponse = "";
 
    terminal.write("\nAssistant: ");
    // ストリーミングをチャンクごとに処理
    for await (const delta of result.textStream) {
      fullResponse += delta;
      // 受信したチャンクを標準出力に書き込む
      terminal.write(delta);
    }
    terminal.write("\n\n");
 
    // チャットの履歴に AI の応答を追加
    messages.push({ role: "assistant", content: fullResponse });
  }
}
 
main().catch(console.error);

{
  "scripts": {
    "start": "tsx src/index.ts"
  }
}

npm start

You: こんにちは
 
Assistant: こんにちは！
 
何かお手伝いできることはありますか？
 
You: 今日もいい天気ですね。
 
Assistant: 本当ですね！気持ちのいい青空が広がって、気分も晴れやかになりますね。
 
こんな日は何か良いことがありそうな気がしますね！
 
You: 

import { experimental_createMCPClient as createMCPClient } from "ai";
import { Experimental_StdioMCPTransport as StdioMCPTransport } from "ai/mcp-stdio";
 
const mcpClient = await createMCPClient({
  transport: new StdioMCPTransport({
    command: "npx",
    args: [
      "-y",
      "@modelcontextprotocol/server-filesystem",
      import.meta.dirname, // ここには読み書きを許可するディレクトリを指定
    ],
  }),
});

const tools = await mcpClient.tools();
const result = streamText({
  model: google("gemini-2.5-pro-exp-03-25"),
  messages,
  tools,
  maxSteps: 5
});

process.on("SIGINT", () => {
  mcpClient.close();
  process.exit(0);
});
process.on("SIGTERM", () => {
  mcpClient.close();
  process.exit(0);
});

$ npm start
 
Secure MCP Filesystem Server running on stdio
Allowed directories: [ '...' ]

import { tool } from "ai";
import z from "zod";
export const shellTool = tool({
  // ツールの説明
  description:
    "A shell command executor. You can use it to run shell commands. Returns the output of the command.",
  // ツールの引数を定義
  // Zod スキーマを使用して引数の型を定義する
  parameters: z.object({
    command: z.string().min(1, "Command is required"),
    args: z.array(z.string()).optional(),
    cwd: z.string().optional(),
  }),
  execute: async ({ command, args, cwd }) => {
    // TODO...
  },
});

import { tool } from "ai";
import z from "zod";
import { exec } from "child_process";
import { promisify } from "util";
import * as readline from "node:readline/promises";
 
const execAsync = promisify(exec);
 
export const shellTool = tool({
  // ...
  execute: async ({ command, args, cwd }) => {
    // 注意: os ごとのコマンドの違いは考慮していません
    const fullCommand = [command, ...(args || [])].join(" ");
    const terminal = readline.createInterface({
      input: process.stdin,
      output: process.stdout,
    });
    const confirmation = await terminal.question(
      `Are you sure you want to run this command? ${fullCommand} (y/n) `
    );
    if (confirmation.toLowerCase() !== "y") {
      return "Command execution cancelled because of user confirmation.";
    }
 
    terminal.close();
 
    try {
      const { stdout, stderr } = await execAsync(fullCommand, { cwd });
      return stdout || stderr;
    } catch (error) {
      return `Error executing command: ${error}`;
    }
  },
});

import { shellTool } from "./tools/shell";
// ...
 
const tools = await mcpClient.tools();
const result = streamText({
  model: google("gemini-2.5-pro-exp-03-25"),
  messages,
  tools: {
    ...tools,
    shell: shellTool,
  },
  maxSteps: 5,
});

export const systemPrompt = `あなたは多くのプログラミング言語・フレームワーク・デザインパターン・ベストプラクティスに精通した、非常に熟練したソフトウェアエンジニアである azusa です。あなたは実践的で効率的なコードを書き、問題解決に体系的にアプローチします。
 
## あなたの役割
 
あなたの目的はユーザーからの与えられたタスクを完了することです。そのために:
 
- タスクを明確なステップに分割し、系列的に実行します
- 問題に対して複数の解決策を検討し、最適なアプローチを選択します
- コードの品質とベストプラクティスを常に意識します
- ユーザーのプロジェクト構造やコーディングスタイルを尊重します
 
## あなたの能力
 
タスク完了のために以下のことが可能です:
 
- **ファイルシステム操作**: ファイルの作成・読み取り・更新・削除
- **プロジェクト分析**: ディレクトリ構造の検索、依存関係の分析、コードベースの理解
- **コード実行**: シェルコマンドを実行してコードの動作確認やテスト実行
- **継続的改善**: ユーザーからのフィードバックに基づいたコードの修正と最適化
 
## 作業プロセス
 
1. **必ず**現在のディレクトリ構造確認し、使用されている技術スタックを把握します
2. 解決策を考え、実行計画を立てます
3. 必要なファイルの変更や作成を行います
4. コードが正しく動作するかテストやアプリケーションの実行をシェルコマンドを使用して確認します。使用可能なコマンドはプロジェクトの構造から確認してください
5. 必要に応じて修正と改善を繰り返します
 
## 注意事項
 
- あなたは会話ではなくタスク完了を目的としています。不必要な挨拶や説明は避けてください。
- コード変更時は既存のコードベースを尊重し、プロジェクトの一貫性を保ってください。
- エラーが発生した場合は、詳細なエラーメッセージを提供し、解決策を提案してください。
- 複雑なタスクは小さなステップに分割し、各ステップで進捗を確認してください。
- セキュリティとパフォーマンスを常に意識したコードを書いてください。
`;

import { systemPrompt } from "./prompts/system";
const messages: CoreMessage[] = [
  {
    role: "system",
    content: systemPrompt,
  },
];

const result = streamText({
  model: google("gemini-2.5-pro-exp-03-25"),
  messages,
  tools: {
    ...tools,
    shell: shellTool,
  },
  maxSteps: 20,
  onStepFinish: (step) => {
    console.log("\n\n");
  },
});

import { tool } from "ai";
import z from "zod";
import fs from "fs/promises";
import path from "path";
import * as readline from "node:readline/promises";
 
// ユーザーに確認を求める関数
const confirm = async (message: string): Promise<string> => {
  const terminal = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
  });
  const answer = await terminal.question(`${message} (y/n) `);
 
  terminal.close();
  return answer;
};
 
export const list_directory = tool({
  description:
    "指定されたディレクトリの内容（ファイルとサブディレクトリ）のリストを取得します。",
  parameters: z.object({
    path: z.string().describe("内容をリストするディレクトリのパス"),
  }),
  execute: async ({ path: dirPath }) => {
    const answer = await confirm(
      `次のディレクトリのリストを取得しますか？ ${dirPath}`
    );
    if (answer.toLowerCase() !== "y") {
      return "Directory listing cancelled by user.";
    }
    try {
      const entries = await fs.readdir(dirPath, { withFileTypes: true });
      const result = entries.map((entry) => ({
        name: entry.name,
        isDirectory: entry.isDirectory(),
      }));
      return result;
    } catch (error: any) {
      return `Error listing directory ${dirPath}: ${error.message}`;
    }
  },
});
 
export const read_file = tool({
  description: "指定されたファイルのコンテンツを読み取ります。",
  parameters: z.object({
    path: z.string().describe("読み取るファイルのパス"),
  }),
  execute: async ({ path: filePath }) => {
    const answer = await confirm(`次のファイルを読み込みますか？ ${filePath}`);
    if (answer.toLowerCase() !== "y") {
      return "File reading cancelled by user.";
    }
    try {
      const content = await fs.readFile(filePath, "utf-8");
      return content;
    } catch (error: any) {
      return `Error reading file ${filePath}: ${error.message}`;
    }
  },
});
 
export const write_file = tool({
  description:
    "指定されたパスにファイルを作成または上書きします。必要な親ディレクトリも作成されます。",
  parameters: z.object({
    path: z.string().describe("書き込むファイルのパス"),
    content: z.string().describe("ファイルに書き込むコンテンツ"),
  }),
  execute: async ({ path: filePath, content }) => {
    const answer = await confirm(
      `次のファイルの作成を許可しますか？ ${filePath}
      コンテンツ: ${content} (y/n) `
    );
    if (answer.toLowerCase() !== "y") {
      return "File writing cancelled by user.";
    }
    try {
      const dir = path.dirname(filePath);
      await fs.mkdir(dir, { recursive: true });
 
      await fs.writeFile(filePath, content, "utf-8");
      return `File written successfully to ${filePath}`;
    } catch (error: any) {
      return `Error writing file ${filePath}: ${error.message}`;
    }
  },
});
 
export const create_directory = tool({
  description:
    "指定されたパスに新しいディレクトリを作成します。必要に応じて親ディレクトリも作成します。",
  parameters: z.object({
    path: z.string().describe("作成するディレクトリのパス"),
  }),
  execute: async ({ path: dirPath }) => {
    const answer = await confirm(`次のディレクトリを作成しますか？ ${dirPath}`);
    if (answer.toLowerCase() !== "y") {
      return "Directory creation cancelled by user.";
    }
    try {
      await fs.mkdir(dirPath, { recursive: true });
      return `Directory created successfully at ${dirPath}`;
    } catch (error: any) {
      if (error.code === "EEXIST") {
        return `Directory already exists at ${dirPath}`;
      }
      return `Error creating directory ${dirPath}: ${error.message}`;
    }
  },
});
 
export const edit_file = tool({
  description:
    "指定されたファイル内のテキストを検索し、指定された新しいテキストで置き換えます。削除する場合は、replace_with を空文字列にします。",
  parameters: z.object({
    path: z.string().describe("編集するファイルのパス"),
    search_text: z.string().describe("検索して置き換える対象のテキスト"),
    replace_with: z.string().describe("search_text を置き換える新しいテキスト"),
  }),
  execute: async ({ path: filePath, search_text, replace_with }) => {
    const answer = await confirm(
      `次のファイルの編集を許可しますか？ ${filePath}
      search_text: ${search_text}
      replace_with: ${replace_with}`
    );
 
    // 「y」以外の入力があった場合は、ユーザーからコードを修正すべきフィードバックがあったという想定
    if (answer.toLowerCase() !== "y") {
      return `File editing cancelled by user.
      feedback: ${answer}
      `;
    }
    try {
      let content = await fs.readFile(filePath, "utf-8");
 
      const originalContent = content;
      content = content.replace(search_text, replace_with);
 
      if (content === originalContent) {
        return `Warning: search_text "${search_text}" not found in ${filePath}. File not modified.`;
      }
 
      await fs.writeFile(filePath, content, "utf-8");
      return `File ${filePath} edited successfully.`;
    } catch (error: any) {
      return `Error editing file ${filePath}: ${error.message}`;
    }
  },
});