@zonuexe/techbook-mcp 0.1.0

package/flake.nix

@@ -0,0 +1,50 @@
+{
+  description = "MCP server for Japanese technical book bibliographic search";
+
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+    flake-utils.url = "github:numtide/flake-utils";
+  };
+
+  outputs = { self, nixpkgs, flake-utils }:
+    flake-utils.lib.eachDefaultSystem (system:
+      let
+        pkgs = nixpkgs.legacyPackages.${system};
+      in
+      {
+        packages.default = pkgs.buildNpmPackage {
+          pname = "techbook-mcp";
+          version = "0.1.0";
+          src = ./.;
+          # After running `npm install` to generate package-lock.json,
+          # run `nix build 2>&1 | grep "got:"` and paste the hash here.
+          npmDepsHash = pkgs.lib.fakeHash;
+          buildPhase = ''
+            npm run build
+          '';
+          installPhase = ''
+            mkdir -p $out/lib
+            cp -r dist $out/lib/dist
+            cp package.json $out/lib/
+            makeWrapper ${pkgs.nodejs_22}/bin/node $out/bin/techbook-mcp \
+              --add-flags "$out/lib/dist/main.js"
+          '';
+          nativeBuildInputs = [ pkgs.makeWrapper ];
+        };
+
+        devShells.default = pkgs.mkShell {
+          buildInputs = [
+            pkgs.nodejs_22
+            pkgs.bun
+            pkgs.deno
+          ];
+          shellHook = ''
+            echo "techbook-mcp dev shell"
+            echo "  Node.js $(node --version)"
+            echo "  Bun     $(bun --version)"
+            echo "  Deno    $(deno --version | head -1)"
+          '';
+        };
+      }
+    );
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@zonuexe/techbook-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for searching Japanese technical book bibliographic information",
+  "license": "AGPL-3.0-or-later",
+  "type": "module",
+  "exports": {
+    ".": "./dist/main.js"
+  },
+  "bin": {
+    "techbook-mcp": "./dist/main.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.11.0",
+    "cheerio": "^1.0.0",
+    "iconv-lite": "^0.6.0",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.8.0",
+    "vitest": "^3.0.0"
+  }
+}

package/src/adapters/cache/memory-cache.ts

@@ -0,0 +1,31 @@
+import type { CacheStore } from "../../ports/cache.js";
+
+interface CacheEntry {
+  value: string;
+  expiresAt?: number;
+}
+
+export class MemoryCacheStore implements CacheStore {
+  private readonly store = new Map<string, CacheEntry>();
+
+  async get(key: string): Promise<string | null> {
+    const entry = this.store.get(key);
+    if (!entry) return null;
+    if (entry.expiresAt !== undefined && Date.now() > entry.expiresAt) {
+      this.store.delete(key);
+      return null;
+    }
+    return entry.value;
+  }
+
+  async set(key: string, value: string, ttlSeconds?: number): Promise<void> {
+    this.store.set(key, {
+      value,
+      expiresAt: ttlSeconds !== undefined ? Date.now() + ttlSeconds * 1000 : undefined,
+    });
+  }
+
+  async delete(key: string): Promise<void> {
+    this.store.delete(key);
+  }
+}

package/src/adapters/cache/null-cache.ts

@@ -0,0 +1,8 @@
+import type { CacheStore } from "../../ports/cache.js";
+
+/** テスト・デバッグ用。キャッシュを一切行わない。 */
+export class NullCacheStore implements CacheStore {
+  async get(_key: string): Promise<null> { return null; }
+  async set(_key: string, _value: string, _ttlSeconds?: number): Promise<void> {}
+  async delete(_key: string): Promise<void> {}
+}

package/src/adapters/html/cheerio-parser.ts

@@ -0,0 +1,49 @@
+import * as cheerio from "cheerio";
+import type { HtmlParser, HtmlDocument, HtmlElement } from "../../ports/html-parser.js";
+
+class CheerioElement implements HtmlElement {
+  constructor(
+    private readonly $: cheerio.CheerioAPI,
+    private readonly el: cheerio.Element,
+  ) {}
+
+  text(): string {
+    return this.$(this.el).text().trim();
+  }
+
+  html(): string | null {
+    return this.$(this.el).html();
+  }
+
+  attr(name: string): string | undefined {
+    return this.$(this.el).attr(name);
+  }
+
+  find(selector: string): HtmlElement[] {
+    return this.$(this.el)
+      .find(selector)
+      .toArray()
+      .map(el => new CheerioElement(this.$, el));
+  }
+}
+
+class CheerioDocument implements HtmlDocument {
+  constructor(private readonly $: cheerio.CheerioAPI) {}
+
+  select(selector: string): HtmlElement[] {
+    return this.$(selector)
+      .toArray()
+      .map(el => new CheerioElement(this.$, el));
+  }
+
+  selectOne(selector: string): HtmlElement | null {
+    return this.select(selector)[0] ?? null;
+  }
+}
+
+export class CheerioHtmlParser implements HtmlParser {
+  parse(html: string): HtmlDocument {
+    const $ = cheerio.load(html);
+    return new CheerioDocument($);
+  }
+}

package/src/adapters/http/fetch-client.ts

@@ -0,0 +1,47 @@
+import type { HttpClient, RequestOptions, HttpResponse } from "../../ports/http.js";
+
+class FetchHttpResponse implements HttpResponse {
+  constructor(private readonly response: Response) {}
+
+  get status(): number {
+    return this.response.status;
+  }
+
+  get url(): string {
+    return this.response.url;
+  }
+
+  text(): Promise<string> {
+    return this.response.text();
+  }
+
+  header(name: string): string | null {
+    return this.response.headers.get(name);
+  }
+}
+
+export class FetchHttpClient implements HttpClient {
+  async get(url: string, options?: RequestOptions): Promise<HttpResponse> {
+    const init: RequestInit = {
+      headers: options?.headers,
+    };
+    if (options?.timeout !== undefined) {
+      init.signal = AbortSignal.timeout(options.timeout);
+    }
+    const response = await fetch(url, init);
+    return new FetchHttpResponse(response);
+  }
+
+  async post(url: string, body: string, options?: RequestOptions): Promise<HttpResponse> {
+    const init: RequestInit = {
+      method: "POST",
+      body,
+      headers: { "Content-Type": "application/json", ...options?.headers },
+    };
+    if (options?.timeout !== undefined) {
+      init.signal = AbortSignal.timeout(options.timeout);
+    }
+    const response = await fetch(url, init);
+    return new FetchHttpResponse(response);
+  }
+}

package/src/adapters/http/mock-client.ts

@@ -0,0 +1,77 @@
+import type { HttpClient, RequestOptions, HttpResponse } from "../../ports/http.js";
+
+export interface MockResponseData {
+  status: number;
+  body: string;
+  headers?: Record<string, string>;
+}
+
+class MockHttpResponse implements HttpResponse {
+  constructor(
+    private readonly data: MockResponseData,
+    private readonly requestUrl: string,
+  ) {}
+
+  get status(): number { return this.data.status; }
+  get url(): string { return this.requestUrl; }
+  async text(): Promise<string> { return this.data.body; }
+  header(name: string): string | null {
+    return this.data.headers?.[name.toLowerCase()] ?? null;
+  }
+}
+
+export class MockHttpClient implements HttpClient {
+  private readonly handlers = new Map<string, MockResponseData>();
+  private readonly postHandlers = new Map<string, MockResponseData>();
+  private readonly _calls: string[] = [];
+
+  /** GET: URL の前方一致でレスポンスを登録する */
+  addResponse(urlPrefix: string, data: MockResponseData): this {
+    this.handlers.set(urlPrefix, data);
+    return this;
+  }
+
+  /** POST: URL の前方一致でレスポンスを登録する */
+  addPostResponse(urlPrefix: string, data: MockResponseData): this {
+    this.postHandlers.set(urlPrefix, data);
+    return this;
+  }
+
+  get calls(): readonly string[] {
+    return this._calls;
+  }
+
+  async get(url: string, _options?: RequestOptions): Promise<HttpResponse> {
+    this._calls.push(url);
+
+    // 完全一致を優先
+    if (this.handlers.has(url)) {
+      return new MockHttpResponse(this.handlers.get(url)!, url);
+    }
+
+    // 前方一致
+    for (const [prefix, data] of this.handlers) {
+      if (url.startsWith(prefix)) {
+        return new MockHttpResponse(data, url);
+      }
+    }
+
+    throw new Error(`MockHttpClient: no handler for GET: ${url}`);
+  }
+
+  async post(url: string, _body: string, _options?: RequestOptions): Promise<HttpResponse> {
+    this._calls.push(url);
+
+    if (this.postHandlers.has(url)) {
+      return new MockHttpResponse(this.postHandlers.get(url)!, url);
+    }
+
+    for (const [prefix, data] of this.postHandlers) {
+      if (url.startsWith(prefix)) {
+        return new MockHttpResponse(data, url);
+      }
+    }
+
+    throw new Error(`MockHttpClient: no handler for POST: ${url}`);
+  }
+}

package/src/adapters/publishers/base.ts

@@ -0,0 +1,129 @@
+import type { PublisherDeps } from "../../domain/publisher.js";
+import type { EbookStore, DrmType } from "../../domain/book.js";
+import type { HtmlDocument } from "../../ports/html-parser.js";
+
+const DEFAULT_HEADERS = {
+  "User-Agent": "techbook-mcp/0.1.0 (+https://github.com/zonuexe/techbook-mcp; bibliographic search bot)",
+  "Accept": "text/html,application/xhtml+xml,application/json",
+  "Accept-Language": "ja,en;q=0.9",
+};
+
+export const CACHE_TTL_SECONDS = 3600; // 1時間
+
+export async function fetchText(
+  url: string,
+  deps: PublisherDeps,
+  extraHeaders?: Record<string, string>,
+): Promise<string> {
+  const cached = await deps.cache.get(url);
+  if (cached !== null) return cached;
+
+  const headers = extraHeaders
+    ? { ...DEFAULT_HEADERS, ...extraHeaders }
+    : DEFAULT_HEADERS;
+
+  const response = await deps.http.get(url, { headers });
+  if (response.status !== 200) {
+    throw new Error(`HTTP ${response.status}: ${url}`);
+  }
+
+  const text = await response.text();
+  await deps.cache.set(url, text, CACHE_TTL_SECONDS);
+  return text;
+}
+
+/** HTMLタグを除去する（gihyo APIのauthorフィールドのruby markup除去に使用） */
+export function stripHtmlTags(html: string): string {
+  return html.replace(/<[^>]+>/g, "");
+}
+
+/** "¥3,960" や "3,300円（税込）" などから整数値を取り出す */
+export function parseJapanesePrice(text: string): number | undefined {
+  const match = text.match(/[\d,]+/);
+  if (!match) return undefined;
+  return parseInt(match[0].replace(/,/g, ""), 10);
+}
+
+/** 相対URLを絶対URLに解決する */
+export function resolveUrl(base: string, path: string): string {
+  return new URL(path, base).toString();
+}
+
+/**
+ * HTMLテキストから Amazon ASIN を抽出する。
+ * amazon.co.jp/dp/{ASIN}, /gp/product/{ASIN}, /o/ASIN/{ASIN} 形式に対応。
+ */
+export function extractAsin(html: string): string | undefined {
+  const match = html.match(/amazon\.co\.jp\/(?:dp|gp\/product|o\/ASIN)\/([A-Z0-9]{10})/);
+  return match?.[1];
+}
+
+// --- 電子書籍ストア分類 ---
+
+interface StorePattern {
+  pattern: RegExp;
+  name: string;
+  drm: DrmType;
+}
+
+const EBOOK_STORE_PATTERNS: StorePattern[] = [
+  // DRM-free
+  { pattern: /techbookfest\.org\/product\//, name: "技術書典", drm: "free" },
+  { pattern: /oreilly\.co\.jp\/books\//, name: "オライリー・ジャパン", drm: "free" },
+  { pattern: /shop\.rutles\.net\//, name: "ラトルズ", drm: "free" },
+  { pattern: /peaks\.cc\/books\//, name: "PEAKS", drm: "free" },
+  { pattern: /optronics-ebook\.com\/products\//, name: "オプトロニクス社", drm: "free" },
+  { pattern: /gihyo\.jp\/dp\/ebook\//, name: "Gihyo Digital Publishing", drm: "social" },
+  { pattern: /seshop\.com\/product\//, name: "SEshop", drm: "social" },
+  { pattern: /book-tech\.com\/books\//, name: "BOOK TECH", drm: "social" },
+  { pattern: /wgn-obs\.shop-pro\.jp\/\?pid=/, name: "ボーンデジタル", drm: "social" },
+  // ソーシャルDRM (購入時生成IDまたは購入者情報を透かし刻印、技術的制限なし)
+  { pattern: /book\.mynavi\.jp\/manatee\//, name: "マナティ", drm: "social" },
+  { pattern: /www\.lambdanote\.com\/products\//, name: "ラムダノート", drm: "social" },
+  { pattern: /tatsu-zine\.com\/books\/(?!pub\/)/, name: "達人出版会", drm: "social" },
+  // ソーシャルDRM (購入者情報透かし入りPDF、技術的制限なし)
+  { pattern: /book\.impress\.co\.jp\/books\//, name: "インプレスブックス", drm: "social" },
+  // DRM-attached
+  { pattern: /saiensu\.co\.jp/, name: "サイエンス社", drm: "password_pdf" },
+  { pattern: /amazon\.co\.jp/, name: "Kindle", drm: "drm" },
+  { pattern: /kinokuniya\.co\.jp\/(?:kinoppystore|f\/dsg-08)/, name: "Kinoppy", drm: "drm" },
+  { pattern: /coop-ebook\.jp\/mem\//, name: "VarsityWave eBooks", drm: "drm" },
+  { pattern: /books\.rakuten\.co\.jp|rakuten\.kobo\.com|kobo\.com/, name: "楽天Kobo", drm: "drm" },
+  { pattern: /booklive\.jp/, name: "BookLive", drm: "drm" },
+  { pattern: /honto\.jp/, name: "honto", drm: "drm" },
+  { pattern: /bookwalker\.jp/, name: "BOOK☆WALKER", drm: "drm" },
+  { pattern: /ebookjapan\.yahoo\.co\.jp/, name: "eBookJapan", drm: "drm" },
+  { pattern: /store\.line\.me/, name: "LINEマンガ", drm: "drm" },
+];
+
+/** URLから電子書籍ストア情報を返す。未知のストアは null。 */
+export function classifyEbookStore(url: string): EbookStore | null {
+  for (const { pattern, name, drm } of EBOOK_STORE_PATTERNS) {
+    if (pattern.test(url)) {
+      return { name, url, drm };
+    }
+  }
+  return null;
+}
+
+/**
+ * HTMLドキュメント内の全リンクを走査して電子書籍ストアを抽出する。
+ * 同一ストアのURLが複数あれば最初の1件のみ返す。
+ */
+export function extractEbookStoresFromDoc(doc: HtmlDocument): EbookStore[] {
+  const stores: EbookStore[] = [];
+  const seenNames = new Set<string>();
+
+  for (const link of doc.select("a[href]")) {
+    const href = link.attr("href");
+    if (!href) continue;
+
+    const store = classifyEbookStore(href);
+    if (store && !seenNames.has(store.name)) {
+      seenNames.add(store.name);
+      stores.push(store);
+    }
+  }
+
+  return stores;
+}

package/src/adapters/publishers/book-tech.ts

@@ -0,0 +1,117 @@
+import type { PublisherAdapter, PublisherDeps } from "../../domain/publisher.js";
+import type { BookRecord, SearchQuery } from "../../domain/book.js";
+import { fetchText, parseJapanesePrice, resolveUrl } from "./base.js";
+
+const BASE_URL = "https://book-tech.com";
+const SEARCH_URL = `${BASE_URL}/books`;
+// クエリパラメータキー（URLエンコード済み）
+const SEARCH_PARAM = "q%5Btitle_or_overview_or_identification_number_1_or_product_code_cont%5D";
+
+/** "2026/2/20" → "2026-02-20" */
+function parseDate(text: string): string | undefined {
+  const m = text.match(/(\d{4})\/(\d{1,2})\/(\d{1,2})/);
+  if (!m) return undefined;
+  return `${m[1]}-${m[2].padStart(2, "0")}-${m[3].padStart(2, "0")}`;
+}
+
+/** "(著)" などの役割語を末尾から除去する */
+function stripRole(name: string): string {
+  return name.replace(/\s*[（(][^)）]*[)）]\s*$/, "").trim();
+}
+
+export const bookTechAdapter: PublisherAdapter = {
+  id: "book-tech",
+  name: "BOOK TECH",
+  baseUrl: BASE_URL,
+
+  async search(query: SearchQuery, deps: PublisherDeps): Promise<BookRecord[]> {
+    const word = [query.title, query.author].filter(Boolean).join(" ");
+    if (!word) return [];
+
+    const url = `${SEARCH_URL}?${SEARCH_PARAM}=${encodeURIComponent(word)}`;
+    const html = await fetchText(url, deps);
+    const doc = deps.parser.parse(html);
+
+    const results: BookRecord[] = [];
+    const limit = query.limit ?? 10;
+
+    for (const item of doc.select("div.contents-index-item")) {
+      const linkEl = item.find("a.book-ribbon-link")[0];
+      const href = linkEl?.attr("href");
+      if (!href) continue;
+      const bookUrl = resolveUrl(BASE_URL, href);
+
+      const title = item.find(".contents-index-item-detail-title")[0]?.text().trim();
+      if (!title) continue;
+
+      const publisherEl = item.find("a[href*='publisher_relations']")[0];
+      const publisher = publisherEl?.text().trim() ?? "";
+
+      const authors = item.find("a[href*='author_relations']")
+        .map(el => stripRole(el.text().trim()))
+        .filter(Boolean);
+
+      const priceText = item.find(".contents-index-item-detail-price_include_tax")[0]?.text();
+      const price = priceText ? parseJapanesePrice(priceText) : undefined;
+
+      const dateText = item.find(".my-1")[0]?.text();
+      const publishedAt = dateText ? parseDate(dateText) : undefined;
+
+      const imgEl = item.find("img.thumb")[0];
+      const coverImageUrl = imgEl?.attr("src") ?? undefined;
+
+      results.push({
+        title,
+        authors,
+        publisher,
+        url: bookUrl,
+        price,
+        publishedAt,
+        coverImageUrl,
+        ebookStores: [{ name: "BOOK TECH", url: bookUrl, drm: "social" }],
+      });
+
+      if (results.length >= limit) break;
+    }
+
+    return results;
+  },
+
+  async getDetail(url: string, deps: PublisherDeps): Promise<BookRecord> {
+    const html = await fetchText(url, deps);
+    const doc = deps.parser.parse(html);
+
+    const title = doc.selectOne(".contents-book-about-title h1")?.text().trim() ?? "";
+
+    const publisherEl = doc.selectOne("a[href*='publisher_relations']");
+    const publisher = publisherEl?.text().trim() ?? "";
+
+    const authors = doc.select("a[href*='author_relations']")
+      .map(el => stripRole(el.text().trim()))
+      .filter(Boolean);
+
+    const priceText = doc.selectOne(".contents-book-item-detail-price_include_tax")?.text();
+    const price = priceText ? parseJapanesePrice(priceText) : undefined;
+
+    const dateText = doc.selectOne(".contents-book-about-publicationdate")?.text();
+    const publishedAt = dateText ? parseDate(dateText) : undefined;
+
+    const isbnText = doc.selectOne(".contents-book-about-id")?.text();
+    const isbn = isbnText?.match(/\d{13}/)?.[0];
+
+    const imgEl = doc.selectOne("img.thumb");
+    const coverImageUrl = imgEl?.attr("src") ?? undefined;
+
+    return {
+      title,
+      authors,
+      publisher,
+      url,
+      isbn,
+      price,
+      publishedAt,
+      coverImageUrl,
+      ebookStores: [{ name: "BOOK TECH", url, drm: "social" }],
+    };
+  },
+};