@zenalexa/unicli 0.220.0 → 0.221.0

package/src/adapters/inpi-fr/get.yaml

@@ -0,0 +1,62 @@
+# @owner       src::adapters::inpi-fr::get
+# @does        Fetch a French patent record by publication number via the INPI public open-data API.
+# @needs       src/engine/steps/fetch.ts, src/engine/steps/map.ts
+# @feeds       src/commands/patent.ts
+# @breaks      throws PipelineError on 404 or 5xx; some legal-status / inventor fields require an INPI session-login this adapter does not perform
+# @invariants  output row conforms to PatentRecord
+# @side-effects HTTPS egress to api-recherche.inpi.fr
+# @perf        single request
+# @concurrency safe
+# @test        none yet
+# @stability   stable
+# @since       2026-05-18
+# @verification blocked-by-key — session-cookie auth not implemented; only the open public-record subset is reachable
+site: inpi-fr
+name: get
+description: Fetch a French patent record by publication number (open subset)
+domain: api.inpi.fr
+type: web-api
+strategy: public
+lint_listing_detail: skip
+
+args:
+  publication_number:
+    type: str
+    required: true
+    positional: true
+    description: French publication number (e.g. FR3098765)
+
+pipeline:
+  - fetch:
+      url: "https://api-recherche.inpi.fr/services/patents/${{ args.publication_number | urlencode }}"
+      method: GET
+      headers:
+        Accept: application/json
+
+  - map:
+      publication_number: "${{ 'FR-' + (item.publicationNumber || args.publication_number || '') + '-' + (item.kindCode || '') }}"
+      application_number: "${{ item.applicationNumber || '' }}"
+      title: "${{ item.title || item.titleFr || item.titleEn || '' }}"
+      abstract: "${{ item.abstract || item.abstractFr || item.abstractEn || '' }}"
+      kind_code: "${{ item.kindCode || '' }}"
+      filing_date: "${{ item.filingDate || item.applicationDate || '' }}"
+      publication_date: "${{ item.publicationDate || '' }}"
+      grant_date: "${{ item.grantDate || '' }}"
+      priority_date: "${{ item.priorityDate || '' }}"
+      legal_status: "${{ item.legalStatus || item.status || '' }}"
+      inventors: "${{ JSON.stringify((function(){ var i=item.inventors; if(!i) return []; var arr = Array.isArray(i) ? i : [i]; return arr.map(n => ({ name: typeof n === 'string' ? n : (n.name || n.fullName || ''), country: 'FR' })).filter(x => x.name); })()) }}"
+      assignees: "${{ JSON.stringify((function(){ var a=item.applicants || item.holders; if(!a) return []; var arr = Array.isArray(a) ? a : [a]; return arr.map(n => ({ name: typeof n === 'string' ? n : (n.name || n.fullName || ''), country: 'FR' })).filter(x => x.name); })()) }}"
+      classifications: "${{ JSON.stringify((function(){ var c=item.ipc || item.classifications; if(!c) return []; var arr = Array.isArray(c) ? c : [c]; return arr.map(x => ({ scheme: 'ipc', code: typeof x === 'string' ? x : (x.code || '') })).filter(x => x.code); })()) }}"
+      source_adapter: inpi-fr
+      source_url: "${{ 'https://data.inpi.fr/brevets/' + (args.publication_number || '') }}"
+      retrieved_at: ""
+
+columns: [publication_number, title, filing_date, publication_date]
+
+# schema-v2 metadata
+capabilities: ["http.fetch", "patent.get"]
+minimum_capability: http.fetch
+trust: public
+confidentiality: public
+quarantine: false
+schema_version: v2

package/src/adapters/inpi-fr/search.yaml

@@ -0,0 +1,74 @@
+# @owner       src::adapters::inpi-fr::search
+# @does        Search French patents (FR brevets) via the public INPI search API (open subset, no login).
+# @needs       src/engine/steps/fetch.ts, src/engine/steps/select.ts, src/engine/steps/map.ts, src/engine/steps/limit.ts
+# @feeds       src/commands/patent.ts
+# @breaks      throws PipelineError on 5xx or rate limit; INPI's full-feature endpoints require an authenticated session — this adapter implements only the public open-data subset
+# @invariants  output rows conform to PatentRecord; publication_number is `FR-<doc>-<kind>`
+# @side-effects HTTPS egress to api.inpi.fr / api-recherche.inpi.fr; no env reads
+# @perf        single request
+# @concurrency safe
+# @test        none yet
+# @stability   stable
+# @since       2026-05-18
+# @verification blocked-by-key — INPI public search API throttles anonymous traffic and the full record endpoints require a session cookie. Session-cookie login flow is not implemented in this adapter; the search endpoint exercised here is the open subset documented at data.inpi.fr.
+site: inpi-fr
+name: search
+description: Search French patents via the INPI public open-data search API
+domain: api.inpi.fr
+type: web-api
+strategy: public
+lint_listing_detail: skip
+
+args:
+  query:
+    type: str
+    required: true
+    positional: true
+    description: Free-text query
+  limit:
+    type: int
+    default: 25
+    description: Maximum results
+
+pipeline:
+  - fetch:
+      url: "https://api-recherche.inpi.fr/services/patents/search"
+      method: GET
+      headers:
+        Accept: application/json
+      params:
+        q: "${{ args.query }}"
+        nbResultsParPage: "${{ args.limit }}"
+        page: "1"
+
+  - select: results
+
+  # INPI open-data JSON; field names mirror INPI's documented schema.
+  - map:
+      publication_number: "${{ 'FR-' + (item.publicationNumber || item.applicationNumber || '') + '-' + (item.kindCode || '') }}"
+      application_number: "${{ item.applicationNumber || '' }}"
+      title: "${{ item.title || item.titleFr || item.titleEn || '' }}"
+      abstract: "${{ item.abstract || item.abstractFr || item.abstractEn || '' }}"
+      kind_code: "${{ item.kindCode || '' }}"
+      filing_date: "${{ item.filingDate || item.applicationDate || '' }}"
+      publication_date: "${{ item.publicationDate || '' }}"
+      grant_date: "${{ item.grantDate || '' }}"
+      priority_date: "${{ item.priorityDate || '' }}"
+      inventors: "${{ JSON.stringify((function(){ var i=item.inventors; if(!i) return []; var arr = Array.isArray(i) ? i : [i]; return arr.map(n => ({ name: typeof n === 'string' ? n : (n.name || n.fullName || ''), country: 'FR' })).filter(x => x.name); })()) }}"
+      assignees: "${{ JSON.stringify((function(){ var a=item.applicants || item.holders; if(!a) return []; var arr = Array.isArray(a) ? a : [a]; return arr.map(n => ({ name: typeof n === 'string' ? n : (n.name || n.fullName || ''), country: 'FR' })).filter(x => x.name); })()) }}"
+      classifications: "${{ JSON.stringify((function(){ var c=item.ipc || item.classifications; if(!c) return []; var arr = Array.isArray(c) ? c : [c]; return arr.map(x => ({ scheme: 'ipc', code: typeof x === 'string' ? x : (x.code || '') })).filter(x => x.code); })()) }}"
+      source_adapter: inpi-fr
+      source_url: "${{ 'https://data.inpi.fr/brevets/' + (item.publicationNumber || item.applicationNumber || '') }}"
+      retrieved_at: ""
+
+  - limit: "${{ args.limit }}"
+
+columns: [publication_number, title, filing_date, publication_date]
+
+# schema-v2 metadata
+capabilities: ["http.fetch", "patent.search"]
+minimum_capability: http.fetch
+trust: public
+confidentiality: public
+quarantine: false
+schema_version: v2

package/src/adapters/instagram/subtitles.ts

@@ -0,0 +1,44 @@
+/**
+ * @owner   Instagram subtitle adapter.
+ * @does    Extracts LLM-readable subtitle text from public Instagram reel and video URLs.
+ * @needs   `yt-dlp` on PATH and an accessible video subtitle track.
+ * @feeds   Cross-platform social video analysis workflows.
+ * @breaks  Instagram or yt-dlp extractor changes can alter subtitle availability.
+ */
+
+import { cli, Strategy } from "../../registry.js";
+import { runVideoSubtitleExtraction } from "../../social/video-text.js";
+
+cli({
+  site: "instagram",
+  name: "subtitles",
+  description:
+    "Extract LLM-readable subtitles from an Instagram reel or video URL with optional browser-cookie reuse",
+  domain: "www.instagram.com",
+  strategy: Strategy.PUBLIC,
+  args: [
+    {
+      name: "url",
+      type: "str",
+      required: true,
+      positional: true,
+      description: "Instagram reel or video URL",
+      format: "uri",
+    },
+    {
+      name: "languages",
+      type: "str",
+      default: "zh-Hans,zh,en",
+      description: "Comma-separated subtitle languages",
+    },
+    {
+      name: "cookies-from-browser",
+      type: "str",
+      description: "Browser name for yt-dlp --cookies-from-browser",
+    },
+  ],
+  columns: ["language", "text", "path"],
+  socialCapabilities: ["read", "media", "subtitles"],
+  defaultFormat: "json",
+  func: async (_page, kwargs) => runVideoSubtitleExtraction(kwargs),
+});

package/src/adapters/ipaustralia/get.yaml

@@ -0,0 +1,67 @@
+# @owner       src::adapters::ipaustralia::get
+# @does        Fetch an Australian patent record by application number via the IP Australia API portal.
+# @needs       src/engine/steps/fetch.ts, src/engine/steps/select-xml.ts, src/engine/steps/map.ts
+# @feeds       src/commands/patent.ts
+# @breaks      throws PipelineError on 401/403, 404, 5xx
+# @invariants  output row conforms to PatentRecord
+# @side-effects reads env IPAUSTRALIA_API_KEY; HTTPS egress to api.ipaustralia.gov.au
+# @perf        single request
+# @concurrency safe
+# @test        none yet
+# @stability   stable
+# @since       2026-05-18
+# @verification blocked-by-key
+site: ipaustralia
+name: get
+description: Fetch an Australian patent by application number
+domain: api.ipaustralia.gov.au
+type: web-api
+strategy: public
+lint_listing_detail: skip
+
+args:
+  application_number:
+    type: str
+    required: true
+    positional: true
+    description: Australian application number (e.g. 2023000123)
+
+pipeline:
+  - fetch:
+      url: "https://api.ipaustralia.gov.au/patents/v1/patent/${{ args.application_number | urlencode }}"
+      method: GET
+      headers:
+        Accept: application/xml
+        x-api-key: "${{ env.IPAUSTRALIA_API_KEY || '' }}"
+
+  - select-xml:
+      xpath: "//patent"
+      unwrap_single: true
+
+  - map:
+      publication_number: "${{ 'AU-' + (item.publicationNumber || args.application_number || '') + '-' + (item.kindCode || '') }}"
+      application_number: "${{ item.applicationNumber || args.application_number || '' }}"
+      title: "${{ item.title || item.inventionTitle || '' }}"
+      abstract: "${{ item.abstract || '' }}"
+      kind_code: "${{ item.kindCode || '' }}"
+      filing_date: "${{ item.filingDate || item.applicationDate || '' }}"
+      publication_date: "${{ item.publicationDate || '' }}"
+      grant_date: "${{ item.grantDate || '' }}"
+      priority_date: "${{ item.priorityDate || '' }}"
+      legal_status: "${{ item.legalStatus || item.status || '' }}"
+      inventors: "${{ JSON.stringify((function(){ var i=item.inventor || item.inventors; if(!i) return []; var arr = Array.isArray(i) ? i : [i]; return arr.map(n => ({ name: typeof n === 'string' ? n : (n.name || n.fullName || ''), country: 'AU' })).filter(x => x.name); })()) }}"
+      assignees: "${{ JSON.stringify((function(){ var a=item.applicant || item.applicants; if(!a) return []; var arr = Array.isArray(a) ? a : [a]; return arr.map(n => ({ name: typeof n === 'string' ? n : (n.name || n.fullName || ''), country: 'AU' })).filter(x => x.name); })()) }}"
+      classifications: "${{ JSON.stringify((function(){ var c=item.ipc || item.classifications; if(!c) return []; var arr = Array.isArray(c) ? c : [c]; return arr.map(x => ({ scheme: 'ipc', code: typeof x === 'string' ? x : (x.code || '') })).filter(x => x.code); })()) }}"
+      source_adapter: ipaustralia
+      source_url: "${{ 'https://search.ipaustralia.gov.au/patents/' + (args.application_number || '') }}"
+      retrieved_at: ""
+
+columns: [publication_number, title, filing_date, publication_date]
+
+# schema-v2 metadata
+capabilities: ["http.fetch", "patent.get"]
+minimum_capability: http.fetch
+trust: public
+confidentiality: public
+quarantine: false
+schema_version: v2

package/src/adapters/ipaustralia/search.yaml

@@ -0,0 +1,74 @@
+# @owner       src::adapters::ipaustralia::search
+# @does        Search Australian patents via the IP Australia API Portal (Open Data services).
+# @needs       src/engine/steps/fetch.ts, src/engine/steps/select-xml.ts, src/engine/steps/map.ts, src/engine/steps/limit.ts
+# @feeds       src/commands/patent.ts
+# @breaks      throws PipelineError on 401/403 (missing IPAUSTRALIA_API_KEY), 4xx, 5xx
+# @invariants  output rows conform to PatentRecord; publication_number is `AU-<doc>-<kind>`
+# @side-effects reads env IPAUSTRALIA_API_KEY; HTTPS egress to api.ipaustralia.gov.au
+# @perf        single request
+# @concurrency safe
+# @test        none yet
+# @stability   stable
+# @since       2026-05-18
+# @verification blocked-by-key — needs IPAUSTRALIA_API_KEY (free registration at api.ipaustralia.gov.au)
+site: ipaustralia
+name: search
+description: Search Australian patents via the IP Australia API portal
+domain: api.ipaustralia.gov.au
+type: web-api
+strategy: public
+lint_listing_detail: skip
+
+args:
+  query:
+    type: str
+    required: true
+    positional: true
+    description: Free-text query (title/abstract)
+  limit:
+    type: int
+    default: 25
+    description: Maximum results
+
+pipeline:
+  - fetch:
+      url: "https://api.ipaustralia.gov.au/patents/v1/search"
+      method: GET
+      headers:
+        Accept: application/xml
+        x-api-key: "${{ env.IPAUSTRALIA_API_KEY || '' }}"
+      params:
+        q: "${{ args.query }}"
+        size: "${{ args.limit }}"
+
+  - select-xml:
+      xpath: "//patent"
+
+  - map:
+      publication_number: "${{ 'AU-' + (item.publicationNumber || item.applicationNumber || '') + '-' + (item.kindCode || '') }}"
+      application_number: "${{ item.applicationNumber || '' }}"
+      title: "${{ item.title || item.inventionTitle || '' }}"
+      abstract: "${{ item.abstract || '' }}"
+      kind_code: "${{ item.kindCode || '' }}"
+      filing_date: "${{ item.filingDate || item.applicationDate || '' }}"
+      publication_date: "${{ item.publicationDate || '' }}"
+      grant_date: "${{ item.grantDate || '' }}"
+      priority_date: "${{ item.priorityDate || '' }}"
+      inventors: "${{ JSON.stringify((function(){ var i=item.inventor || item.inventors; if(!i) return []; var arr = Array.isArray(i) ? i : [i]; return arr.map(n => ({ name: typeof n === 'string' ? n : (n.name || n.fullName || ''), country: 'AU' })).filter(x => x.name); })()) }}"
+      assignees: "${{ JSON.stringify((function(){ var a=item.applicant || item.applicants; if(!a) return []; var arr = Array.isArray(a) ? a : [a]; return arr.map(n => ({ name: typeof n === 'string' ? n : (n.name || n.fullName || ''), country: 'AU' })).filter(x => x.name); })()) }}"
+      classifications: "${{ JSON.stringify((function(){ var c=item.ipc || item.classifications; if(!c) return []; var arr = Array.isArray(c) ? c : [c]; return arr.map(x => ({ scheme: 'ipc', code: typeof x === 'string' ? x : (x.code || '') })).filter(x => x.code); })()) }}"
+      source_adapter: ipaustralia
+      source_url: "${{ 'https://search.ipaustralia.gov.au/patents/' + (item.applicationNumber || '') }}"
+      retrieved_at: ""
+
+  - limit: "${{ args.limit }}"
+
+columns: [publication_number, title, filing_date, publication_date]
+
+# schema-v2 metadata
+capabilities: ["http.fetch", "patent.search"]
+minimum_capability: http.fetch
+trust: public
+confidentiality: public
+quarantine: false
+schema_version: v2

package/src/adapters/jikan/web.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from "vitest";
+import { resolveCommand } from "../../registry.js";
+import { mapJikanRows } from "./web.js";
+
+describe("jikan public commands", () => {
+  it("registers MAL search surfaces", () => {
+    expect(
+      Object.keys(resolveCommand("jikan", "anime")!.adapter.commands),
+    ).toEqual(
+      expect.arrayContaining(["anime", "manga", "characters", "people"]),
+    );
+  });
+
+  it("exposes year and sort controls for 2024-2026 media lookup", () => {
+    expect(resolveCommand("jikan", "anime")!.command.adapterArgs).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ name: "year", type: "int" }),
+        expect.objectContaining({
+          name: "sort",
+          choices: expect.arrayContaining(["score", "popularity", "recent"]),
+        }),
+      ]),
+    );
+  });
+
+  it("maps rows", () => {
+    expect(
+      mapJikanRows(
+        [
+          {
+            mal_id: 141632,
+            name: "Hanabi",
+            name_kanji: "花火",
+            favorites: 10,
+            url: "https://myanimelist.net/character/141632/Hanabi",
+          },
+        ],
+        "characters",
+      ),
+    ).toMatchObject([
+      {
+        rank: 1,
+        id: 141632,
+        kind: "characters",
+        title: "Hanabi",
+        title_japanese: "花火",
+      },
+    ]);
+  });
+});

package/src/adapters/jikan/web.ts

@@ -0,0 +1,177 @@
+/**
+ * @owner   src/adapters/jikan/web.ts
+ * @does    Register Jikan public MyAnimeList search commands for anime, manga, characters, and people.
+ * @needs   Jikan v4 public REST API and MAL entity URL formats.
+ * @feeds   ACG title, character, and creator discovery.
+ * @breaks  Jikan throttling or response field changes can block MyAnimeList-backed lookup.
+ */
+
+import { USER_AGENT } from "../../constants.js";
+import { cli, Strategy } from "../../registry.js";
+
+const API = "https://api.jikan.moe/v4";
+
+function str(value: unknown): string {
+  return value === undefined || value === null ? "" : String(value);
+}
+
+function required(value: unknown, label: string): string {
+  const text = str(value).trim();
+  if (!text) throw new Error(`jikan ${label} cannot be empty.`);
+  return text;
+}
+
+function requireLimit(value: unknown): number {
+  if (value === undefined || value === null || value === "") return 10;
+  const n = Number(value);
+  if (!Number.isInteger(n) || n < 1 || n > 25) {
+    throw new Error("jikan limit must be an integer in [1, 25].");
+  }
+  return n;
+}
+
+function optionalYear(value: unknown): number | undefined {
+  if (value === undefined || value === null || value === "") return undefined;
+  const n = Number(value);
+  if (!Number.isInteger(n) || n < 1900 || n > 2100) {
+    throw new Error("jikan year must be an integer in [1900, 2100].");
+  }
+  return n;
+}
+
+const SORTS: Record<string, { orderBy: string; direction: string }> = {
+  score: { orderBy: "score", direction: "desc" },
+  popularity: { orderBy: "popularity", direction: "asc" },
+  recent: { orderBy: "start_date", direction: "desc" },
+  relevance: { orderBy: "", direction: "" },
+};
+
+function sortSpec(value: unknown): { orderBy: string; direction: string } {
+  const key = String(value ?? "relevance").trim();
+  const spec = SORTS[key];
+  if (!spec) {
+    throw new Error(
+      `jikan sort must be one of: ${Object.keys(SORTS).join(", ")}.`,
+    );
+  }
+  return spec;
+}
+
+async function fetchJikan(
+  path: string,
+  query: string,
+  limit: number,
+  kwargs: Record<string, unknown>,
+): Promise<unknown[]> {
+  const url = new URL(`${API}/${path}`);
+  url.searchParams.set("q", query);
+  url.searchParams.set("limit", String(limit));
+  if (path === "anime" || path === "manga") {
+    const year = optionalYear(kwargs.year);
+    if (year) {
+      url.searchParams.set("start_date", `${year}-01-01`);
+      url.searchParams.set("end_date", `${year}-12-31`);
+    }
+    const sort = sortSpec(kwargs.sort);
+    if (sort.orderBy) {
+      url.searchParams.set("order_by", sort.orderBy);
+      url.searchParams.set("sort", sort.direction);
+    }
+  }
+  const response = await fetch(url, {
+    headers: { Accept: "application/json", "User-Agent": USER_AGENT },
+  });
+  if (!response.ok)
+    throw new Error(`jikan request failed with HTTP ${response.status}.`);
+  const data = (await response.json()) as { data?: unknown[] };
+  return data.data ?? [];
+}
+
+export function mapJikanRows(
+  rows: unknown[],
+  kind: string,
+): Record<string, unknown>[] {
+  return rows.map((row, index) => {
+    const item = row as Record<string, unknown>;
+    const images = item.images as { jpg?: { image_url?: string } } | undefined;
+    return {
+      rank: index + 1,
+      id: item.mal_id ?? null,
+      kind,
+      title: str(item.title ?? item.name),
+      title_japanese: str(item.title_japanese ?? item.name_kanji),
+      type: str(item.type),
+      score: item.score ?? null,
+      members: item.members ?? item.favorites ?? null,
+      url: str(item.url),
+      image: str(images?.jpg?.image_url),
+    };
+  });
+}
+
+async function search(
+  kind: "anime" | "manga" | "characters" | "people",
+  kwargs: Record<string, unknown>,
+) {
+  const query = required(kwargs.query, "query");
+  const cap = requireLimit(kwargs.limit);
+  const rows = mapJikanRows(await fetchJikan(kind, query, cap, kwargs), kind);
+  if (rows.length === 0)
+    throw new Error(`No Jikan ${kind} found for "${query}".`);
+  return rows;
+}
+
+const ENTITY_ARGS = [
+  { name: "query", type: "str" as const, required: true, positional: true },
+  { name: "limit", type: "int" as const, default: 10 },
+];
+const MEDIA_ARGS = [
+  { name: "query", type: "str" as const, required: true, positional: true },
+  { name: "limit", type: "int" as const, default: 10 },
+  { name: "year", type: "int" as const },
+  {
+    name: "sort",
+    type: "str" as const,
+    default: "relevance",
+    choices: ["relevance", "score", "popularity", "recent"],
+  },
+];
+const COLUMNS = [
+  "rank",
+  "id",
+  "kind",
+  "title",
+  "title_japanese",
+  "type",
+  "score",
+  "members",
+  "url",
+];
+
+for (const name of ["anime", "manga"] as const) {
+  cli({
+    site: "jikan",
+    name,
+    description: `Search MyAnimeList ${name} through Jikan by Japanese name, romaji, or alias`,
+    domain: "api.jikan.moe",
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: MEDIA_ARGS,
+    columns: COLUMNS,
+    func: async (_page, kwargs) => search(name, kwargs),
+  });
+}
+
+for (const name of ["characters", "people"] as const) {
+  cli({
+    site: "jikan",
+    name,
+    description: `Search MyAnimeList ${name} through Jikan by Japanese name, romaji, or alias`,
+    domain: "api.jikan.moe",
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: ENTITY_ARGS,
+    columns: COLUMNS,
+    func: async (_page, kwargs) => search(name, kwargs),
+  });
+}

package/src/adapters/jpo/get.yaml

@@ -0,0 +1,63 @@
+# @owner       src::adapters::jpo::get
+# @does        Fetch a single Japanese patent record from JPO Patent Information Retrieval API by application number.
+# @needs       src/engine/steps/fetch.ts, src/engine/steps/map.ts
+# @feeds       src/commands/patent.ts
+# @breaks      throws PipelineError on 401/403, 404, 5xx
+# @invariants  output row conforms to PatentRecord
+# @side-effects reads env JPO_API_TOKEN; HTTPS egress to ip-data.jpo.go.jp
+# @perf        single request
+# @concurrency safe
+# @test        none yet
+# @stability   stable
+# @since       2026-05-18
+# @verification blocked-by-key
+site: jpo
+name: get
+description: Fetch a JPO application by application number
+domain: ip-data.jpo.go.jp
+type: web-api
+strategy: public
+lint_listing_detail: skip
+
+args:
+  application_number:
+    type: str
+    required: true
+    positional: true
+    description: JPO application number (e.g. 特願2024-012345 numeric form 2024012345)
+
+pipeline:
+  - fetch:
+      url: "https://ip-data.jpo.go.jp/api/v2/patent/applications/${{ args.application_number | urlencode }}"
+      method: GET
+      headers:
+        Accept: application/json
+        Authorization: "Bearer ${{ env.JPO_API_TOKEN || '' }}"
+
+  - map:
+      publication_number: "${{ 'JP-' + (item.publicationNumber || item.applicationNumber || '') + '-' + (item.publicationKindCode || '') }}"
+      application_number: "${{ item.applicationNumber || args.application_number || '' }}"
+      title: "${{ item.inventionTitleJapanese || item.inventionTitleEnglish || '' }}"
+      abstract: "${{ item.abstractJapanese || item.abstractEnglish || '' }}"
+      kind_code: "${{ item.publicationKindCode || '' }}"
+      filing_date: "${{ item.applicationDate || '' }}"
+      publication_date: "${{ item.publicationDate || '' }}"
+      grant_date: "${{ item.registrationDate || '' }}"
+      priority_date: "${{ item.priorityDate || '' }}"
+      legal_status: "${{ item.statusDescription || item.status || '' }}"
+      inventors: "${{ JSON.stringify((function(){ var i=item.inventorName; if(!i) return []; var arr = Array.isArray(i) ? i : [i]; return arr.map(n => ({ name: typeof n === 'string' ? n : (n.name || ''), country: 'JP' })).filter(x => x.name); })()) }}"
+      assignees: "${{ JSON.stringify((function(){ var a=item.applicantName; if(!a) return []; var arr = Array.isArray(a) ? a : [a]; return arr.map(n => ({ name: typeof n === 'string' ? n : (n.name || ''), country: 'JP' })).filter(x => x.name); })()) }}"
+      classifications: "${{ JSON.stringify((function(){ var c=item.ipcClassification; if(!c) return []; var arr = Array.isArray(c) ? c : [c]; return arr.map(x => ({ scheme: 'ipc', code: typeof x === 'string' ? x : (x.code || '') })).filter(x => x.code); })()) }}"
+      source_adapter: jpo
+      source_url: "${{ 'https://www.j-platpat.inpit.go.jp/p0200' }}"
+      retrieved_at: ""
+
+columns: [publication_number, title, filing_date, publication_date]
+
+# schema-v2 metadata
+capabilities: ["http.fetch", "patent.get"]
+minimum_capability: http.fetch
+trust: public
+confidentiality: public
+quarantine: false
+schema_version: v2