src/
├── filesystem/          # ファイルシステム操作
├── memory/              # Knowledge Graph・永続メモリ
├── sequentialthinking/  # 段階的思考・推論構造化
├── git/                 # Gitリポジトリ操作
├── github/              # GitHub API統合
├── postgres/            # PostgreSQL接続
├── puppeteer/           # ブラウザ自動化
└── ...

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
  McpError,
  ErrorCode,
} from "@modelcontextprotocol/sdk/types.js";

const server = new Server(
  {
    name: "my-server",
    version: "0.1.0",
  },
  {
    capabilities: {
      tools: {},
    },
  }
);

// ツール一覧を返すハンドラ
server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: "my_tool",
        description: "何かするツール",
        inputSchema: {
          type: "object",
          properties: {
            input: { type: "string" },
          },
          required: ["input"],
        },
      },
    ],
  };
});

// ツール実行ハンドラ
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  if (request.params.name === "my_tool") {
    return {
      content: [{ type: "text", text: "結果" }],
    };
  }
  throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`);
});

// 起動
const transport = new StdioServerTransport();
await server.connect(transport);

# ビルド後に実行する場合
node dist/index.js /Users/username/projects /tmp/workspace

const allowedDirectories = process.argv.slice(2).map((dir) =>
  normalizePath(path.resolve(expandHome(dir)))
);

function normalizePath(p: string): string {
  return path.normalize(p);
}

function expandHome(filepath: string): string {
  if (filepath.startsWith("~/") || filepath === "~") {
    return path.join(os.homedir(), filepath.slice(1));
  }
  return filepath;
}

async function validatePath(requestedPath: string): Promise<string> {
  const expandedPath = expandHome(requestedPath);
  const absolute = path.isAbsolute(expandedPath)
    ? path.resolve(expandedPath)
    : path.resolve(process.cwd(), expandedPath);

  const normalizedRequested = normalizePath(absolute);

  // 許可ディレクトリのいずれかのサブパスかチェック
  const isAllowed = allowedDirectories.some((dir) =>
    normalizedRequested.startsWith(dir)
  );

  if (!isAllowed) {
    throw new McpError(
      ErrorCode.InvalidRequest,
      `Access denied - path outside allowed directories: ${absolute}`
    );
  }

  // シンボリックリンクの実体パスも確認（ここが重要！！）
  try {
    const realPath = await fs.realpath(absolute);
    const normalizedReal = normalizePath(realPath);
    const isRealPathAllowed = allowedDirectories.some((dir) =>
      normalizedReal.startsWith(dir)
    );
    if (!isRealPathAllowed) {
      throw new McpError(
        ErrorCode.InvalidRequest,
        "Access denied - symlink target outside allowed directories"
      );
    }
    return realPath;
  } catch (error) {
    // ファイルがまだ存在しない場合（新規作成時）の親ディレクトリ検証
    const parentDir = path.dirname(absolute);
    try {
      const realParentPath = await fs.realpath(parentDir);
      const normalizedParent = normalizePath(realParentPath);
      const isParentAllowed = allowedDirectories.some((dir) =>
        normalizedParent.startsWith(dir)
      );
      if (!isParentAllowed) {
        throw new McpError(
          ErrorCode.InvalidRequest,
          "Access denied - parent directory outside allowed directories"
        );
      }
      return absolute;
    } catch {
      throw new McpError(
        ErrorCode.InvalidRequest,
        `Parent directory does not exist: ${parentDir}`
      );
    }
  }
}

async function searchFiles(
  rootPath: string,
  pattern: string,
  excludePatterns: string[] = []
): Promise<string[]> {
  const results: string[] = [];

  async function search(currentPath: string) {
    const entries = await fs.readdir(currentPath, { withFileTypes: true });

    for (const entry of entries) {
      const fullPath = path.join(currentPath, entry.name);

      // 除外パターンのチェック
      const isExcluded = excludePatterns.some((pat) => {
        const globPattern = pat.includes("/") ? pat : `**/${pat}`;
        return minimatch(fullPath, globPattern, { dot: true });
      });

      if (isExcluded) continue;

      // 各パスに対してもvalidatePathを呼ぶ（セキュリティ！！）
      try {
        await validatePath(fullPath);
      } catch {
        continue;
      }

      if (entry.isDirectory()) {
        await search(fullPath);
      } else if (entry.name.toLowerCase().includes(pattern.toLowerCase())) {
        results.push(fullPath);
      }
    }
  }

  await search(rootPath);
  return results;
}

interface Entity {
  name: string;           // エンティティの名前（一意識別子）
  entityType: string;     // 種別（"person", "project", "concept"など）
  observations: string[]; // このエンティティについての観察・事実
}

interface Relation {
  from: string;           // 関係の起点エンティティ名
  to: string;             // 関係の終点エンティティ名
  relationType: string;   // 関係の種別（"works_on", "knows", "depends_on"など）
}

interface KnowledgeGraph {
  entities: Entity[];
  relations: Relation[];
}

async function loadGraph(): Promise<KnowledgeGraph> {
  try {
    const data = await fs.readFile(MEMORY_FILE_PATH, "utf-8");
    const lines = data.split("\n").filter((line) => line.trim());
    return lines.reduce(
      (graph, line) => {
        const item = JSON.parse(line);
        if (item.type === "entity") {
          graph.entities.push(item);
        } else if (item.type === "relation") {
          graph.relations.push(item);
        }
        return graph;
      },
      { entities: [], relations: [] } as KnowledgeGraph
    );
  } catch {
    return { entities: [], relations: [] };
  }
}

async function saveGraph(graph: KnowledgeGraph): Promise<void> {
  const lines = [
    ...graph.entities.map((e) => JSON.stringify({ type: "entity", ...e })),
    ...graph.relations.map((r) => JSON.stringify({ type: "relation", ...r })),
  ];
  await fs.writeFile(MEMORY_FILE_PATH, lines.join("\n"));
}

interface ThoughtData {
  thought: string;            // 今回の思考内容
  thoughtNumber: number;      // 何番目の思考か
  totalThoughts: number;      // 見積もり総思考数（途中変更可能！！）
  nextThoughtNeeded: boolean; // まだ続きが必要か
  isRevision?: boolean;       // 過去の思考の修正か
  revisesThought?: number;    // どの番号の思考を修正するか
  branchFromThought?: number; // どの番号の思考から分岐するか
  branchId?: string;          // ブランチの識別子
}

processThought(input: unknown): { content: Array<{type: string; text: string}>; isError?: boolean } {
  const validatedInput = this.validateThoughtData(input);

  if (validatedInput.thoughtNumber > validatedInput.totalThoughts) {
    validatedInput.totalThoughts = validatedInput.thoughtNumber;
  }

  this.thoughtHistory.push(validatedInput);

  if (validatedInput.branchFromThought) {
    const branchId =
      validatedInput.branchId ||
      `branch_${validatedInput.branchFromThought}_${validatedInput.thoughtNumber}`;
    if (!this.branches[branchId]) {
      this.branches[branchId] = [];
    }
    this.branches[branchId].push(validatedInput);
  }

  return {
    content: [
      {
        type: "text",
        text: JSON.stringify(
          {
            thoughtNumber: validatedInput.thoughtNumber,
            totalThoughts: validatedInput.totalThoughts,
            nextThoughtNeeded: validatedInput.nextThoughtNeeded,
            branches: Object.keys(this.branches),
            thoughtHistoryLength: this.thoughtHistory.length,
          },
          null,
          2
        ),
      },
    ],
  };
}

// ツール定義：inputSchemaを必ず詳細に書く
{
  name: "tool_name",
  description: "LLMが理解しやすい、具体的で明確な説明。何をするツールか・どんな入力を渡すかを明示する",
  inputSchema: {
    type: "object",
    properties: {
      path: {
        type: "string",
        description: "操作対象のパス（絶対パス推奨）",
      },
      options: {
        type: "object",
        description: "オプション設定",
        properties: {
          recursive: { type: "boolean", description: "再帰的に処理するか" },
        },
      },
    },
    required: ["path"],
  },
}

// エラーハンドリング：McpErrorを使って構造化する
try {
  const validatedPath = await validatePath(requestedPath);
  // 処理...
  return {
    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
  };
} catch (error) {
  if (error instanceof McpError) {
    throw error; // MCPエラーはそのまま再throw
  }
  throw new McpError(
    ErrorCode.InternalError,
    `Unexpected error: ${error instanceof Error ? error.message : String(error)}`
  );
}