import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
  type ServerResult,
} from '@modelcontextprotocol/sdk/types.js';
import { readFileSync } from 'node:fs';
import { GraphCache } from './cache.js';
import { makeWikiGraphTools } from './tools.js';

function readPackageVersion(): string {
  const pkgUrl = new URL('../package.json', import.meta.url);
  const pkg = JSON.parse(readFileSync(pkgUrl, 'utf8')) as { version?: unknown };
  if (typeof pkg.version !== 'string' || pkg.version.length === 0) {
    throw new Error(`package.json at ${pkgUrl.pathname} missing string "version" field`);
  }
  return pkg.version;
}

async function main(): Promise<void> {
  const cache = new GraphCache();
  const tools = makeWikiGraphTools(cache);
  const byName = new Map(tools.map((t) => [t.name, t]));

  const server = new Server(
    { name: 'wiki-graph', version: readPackageVersion() },
    { capabilities: { tools: {} } },
  );

  server.setRequestHandler(ListToolsRequestSchema, async () => ({
    tools: tools.map((t) => ({
      name: t.name,
      description: t.description,
      inputSchema: t.inputSchema,
    })),
  }));

  server.setRequestHandler(CallToolRequestSchema, async (req): Promise<ServerResult> => {
    const tool = byName.get(req.params.name);
    if (!tool) {
      return {
        content: [{ type: 'text', text: `Unknown tool: ${req.params.name}` }],
        isError: true,
      };
    }
    // ToolResult is a structural CallToolResult; cast over the widened SDK union.
    return tool.handler(req.params.arguments ?? {}) as ServerResult;
  });

  const transport = new StdioServerTransport();
  await server.connect(transport);
}

await main();