ffxiv_ptfinder 1.0.1

package/src/lambdaHandler.ts

@@ -0,0 +1,39 @@
+import { readEnvOptions, resolveOptions } from "./envOptions";
+import { runApp } from "./runApp";
+import { createLogger } from "./logger";
+
+type ApiGatewayResultV2 = {
+  statusCode: number;
+  headers?: Record<string, string>;
+  body?: string;
+};
+
+/**
+ * AWS Lambda handler。
+ *
+ * EventBridge のスケジュール実行を想定し、設定は環境変数のみで行います。
+ */
+export async function handler(
+  _event?: unknown,
+  context?: { awsRequestId?: string }
+): Promise<ApiGatewayResultV2> {
+  const logger = createLogger("lambda");
+  const startedAt = Date.now();
+  logger.info("invoke", { awsRequestId: context?.awsRequestId });
+
+  try {
+    const env = readEnvOptions();
+    const options = resolveOptions({}, env);
+    const result = await runApp(options);
+
+    logger.info("success", { awsRequestId: context?.awsRequestId, sent: result.sent, ms: Date.now() - startedAt });
+    return {
+      statusCode: 200,
+      headers: { "content-type": "application/json; charset=utf-8" },
+      body: JSON.stringify({ ok: true, sent: result.sent })
+    };
+  } catch (err: unknown) {
+    logger.error("error", { awsRequestId: context?.awsRequestId, err, ms: Date.now() - startedAt });
+    throw err;
+  }
+}

package/src/listingsPipeline.ts

@@ -0,0 +1,50 @@
+import { extractListingsFromHtml } from "./extractListings";
+import { applyDescriptionTags } from "./descriptionRequirements";
+import { loadDescriptionTagsJa } from "./descriptionTags";
+import { loadHtml } from "./fetchHtml";
+import {
+  ALLOWED_DATA_CENTRES,
+  DEFAULT_FILTER_FILE
+} from "./config";
+import type { Listing } from "./types";
+import { matchTextFilter, type ListingSearchFilter } from "./searchFilter";
+
+/**
+ * 対象DC（Elemental/Mana/Meteor/Gaia）のみに絞り込みます。
+ */
+function filterAllowedDataCentres(listings: Listing[]): Listing[] {
+  return listings.filter((l) => l.dataCentre && ALLOWED_DATA_CENTRES.has(l.dataCentre));
+}
+
+export type PipelineOptions = {
+  input: string;
+  searchFilter?: ListingSearchFilter;
+};
+
+/**
+ * HTML取得→募集抽出→DC/クエリ絞り込み→要件抽出、までを行います。
+ *
+ * Webhook送信やテキスト整形はこの関数の責務に含めません。
+ */
+export async function buildListings(options: PipelineOptions): Promise<Listing[]> {
+  const html = await loadHtml(options.input);
+  const allListings = extractListingsFromHtml(html);
+  const dcFiltered = filterAllowedDataCentres(allListings);
+  const queryFiltered = dcFiltered;
+
+  const tagsJa = await loadDescriptionTagsJa();
+  const tagged = applyDescriptionTags(queryFiltered, tagsJa.tags);
+  const preFiltered = tagged;
+  if (!options.searchFilter) return preFiltered;
+
+  const f = options.searchFilter;
+  return preFiltered.filter((l) => {
+    if (!matchTextFilter(l.duty?.title ?? "", f.dutyTitle)) return false;
+    if (!matchTextFilter(l.creator ?? "", f.creator)) return false;
+    if (f.dataCentres && f.dataCentres.length > 0 && !f.dataCentres.includes(l.dataCentre ?? "")) return false;
+    if (f.pfCategories && f.pfCategories.length > 0 && !f.pfCategories.includes(l.dataPfCategory ?? "")) return false;
+    if (!matchTextFilter(l.description ?? "", f.description)) return false;
+    if (!matchTextFilter((l.requirements ?? []).join(" "), f.requirements)) return false;
+    return true;
+  });
+}

package/src/lodestoneEnrichment.ts

@@ -0,0 +1,96 @@
+import type { Listing } from "./types";
+import {
+  buildAchievementCategoryUrl,
+  fetchAchievementCategoryHtml,
+  parseUltimateClearsFromAchievementHtml
+} from "@piyoraik/ffxiv-lodestone-character-lookup";
+import {
+  buildLodestoneSearchUrl,
+  fetchTopCharacterUrl,
+  parseCreator
+} from "@piyoraik/ffxiv-lodestone-character-lookup";
+
+type CacheEntry = {
+  searchUrl: string;
+  characterUrl?: string;
+  achievementUrl?: string;
+  ultimateStatus?: "ok" | "private_or_unavailable" | "error";
+  ultimateClears?: string[];
+};
+
+export type LodestoneEnrichmentCache = Map<string, CacheEntry>;
+
+/**
+ * Lodestone補完（検索URL/キャラクターURL/アチーブ取得）用のキャッシュを作成します。
+ *
+ * 同一募集者が複数回出てくるケースがあるため、1実行内で使い回します。
+ */
+export function createLodestoneEnrichmentCache(): LodestoneEnrichmentCache {
+  return new Map<string, CacheEntry>();
+}
+
+/**
+ * 募集者情報（`Name @ World`）から Lodestone の検索URL/キャラクターURL/アチーブ達成状況を補完します。
+ *
+ * 検索の結果、先頭にヒットしたURLが取得できない場合でも、検索URLはセットします。
+ */
+export async function enrichListingWithLodestone(
+  listing: Listing,
+  cache: LodestoneEnrichmentCache
+): Promise<Listing> {
+  const creator = listing.creator?.trim();
+  if (!creator) return listing;
+
+  const cached = cache.get(creator);
+  if (cached) {
+    return {
+      ...listing,
+      creatorLodestoneSearchUrl: cached.searchUrl,
+      creatorLodestoneUrl: cached.characterUrl,
+      creatorAchievementUrl: cached.achievementUrl,
+      creatorUltimateClears: cached.ultimateClears,
+      creatorUltimateClearsStatus: cached.ultimateStatus
+    };
+  }
+
+  const info = parseCreator(creator);
+  if (!info) return listing;
+
+  const searchUrl = buildLodestoneSearchUrl(info);
+  let characterUrl: string | undefined;
+  let achievementUrl: string | undefined;
+  let ultimateStatus: "ok" | "private_or_unavailable" | "error" | undefined;
+  let ultimateClears: string[] | undefined;
+
+  try {
+    characterUrl = await fetchTopCharacterUrl(searchUrl);
+  } catch {
+    // 失敗しても後続処理は継続する
+    characterUrl = undefined;
+  }
+
+  if (characterUrl) {
+    achievementUrl = buildAchievementCategoryUrl(characterUrl);
+    if (achievementUrl) {
+      try {
+        const html = await fetchAchievementCategoryHtml(achievementUrl);
+        const parsed = parseUltimateClearsFromAchievementHtml(html);
+        ultimateStatus = parsed.status;
+        ultimateClears = parsed.clears;
+      } catch {
+        ultimateStatus = "error";
+        ultimateClears = undefined;
+      }
+    }
+  }
+
+  cache.set(creator, { searchUrl, characterUrl, achievementUrl, ultimateStatus, ultimateClears });
+  return {
+    ...listing,
+    creatorLodestoneSearchUrl: searchUrl,
+    creatorLodestoneUrl: characterUrl,
+    creatorAchievementUrl: achievementUrl,
+    creatorUltimateClears: ultimateClears,
+    creatorUltimateClearsStatus: ultimateStatus
+  };
+}

package/src/logger.ts

@@ -0,0 +1,60 @@
+export type LogLevel = "debug" | "info" | "warn" | "error";
+
+export type Logger = {
+  debug: (message: string, fields?: Record<string, unknown>) => void;
+  info: (message: string, fields?: Record<string, unknown>) => void;
+  warn: (message: string, fields?: Record<string, unknown>) => void;
+  error: (message: string, fields?: Record<string, unknown>) => void;
+};
+
+function serializeError(err: unknown): Record<string, unknown> {
+  if (err instanceof Error) {
+    return {
+      name: err.name,
+      message: err.message,
+      stack: err.stack
+    };
+  }
+  return { message: String(err) };
+}
+
+function toLogObject(params: {
+  level: LogLevel;
+  component: string;
+  message: string;
+  fields?: Record<string, unknown>;
+}): Record<string, unknown> {
+  const base: Record<string, unknown> = {
+    ts: new Date().toISOString(),
+    level: params.level,
+    component: params.component,
+    message: params.message
+  };
+
+  const fields = params.fields ?? {};
+  for (const [key, value] of Object.entries(fields)) {
+    if (value instanceof Error) base[key] = serializeError(value);
+    else if (value !== undefined) base[key] = value;
+  }
+
+  return base;
+}
+
+/**
+ * CloudWatch Logs で追いやすい JSON 1行ログを出すための logger を作ります。
+ */
+export function createLogger(component: string): Logger {
+  const write = (level: LogLevel, message: string, fields?: Record<string, unknown>) => {
+    // 1行JSONに揃える（CloudWatch上でフィルタしやすくする）
+    const obj = toLogObject({ level, component, message, fields });
+    process.stdout.write(JSON.stringify(obj) + "\n");
+  };
+
+  return {
+    debug: (message, fields) => write("debug", message, fields),
+    info: (message, fields) => write("info", message, fields),
+    warn: (message, fields) => write("warn", message, fields),
+    error: (message, fields) => write("error", message, fields)
+  };
+}
+

package/src/notifyCli.ts

@@ -0,0 +1,32 @@
+import { parseCliArgs } from "./cliOptions";
+import { readEnvOptions, resolveOptions } from "./envOptions";
+import { runApp } from "./runApp";
+
+/**
+ * パイプ出力時（例: `| head`）の EPIPE を無視するハンドラを登録します。
+ */
+function installStdoutEpipeHandler(): void {
+  process.stdout.on("error", (err: NodeJS.ErrnoException) => {
+    if (err.code === "EPIPE") process.exit(0);
+    throw err;
+  });
+}
+
+/**
+ * 通知（Webhook送信）用 CLI。
+ * EventBridge/Lambda と同じ `runApp` を呼び出して実行します。
+ */
+async function main(): Promise<void> {
+  installStdoutEpipeHandler();
+  const cliOptions = parseCliArgs(process.argv.slice(2));
+  const envOptions = readEnvOptions();
+  const options = resolveOptions(cliOptions, envOptions);
+  await runApp(options);
+}
+
+main().catch((err: unknown) => {
+  const message = err instanceof Error ? err.stack ?? err.message : String(err);
+  process.stderr.write(message + "\n");
+  process.exitCode = 1;
+});
+

package/src/partyText.ts

@@ -0,0 +1,161 @@
+import type { Listing } from "./types";
+import {
+  getUltimateAchievementGroupMap,
+  getUltimateAchievementShortMap,
+  type HighEndAchievementGroup,
+  type UltimateAchievementName
+} from "@piyoraik/ffxiv-lodestone-character-lookup";
+
+export type PartyRole = "tank" | "healer" | "dps";
+
+/**
+ * `title` 内のスペース区切りジョブコードを分割します。
+ */
+export function splitJobList(value: string): string[] {
+  return value
+    .split(/\s+/)
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+/**
+ * party の classList からロールヒント（`tank`/`healer`/`dps`）を取得します。
+ */
+export function getRolesFromClassList(classList: string[]): PartyRole[] {
+  const roles: PartyRole[] = [];
+  if (classList.includes("tank")) roles.push("tank");
+  if (classList.includes("healer")) roles.push("healer");
+  if (classList.includes("dps")) roles.push("dps");
+  return roles;
+}
+
+/**
+ * ジョブコードからロールを解決します（ルックアップマップを使用）。
+ */
+export function getRoleFromJobCode(
+  jobCode: string,
+  jobCodeToRole: Map<string, PartyRole>
+): PartyRole | undefined {
+  return jobCodeToRole.get(jobCode);
+}
+
+function formatLine(label: string, values: Iterable<string>): string {
+  const text = Array.from(values).join(" ");
+  return `${label}：${text}`;
+}
+
+type PartyGroups = {
+  joined: Record<PartyRole, string[]>;
+  recruiting: Record<PartyRole, Set<string>>;
+};
+
+function createEmptyPartyGroups(): PartyGroups {
+  return {
+    joined: { tank: [], healer: [], dps: [] },
+    recruiting: { tank: new Set<string>(), healer: new Set<string>(), dps: new Set<string>() }
+  };
+}
+
+/**
+ * listing の `party` 配列から、ロール別の参加/募集情報を組み立てます。
+ */
+export function buildPartyGroups(
+  listing: Listing,
+  codeToShort: Map<string, string>,
+  codeToRole: Map<string, PartyRole>
+): PartyGroups {
+  const groups = createEmptyPartyGroups();
+
+  for (const item of listing.party) {
+    if (item.classList.includes("total")) continue;
+    const title = item.title?.trim();
+    if (!title) continue;
+
+    if (item.classList.includes("filled")) {
+      const role = getRoleFromJobCode(title, codeToRole);
+      if (!role) continue;
+      groups.joined[role].push(codeToShort.get(title) ?? title);
+      continue;
+    }
+
+    const rolesFromClass = getRolesFromClassList(item.classList);
+    for (const job of splitJobList(title)) {
+      const short = codeToShort.get(job) ?? job;
+      const roleFromCode = getRoleFromJobCode(job, codeToRole);
+
+      if (rolesFromClass.length > 0) {
+        for (const role of rolesFromClass) groups.recruiting[role].add(short);
+        continue;
+      }
+
+      if (roleFromCode) groups.recruiting[roleFromCode].add(short);
+    }
+  }
+
+  return groups;
+}
+
+/**
+ * 1件の募集をテキストブロックとして整形します。
+ */
+export function formatListingText(
+  listing: Listing,
+  codeToShort: Map<string, string>,
+  codeToRole: Map<string, PartyRole>
+): string {
+  const { joined, recruiting } = buildPartyGroups(listing, codeToShort, codeToRole);
+
+  return [
+    `コンテンツ: ${listing.duty?.title ?? ""}`,
+    `募集者: ${listing.creator ?? ""}`,
+    `ロードストーン: ${listing.creatorLodestoneUrl ?? listing.creatorLodestoneSearchUrl ?? ""}`,
+    `絶クリア: ${formatHighEndClears(listing, "ultimate")}`,
+    `零式クリア: ${formatHighEndClears(listing, "savage")}`,
+    `DC: ${listing.dataCentre ?? ""}`,
+    `カテゴリ: ${listing.dataPfCategory ?? ""}`,
+    `要件: ${listing.requirements.join(" ")}`,
+    `募集文: ${listing.description}`,
+    "パーティ:",
+    "【参加ジョブ】",
+    formatLine("タンク", joined.tank),
+    formatLine("ヒーラー", joined.healer),
+    formatLine("DPS", joined.dps),
+    "【募集ジョブ】",
+    formatLine("タンク", recruiting.tank),
+    formatLine("ヒーラー", recruiting.healer),
+    formatLine("DPS", recruiting.dps)
+  ].join("\n");
+}
+
+/**
+ * 高難度（絶/零式）アチーブ達成状況を表示用に整形します。
+ */
+function formatHighEndClears(listing: Listing, group: HighEndAchievementGroup): string {
+  if (!listing.creatorAchievementUrl && !listing.creatorLodestoneUrl) return "";
+
+  const status = listing.creatorUltimateClearsStatus;
+  if (status === "private_or_unavailable") return "非公開/取得不可";
+  if (status === "error") return "取得エラー";
+
+  const clears = listing.creatorUltimateClears ?? [];
+  if (clears.length === 0) return "なし";
+
+  const shortMap = getUltimateAchievementShortMap();
+  const groupMap = getUltimateAchievementGroupMap();
+  const short = clears
+    .filter((name) => groupMap.get(name as UltimateAchievementName) === group)
+    .map((name) => shortMap.get(name as UltimateAchievementName) ?? name);
+
+  return short.length > 0 ? short.join(" / ") : "なし";
+}
+
+/**
+ * 複数募集を空行区切りで整形します。
+ */
+export function formatListingsText(
+  listings: Listing[],
+  codeToShort: Map<string, string>,
+  codeToRole: Map<string, PartyRole>
+): string {
+  return listings.map((l) => formatListingText(l, codeToShort, codeToRole)).join("\n\n");
+}

package/src/runApp.ts

@@ -0,0 +1,119 @@
+import { loadJobsJa } from "./jobs";
+import { DEFAULT_WEBHOOK_LIMIT } from "./config";
+import { postDiscordWebhook, sleep, toDiscordCodeBlock } from "./discordWebhook";
+import { formatListingText, type PartyRole } from "./partyText";
+import type { Listing } from "./types";
+import type { ResolvedCliOptions } from "./envOptions";
+import { buildListings } from "./listingsPipeline";
+import {
+  loadListingSearchFilterFromFile,
+  matchListing,
+  type ListingSearchFilter
+} from "./searchFilter";
+import { createLogger, type Logger } from "./logger";
+import { buildJobMaps } from "./jobMaps";
+import { createLodestoneEnrichmentCache, enrichListingWithLodestone } from "./lodestoneEnrichment";
+
+function summarizeFilter(filter: ListingSearchFilter | undefined): Record<string, unknown> | undefined {
+  if (!filter) return undefined;
+  return { keys: Object.keys(filter) };
+}
+
+/**
+ * Discord Webhook に送信します（最大 `limit` 件、1募集=1メッセージ）。
+ */
+async function sendToDiscordWebhook(params: {
+  webhookUrl: string;
+  limit: number;
+  listings: Listing[];
+  codeToShort: Map<string, string>;
+  codeToRole: Map<string, PartyRole>;
+  searchFilter?: ListingSearchFilter;
+  logger?: Logger;
+}): Promise<number> {
+  const lodestoneCache = createLodestoneEnrichmentCache();
+
+  let sent = 0;
+  let scanned = 0;
+  let filteredOut = 0;
+  for (const listing of params.listings) {
+    if (sent >= params.limit) break;
+    scanned++;
+    const enriched = await enrichListingWithLodestone(listing, lodestoneCache);
+    const text = formatListingText(enriched, params.codeToShort, params.codeToRole);
+
+    const ok = await matchListing({
+      listing: enriched,
+      filter: params.searchFilter,
+      formattedText: text
+    });
+    if (!ok) {
+      filteredOut++;
+      continue;
+    }
+
+    const content = toDiscordCodeBlock(text);
+    await postDiscordWebhook(params.webhookUrl, content);
+    await sleep(350);
+    sent++;
+  }
+  params.logger?.info("send_summary", { scanned, filteredOut, sent, limit: params.limit });
+
+  if (sent === 0) {
+    const message = "該当の募集は見つかりませんでした";
+    await postDiscordWebhook(params.webhookUrl, message);
+    params.logger?.info("no_match", { posted: true });
+  }
+  return sent;
+}
+
+export type RunResult = { mode: "webhook"; sent: number };
+
+/**
+ * アプリのコア処理（CLI/Lambda共通）。
+ *
+ * - HTML 取得（ファイル or URL）
+ * - 募集一覧を抽出
+ * - DCフィルタ / クエリフィルタ
+ * - description タグを requirements に抽出
+ * - JSON/text 出力、または webhook 送信
+ */
+export async function runApp(options: ResolvedCliOptions): Promise<RunResult> {
+  const logger = createLogger("runApp");
+  const startAt = Date.now();
+
+  const fileFilter =
+    options.searchFilterFile ? await loadListingSearchFilterFromFile(options.searchFilterFile) : undefined;
+  const mergedSearchFilter = fileFilter ?? options.searchFilter;
+
+  logger.info("start", {
+    limit: options.limit,
+    filterFile: options.searchFilterFile,
+    filterLoaded: Boolean(fileFilter),
+    filterSummary: summarizeFilter(mergedSearchFilter)
+  });
+
+  const buildStartAt = Date.now();
+  const taggedListings = await buildListings({
+    input: options.input,
+    searchFilter: mergedSearchFilter
+  });
+  logger.info("listings_built", { count: taggedListings.length, ms: Date.now() - buildStartAt });
+
+  const jobsJa = await loadJobsJa();
+  const { codeToShort, codeToRole } = buildJobMaps(jobsJa.jobs);
+
+  const limit = options.limit ?? DEFAULT_WEBHOOK_LIMIT;
+  logger.info("send_start", { limit, candidates: taggedListings.length });
+  const sent = await sendToDiscordWebhook({
+    webhookUrl: options.webhookUrl,
+    limit,
+    listings: taggedListings,
+    codeToShort,
+    codeToRole,
+    searchFilter: mergedSearchFilter,
+    logger
+  });
+  logger.info("done", { sent, ms: Date.now() - startAt });
+  return { mode: "webhook", sent };
+}