@sorane/core 0.2.0

package/src/c2pa-pass.ts

@@ -0,0 +1,116 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import type { C2paConfig } from "./config.ts";
+
+export interface C2paCredentials {
+  readonly signCert: string;
+  readonly privateKey: string;
+  readonly settingsPath?: string;
+}
+
+export interface SignRasterOptions {
+  readonly binary?: string;
+  readonly embed?: boolean;
+  readonly createIntent: string;
+  readonly credentials: C2paCredentials;
+}
+
+const RASTER_RE = /\.(jpe?g|png)$/i;
+
+export function isC2paRasterPath(filePath: string): boolean {
+  return RASTER_RE.test(filePath);
+}
+
+export function resolveC2paCredentials(
+  config: C2paConfig | undefined,
+): C2paCredentials | null {
+  if (config?.enabled !== true) return null;
+
+  const signCert =
+    config.certificate_path ??
+    process.env.SORANE_C2PA_CERT ??
+    process.env.C2PA_SIGN_CERT;
+  const privateKey =
+    config.private_key_path ??
+    process.env.SORANE_C2PA_KEY ??
+    process.env.C2PA_PRIVATE_KEY;
+
+  if (!signCert || !privateKey) return null;
+  if (!existsSync(signCert) || !existsSync(privateKey)) return null;
+
+  return {
+    signCert,
+    privateKey,
+    settingsPath: config.settings_path,
+  };
+}
+
+/** c2patool 0.26+ 向けの署名環境（settings ファイルまたは PEM 環境変数）。 */
+function buildSigningEnv(creds: C2paCredentials): NodeJS.ProcessEnv {
+  const env = { ...process.env };
+  if (creds.settingsPath && existsSync(creds.settingsPath)) {
+    env.C2PATOOL_SETTINGS = creds.settingsPath;
+    return env;
+  }
+  env.C2PA_PRIVATE_KEY = readFileSync(creds.privateKey, "utf8");
+  env.C2PA_SIGN_CERT = readFileSync(creds.signCert, "utf8");
+  delete env.C2PATOOL_SETTINGS;
+  return env;
+}
+
+/** c2patool でラスタ画像に C2PA manifest を埋め込む。失敗時は false。 */
+export function signRasterWithC2pa(
+  inputPath: string,
+  outputPath: string,
+  opts: SignRasterOptions,
+): { readonly ok: boolean; readonly message?: string } {
+  const binary = opts.binary ?? "c2patool";
+  const env = buildSigningEnv(opts.credentials);
+
+  const args = [
+    inputPath,
+    "-c",
+    '{"assertions":[]}',
+    "--create",
+    opts.createIntent,
+    "-o",
+    outputPath,
+    "-f",
+    "--no_signing_verify",
+  ];
+  if (opts.embed === false) args.push("-s");
+
+  const result = spawnSync(binary, args, {
+    env,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+
+  if (result.status !== 0) {
+    const msg = (result.stderr || result.stdout || "").trim();
+    return { ok: false, message: msg.length > 0 ? msg : `c2patool exited ${result.status}` };
+  }
+  return { ok: true };
+}
+
+/** 出力画像に C2PA manifest があるか簡易確認（c2patool --info）。 */
+export function probeC2paManifest(
+  filePath: string,
+  binary = "c2patool",
+): boolean {
+  const result = spawnSync(binary, [filePath, "--info"], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  if (result.status !== 0) return false;
+  const out = `${result.stdout}\n${result.stderr}`;
+  return /manifest|validated|active manifest/i.test(out);
+}
+
+export function c2patoolAvailable(binary = "c2patool"): boolean {
+  const result = spawnSync(binary, ["--version"], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  return result.status === 0;
+}

package/src/catalog.ts

@@ -0,0 +1,61 @@
+import type { OkfConcept } from "@sorane/okf";
+import { parseAiDisclosure } from "./ai-disclosure.ts";
+
+export interface CatalogEntry {
+  readonly slug: string;
+  readonly url: string;
+  readonly concept: OkfConcept;
+}
+
+export function buildCatalogJsonLd(
+  entries: readonly CatalogEntry[],
+  siteTitle: string,
+  baseUrl: string,
+  opts?: { readonly machineReadable?: boolean },
+): string {
+  const machineReadable = opts?.machineReadable !== false;
+  const graph = entries.map((e) => {
+    const dataset: Record<string, unknown> = {
+      "@type": "Dataset",
+      "@id": e.url,
+      name: e.concept.title,
+      keywords: [e.concept.type, ...(e.concept.tags ?? [])],
+      distribution: [
+        {
+          "@type": "DataDownload",
+          encodingFormat: "text/markdown",
+          contentUrl: `${e.url.replace(/\.html$/, ".md")}`,
+        },
+      ],
+    };
+    if (e.concept.description) dataset.description = e.concept.description;
+    if (e.concept.timestamp) dataset.dateModified = e.concept.timestamp;
+    const disclosure = machineReadable
+      ? parseAiDisclosure(e.concept.frontmatter)
+      : null;
+    if (disclosure) {
+      dataset.digitalSourceType = disclosure.digitalSourceType;
+      if (disclosure.systems?.length) {
+        const kw = dataset.keywords as string[];
+        dataset.keywords = [
+          ...kw,
+          ...disclosure.systems.map((s) => `ai-system:${s.name}`),
+        ];
+      }
+    }
+    return dataset;
+  });
+
+  const catalog = {
+    "@context": {
+      "@vocab": "https://schema.org/",
+      dcat: "http://www.w3.org/ns/dcat#",
+    },
+    "@type": "DataCatalog",
+    name: siteTitle,
+    url: baseUrl.length > 0 ? baseUrl : undefined,
+    dataset: graph,
+  };
+
+  return JSON.stringify(catalog, null, 2) + "\n";
+}

package/src/config.ts

@@ -0,0 +1,255 @@
+export interface FontSourceSpec {
+  readonly source: string;
+  readonly weight?: string;
+  readonly embed?: "subset" | "static";
+}
+
+export interface FontRoles {
+  readonly body: readonly string[];
+  readonly heading?: readonly string[];
+  readonly code?: readonly string[];
+}
+
+export type FeaturedMode = "excerpt" | "full" | "off";
+
+export interface BlogBuildConfig {
+  /** 1ページあたりの記事数（page/N.html） */
+  readonly page_size?: number;
+  /** トップ index のアーカイブ欄に載せる件数（既定 15） */
+  readonly index_archive_limit?: number;
+  /** トップの最新記事表示: excerpt | full | off */
+  readonly featured_mode?: FeaturedMode;
+  /** featured_mode: excerpt の最大文字数 */
+  readonly excerpt_length?: number;
+  /** アーカイブリストに description を出す */
+  readonly show_list_descriptions?: boolean;
+  /** archive/index.html, archive/YYYY.html 等を生成 */
+  readonly archives?: boolean;
+  /** tag/slug.html を生成 */
+  readonly tags?: boolean;
+}
+
+export type SearchMode = "fts" | "hybrid";
+
+export interface SearchConfig {
+  /** fts（標準）| hybrid（experimental・要埋め込みモデル） */
+  readonly mode?: SearchMode;
+  /** FTS インデックスの出力先（既定: .sorane/index.db） */
+  readonly index?: string;
+  /** 埋め込みモデル root（既定: vendor/models） */
+  readonly model?: string;
+  /** モデル ID（既定: ruri-v3-30m） */
+  readonly model_id?: string;
+  /** 大容量検索資産の配信元（R2 等）。末尾 "/" 推奨。空なら同一オリジン。 */
+  readonly asset_base_url?: string;
+  /** dist に ONNX モデルを同梱する（Pages 25MiB 制限のため本番では false 推奨） */
+  readonly bundle_model?: boolean;
+}
+
+export type DocsNavSpec = string | { readonly href: string; readonly title?: string };
+
+export interface DocsConfig {
+  /** ドキュメントサイトのサイドバー順（href は dist 基準、例: getting-started.html） */
+  readonly nav?: readonly DocsNavSpec[];
+}
+
+export type MermaidMode = "client" | "build" | "off";
+
+export interface DiagramsConfig {
+  readonly enabled?: boolean;
+  readonly mermaid?: {
+    readonly mode?: MermaidMode;
+    readonly version?: string;
+    readonly mmdc?: string;
+  };
+  readonly d2?: {
+    readonly enabled?: boolean;
+    readonly binary?: string;
+  };
+  readonly graphviz?: {
+    readonly enabled?: boolean;
+    readonly binary?: string;
+  };
+}
+
+export const DEFAULT_DIAGRAMS_CONFIG: Required<DiagramsConfig> = {
+  enabled: true,
+  mermaid: { mode: "client", version: "~11.15.0", mmdc: "mmdc" },
+  d2: { enabled: false, binary: "d2" },
+  graphviz: { enabled: false, binary: "dot" },
+};
+
+export interface ImageMetadataConfig {
+  readonly enabled?: boolean;
+  readonly exiftool?: string;
+  /** 既定: content/asset-provenance.yaml */
+  readonly manifest?: string;
+}
+
+export interface C2paConfig {
+  readonly enabled?: boolean;
+  /** 既定 true（埋め込み）。false は sidecar .c2pa（開発用） */
+  readonly embed?: boolean;
+  readonly binary?: string;
+  readonly certificate_path?: string;
+  readonly private_key_path?: string;
+  readonly settings_path?: string;
+}
+
+export interface AiDisclosureConfig {
+  readonly enabled?: boolean;
+  readonly badges?: boolean;
+  readonly json_ld?: boolean;
+  readonly machine_readable?: boolean;
+  readonly atom?: boolean;
+  readonly show_on_lists?: boolean;
+  readonly policy_url?: string;
+}
+
+export interface FontConfigInput {
+  readonly enabled?: boolean;
+  readonly family?: string;
+  readonly source?: string;
+  readonly cache_dir?: string;
+  readonly weight?: string;
+  readonly skip_key?: string;
+  readonly roles?: FontRoles;
+  readonly sources?: Readonly<Record<string, FontSourceSpec>>;
+}
+
+export interface SoraneConfig {
+  readonly site: {
+    readonly title: string;
+    readonly description: string;
+    readonly base_url: string;
+    readonly lang: string;
+    /** 既定の OGP 画像（絶対 URL またはサイトルート相対パス。要 base_url） */
+    readonly og_image?: string;
+  };
+  readonly build: {
+    readonly content_dir: string;
+    readonly out_dir: string;
+    readonly permalink: string;
+    /** 存在すれば out_dir へ再帰コピーする静的資産ディレクトリ（例: static/）。 */
+    readonly static_dir?: string;
+    readonly blog?: BlogBuildConfig;
+    readonly ai_disclosure?: AiDisclosureConfig;
+    readonly diagrams?: DiagramsConfig;
+    readonly image_metadata?: ImageMetadataConfig;
+    readonly c2pa?: C2paConfig;
+  };
+  readonly fonts: {
+    readonly enabled: boolean;
+    readonly cache_dir: string;
+    readonly skip_key: string;
+    readonly family?: string;
+    readonly source?: string;
+    readonly weight?: string;
+    readonly roles?: FontRoles;
+    readonly sources?: Readonly<Record<string, FontSourceSpec>>;
+  };
+  readonly search: SearchConfig & {
+    readonly mode: SearchMode;
+    readonly index: string;
+    readonly model: string;
+    readonly model_id: string;
+    readonly asset_base_url: string;
+  };
+  readonly docs?: DocsConfig;
+}
+
+export const DEFAULT_CONFIG: SoraneConfig = {
+  site: {
+    title: "Sorane Site",
+    description: "OKF-native static site",
+    base_url: "",
+    lang: "ja",
+  },
+  build: {
+    content_dir: "content",
+    out_dir: "dist",
+    permalink: "{{slug}}.html",
+    blog: {
+      page_size: 50,
+      index_archive_limit: 15,
+      featured_mode: "excerpt",
+      excerpt_length: 400,
+      show_list_descriptions: false,
+      archives: true,
+      tags: true,
+    },
+    ai_disclosure: {},
+    diagrams: DEFAULT_DIAGRAMS_CONFIG,
+    image_metadata: {},
+    c2pa: { enabled: false, embed: true, binary: "c2patool" },
+  },
+  fonts: {
+    enabled: false,
+    family: "Sorane-Subset",
+    source: "assets/fonts/source.ttf",
+    cache_dir: ".sorane/cache/fonts",
+    weight: "450",
+    skip_key: "noFontEmbedding",
+  },
+  search: {
+    mode: "fts",
+    index: ".sorane/index.db",
+    model: "vendor/models",
+    model_id: "ruri-v3-30m",
+    asset_base_url: "",
+    bundle_model: true,
+  },
+};
+
+export function mergeConfig(partial: Partial<SoraneConfig>): SoraneConfig {
+  return {
+    site: { ...DEFAULT_CONFIG.site, ...partial.site },
+    build: {
+      ...DEFAULT_CONFIG.build,
+      ...partial.build,
+      blog: { ...DEFAULT_CONFIG.build.blog, ...partial.build?.blog },
+      ai_disclosure: partial.build?.ai_disclosure
+        ? { ...DEFAULT_CONFIG.build.ai_disclosure, ...partial.build.ai_disclosure }
+        : DEFAULT_CONFIG.build.ai_disclosure,
+      diagrams: partial.build?.diagrams
+        ? {
+            ...DEFAULT_DIAGRAMS_CONFIG,
+            ...partial.build.diagrams,
+            mermaid: {
+              ...DEFAULT_DIAGRAMS_CONFIG.mermaid,
+              ...partial.build.diagrams.mermaid,
+            },
+            d2: {
+              ...DEFAULT_DIAGRAMS_CONFIG.d2,
+              ...partial.build.diagrams.d2,
+            },
+            graphviz: {
+              ...DEFAULT_DIAGRAMS_CONFIG.graphviz,
+              ...partial.build.diagrams.graphviz,
+            },
+          }
+        : DEFAULT_DIAGRAMS_CONFIG,
+      image_metadata: partial.build?.image_metadata
+        ? { ...DEFAULT_CONFIG.build.image_metadata, ...partial.build.image_metadata }
+        : DEFAULT_CONFIG.build.image_metadata,
+      c2pa: partial.build?.c2pa
+        ? { ...DEFAULT_CONFIG.build.c2pa, ...partial.build.c2pa }
+        : DEFAULT_CONFIG.build.c2pa,
+    },
+    fonts: { ...DEFAULT_CONFIG.fonts, ...partial.fonts },
+    search: { ...DEFAULT_CONFIG.search, ...partial.search },
+    docs: partial.docs ? { nav: partial.docs.nav } : undefined,
+  };
+}
+
+/** permalink テンプレートから出力 HTML ファイル名を決める。 */
+export function resolvePermalink(
+  template: string,
+  slug: string,
+  timestamp?: string,
+): string {
+  const date = timestamp?.slice(0, 10) ?? "";
+  return template
+    .replace(/\{\{slug\}\}/g, slug)
+    .replace(/\{\{date\}\}/g, date);
+}

package/src/diagrams/compile-d2.ts

@@ -0,0 +1,70 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import type { DiagramsConfig } from "../config.ts";
+import { diagramSourceHash } from "./diagram-hash.ts";
+
+const execFileAsync = promisify(execFile);
+
+/** @deprecated Use diagramSourceHash */
+export function d2SourceHash(source: string): string {
+  return diagramSourceHash(source);
+}
+
+export function isD2CompileEnabled(config?: DiagramsConfig): boolean {
+  return config?.enabled !== false && config?.d2?.enabled === true;
+}
+
+export function resolveD2Binary(config: DiagramsConfig): string {
+  return config.d2?.binary ?? "d2";
+}
+
+export interface CompileD2Options {
+  readonly source: string;
+  readonly binary: string;
+  readonly outDir: string;
+}
+
+export interface CompileD2Result {
+  readonly hash: string;
+  readonly svgFileName: string;
+  readonly ok: boolean;
+  readonly warning?: string;
+}
+
+export async function compileD2ToSvg(opts: CompileD2Options): Promise<CompileD2Result> {
+  const hash = diagramSourceHash(opts.source);
+  const svgFileName = `${hash}.svg`;
+  const dest = join(opts.outDir, svgFileName);
+  mkdirSync(opts.outDir, { recursive: true });
+
+  if (existsSync(dest)) {
+    return { hash, svgFileName, ok: true };
+  }
+
+  const tmpDir = mkdtempSync(join(tmpdir(), "sorane-d2-"));
+  try {
+    const input = join(tmpDir, "diagram.d2");
+    const output = join(tmpDir, "diagram.svg");
+    writeFileSync(input, opts.source, "utf8");
+    await execFileAsync(opts.binary, ["--layout", "elk", input, output], {
+      timeout: 120_000,
+    });
+    writeFileSync(dest, readFileSync(output), "utf8");
+    return { hash, svgFileName, ok: true };
+  } catch (err) {
+    const warning = err instanceof Error ? err.message : String(err);
+    return { hash, svgFileName, ok: false, warning };
+  } finally {
+    rmSync(tmpDir, { recursive: true, force: true });
+  }
+}

package/src/diagrams/compile-graphviz.ts

@@ -0,0 +1,71 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import type { DiagramsConfig } from "../config.ts";
+import { diagramSourceHash } from "./diagram-hash.ts";
+
+const execFileAsync = promisify(execFile);
+
+export function isGraphvizCompileEnabled(config?: DiagramsConfig): boolean {
+  return config?.enabled !== false && config?.graphviz?.enabled === true;
+}
+
+export function resolveGraphvizBinary(config: DiagramsConfig): string {
+  return config.graphviz?.binary ?? "dot";
+}
+
+export function isGraphvizLang(lang: string | null | undefined): boolean {
+  return lang === "graphviz" || lang === "dot";
+}
+
+export interface CompileGraphvizOptions {
+  readonly source: string;
+  readonly binary: string;
+  readonly outDir: string;
+}
+
+export interface CompileGraphvizResult {
+  readonly hash: string;
+  readonly svgFileName: string;
+  readonly ok: boolean;
+  readonly warning?: string;
+}
+
+export async function compileGraphvizToSvg(
+  opts: CompileGraphvizOptions,
+): Promise<CompileGraphvizResult> {
+  const hash = diagramSourceHash(opts.source);
+  const svgFileName = `${hash}.svg`;
+  const dest = join(opts.outDir, svgFileName);
+  mkdirSync(opts.outDir, { recursive: true });
+
+  if (existsSync(dest)) {
+    return { hash, svgFileName, ok: true };
+  }
+
+  const tmpDir = mkdtempSync(join(tmpdir(), "sorane-dot-"));
+  try {
+    const input = join(tmpDir, "diagram.dot");
+    const output = join(tmpDir, "diagram.svg");
+    writeFileSync(input, opts.source, "utf8");
+    await execFileAsync(opts.binary, ["-Tsvg", input, "-o", output], {
+      timeout: 120_000,
+    });
+    writeFileSync(dest, readFileSync(output), "utf8");
+    return { hash, svgFileName, ok: true };
+  } catch (err) {
+    const warning = err instanceof Error ? err.message : String(err);
+    return { hash, svgFileName, ok: false, warning };
+  } finally {
+    rmSync(tmpDir, { recursive: true, force: true });
+  }
+}

package/src/diagrams/compile-mermaid.ts

@@ -0,0 +1,102 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+import { tmpdir } from "node:os";
+import { createRequire } from "node:module";
+import type { DiagramsConfig } from "../config.ts";
+import { diagramSourceHash } from "./diagram-hash.ts";
+
+const execFileAsync = promisify(execFile);
+const require = createRequire(import.meta.url);
+
+export function isMermaidBuildEnabled(config?: DiagramsConfig): boolean {
+  return config?.enabled !== false && config?.mermaid?.mode === "build";
+}
+
+export function resolveMmdcBinary(config: DiagramsConfig): string {
+  const configured = config.mermaid?.mmdc;
+  if (configured && configured.length > 0 && configured !== "mmdc") return configured;
+  const candidates = [
+    join(process.cwd(), "node_modules", ".bin", "mmdc"),
+    (() => {
+      try {
+        const pkgPath = require.resolve("@mermaid-js/mermaid-cli/package.json");
+        return join(dirname(pkgPath), "node_modules", ".bin", "mmdc");
+      } catch {
+        return "";
+      }
+    })(),
+    (() => {
+      try {
+        return require.resolve("@mermaid-js/mermaid-cli/src/cli.js");
+      } catch {
+        return "";
+      }
+    })(),
+  ];
+  for (const candidate of candidates) {
+    if (candidate.length > 0 && existsSync(candidate)) return candidate;
+  }
+  return configured && configured.length > 0 ? configured : "mmdc";
+}
+
+export interface CompileMermaidOptions {
+  readonly source: string;
+  readonly binary: string;
+  readonly outDir: string;
+}
+
+export interface CompileMermaidResult {
+  readonly hash: string;
+  readonly svgFileName: string;
+  readonly ok: boolean;
+  readonly warning?: string;
+}
+
+const MERMAID_CONFIG = {
+  securityLevel: "strict",
+  deterministicIds: true,
+  deterministicIDSeed: "sorane",
+};
+
+export async function compileMermaidToSvg(
+  opts: CompileMermaidOptions,
+): Promise<CompileMermaidResult> {
+  const hash = diagramSourceHash(opts.source);
+  const svgFileName = `${hash}.svg`;
+  const dest = join(opts.outDir, svgFileName);
+  mkdirSync(opts.outDir, { recursive: true });
+
+  if (existsSync(dest)) {
+    return { hash, svgFileName, ok: true };
+  }
+
+  const tmpDir = mkdtempSync(join(tmpdir(), "sorane-mmdc-"));
+  try {
+    const input = join(tmpDir, "diagram.mmd");
+    const output = join(tmpDir, "diagram.svg");
+    const configPath = join(tmpDir, "mermaidConfig.json");
+    writeFileSync(input, opts.source, "utf8");
+    writeFileSync(configPath, JSON.stringify(MERMAID_CONFIG), "utf8");
+    await execFileAsync(
+      opts.binary,
+      ["-i", input, "-o", output, "-c", configPath, "--quiet"],
+      { timeout: 180_000 },
+    );
+    writeFileSync(dest, readFileSync(output), "utf8");
+    return { hash, svgFileName, ok: true };
+  } catch (err) {
+    const warning = err instanceof Error ? err.message : String(err);
+    return { hash, svgFileName, ok: false, warning };
+  } finally {
+    rmSync(tmpDir, { recursive: true, force: true });
+  }
+}

package/src/diagrams/diagram-hash.ts

@@ -0,0 +1,5 @@
+import { createHash } from "node:crypto";
+
+export function diagramSourceHash(source: string): string {
+  return createHash("sha256").update(source, "utf8").digest("hex");
+}