@sorane/core 0.2.0

package/src/static-assets.ts

@@ -0,0 +1,198 @@
+import { copyFileSync, cpSync, existsSync, mkdirSync, readdirSync, statSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import {
+  loadAssetProvenance,
+  lookupAssetProvenance,
+  resolveC2paCreateIntent,
+} from "./asset-provenance.ts";
+import {
+  c2patoolAvailable,
+  isC2paRasterPath,
+  resolveC2paCredentials,
+  signRasterWithC2pa,
+  type C2paCredentials,
+} from "./c2pa-pass.ts";
+import {
+  embedIptcXmp,
+  exiftoolAvailable,
+  hasImageMetadataFields,
+  isImageMetadataPath,
+} from "./iptc-xmp-pass.ts";
+import type { MarkdownImageRef } from "./markdown-image-refs.ts";
+import type { C2paConfig, ImageMetadataConfig } from "./config.ts";
+
+export interface StaticAssetPassOptions {
+  readonly cwd: string;
+  readonly staticSrc: string;
+  readonly outDir: string;
+  readonly staticDirName: string;
+  readonly contentDir: string;
+  readonly c2pa?: C2paConfig;
+  readonly imageMetadata?: ImageMetadataConfig;
+  readonly skipC2pa?: boolean;
+  readonly inlineImages?: readonly MarkdownImageRef[];
+  readonly onWarning?: (message: string) => void;
+  readonly onProgress?: (message: string) => void;
+}
+
+export interface StaticAssetPassResult {
+  readonly rasterSigned: number;
+  readonly rasterCopied: number;
+  readonly metadataEmbedded: number;
+  readonly inlineImagesCopied: number;
+}
+
+function walkFiles(root: string): string[] {
+  const out: string[] = [];
+  function visit(dir: string): void {
+    for (const name of readdirSync(dir).sort()) {
+      const abs = join(dir, name);
+      if (statSync(abs).isDirectory()) visit(abs);
+      else out.push(abs);
+    }
+  }
+  visit(root);
+  return out;
+}
+
+export async function processStaticAssets(
+  opts: StaticAssetPassOptions,
+): Promise<StaticAssetPassResult> {
+  const warn = opts.onWarning ?? (() => {});
+  const log = opts.onProgress ?? (() => {});
+
+  const outRoot = join(opts.outDir, opts.staticDirName);
+  if (existsSync(opts.staticSrc)) {
+    cpSync(opts.staticSrc, outRoot, { recursive: true });
+  }
+
+  const provenance = loadAssetProvenance(
+    opts.contentDir,
+    opts.imageMetadata?.manifest,
+  );
+
+  const imageMetadataConfig = opts.imageMetadata;
+  const imageMetadataEnabled = imageMetadataConfig?.enabled === true;
+  const exiftoolBinary = imageMetadataConfig?.exiftool ?? "exiftool";
+  let exiftoolReady = false;
+  if (imageMetadataEnabled) {
+    if (exiftoolAvailable(exiftoolBinary)) {
+      exiftoolReady = true;
+    } else {
+      warn(
+        `image_metadata.enabled but ${exiftoolBinary} not found on PATH; static images copied without XMP`,
+      );
+    }
+  }
+
+  const c2paConfig = opts.c2pa;
+  const skipC2pa = opts.skipC2pa === true;
+  let credentials: C2paCredentials | null = null;
+  let c2paBinary = c2paConfig?.binary ?? "c2patool";
+
+  if (c2paConfig?.enabled === true && !skipC2pa) {
+    credentials = resolveC2paCredentials(c2paConfig);
+    if (!credentials) {
+      warn(
+        "c2pa.enabled but signing credentials missing (set certificate_path/private_key_path or SORANE_C2PA_CERT/SORANE_C2PA_KEY); static images copied unsigned",
+      );
+    } else if (!c2patoolAvailable(c2paBinary)) {
+      warn(`c2pa.enabled but ${c2paBinary} not found on PATH; static images copied unsigned`);
+      credentials = null;
+    }
+  }
+
+  let rasterSigned = 0;
+  let rasterCopied = 0;
+  let metadataEmbedded = 0;
+  let inlineImagesCopied = 0;
+
+  async function tagRaster(outAbs: string, hints: Parameters<typeof lookupAssetProvenance>[1]) {
+    const entry = lookupAssetProvenance(provenance, hints);
+    const relForLog =
+      typeof hints === "string"
+        ? hints
+        : (hints.publicPath ?? hints.staticRel ?? hints.markdownPath ?? "image");
+
+    if (exiftoolReady && isImageMetadataPath(outAbs) && hasImageMetadataFields(entry)) {
+      const embedded = embedIptcXmp(outAbs, entry!, { binary: exiftoolBinary });
+      if (embedded.ok) {
+        metadataEmbedded += 1;
+        log(`iptc-xmp: embedded metadata in ${relForLog}`);
+      } else {
+        warn(`iptc-xmp: failed to embed ${relForLog}: ${embedded.message ?? "unknown error"}`);
+      }
+    }
+
+    const relPath = typeof hints === "string" ? hints : hints.staticRel;
+    if (!relPath || !isC2paRasterPath(relPath)) return;
+    rasterCopied += 1;
+    if (!credentials) return;
+
+    const createIntent = resolveC2paCreateIntent(entry);
+    const signed = signRasterWithC2pa(
+      existsSync(outAbs) ? outAbs : join(opts.staticSrc, relPath),
+      outAbs,
+      {
+        binary: c2paBinary,
+        embed: c2paConfig?.embed !== false,
+        createIntent,
+        credentials,
+      },
+    );
+    if (signed.ok) {
+      rasterSigned += 1;
+      log(`c2pa: signed ${relForLog} (${createIntent})`);
+    } else {
+      warn(`c2pa: failed to sign ${relForLog}: ${signed.message ?? "unknown error"}`);
+    }
+  }
+
+  for (const ref of opts.inlineImages ?? []) {
+    if (ref.kind !== "content") continue;
+    const outAbs = join(opts.outDir, ref.outRel);
+    mkdirSync(dirname(outAbs), { recursive: true });
+    copyFileSync(ref.srcAbs, outAbs);
+    inlineImagesCopied += 1;
+    await tagRaster(outAbs, {
+      staticRel: ref.outRel,
+      markdownPath: ref.markdownPath,
+      publicPath: ref.publicPath,
+      contentRel: ref.publicPath,
+      sourceMdRel: ref.sourceMdRel,
+    });
+  }
+
+  if (!existsSync(opts.staticSrc)) {
+    if (metadataEmbedded > 0) log(`iptc-xmp: ${metadataEmbedded} image(s) tagged`);
+    if (rasterSigned > 0) log(`c2pa: ${rasterSigned} raster asset(s) signed`);
+    return { rasterSigned, rasterCopied, metadataEmbedded, inlineImagesCopied };
+  }
+
+  const inlineHintsBySrc = new Map<string, MarkdownImageRef>();
+  for (const ref of opts.inlineImages ?? []) {
+    if (!inlineHintsBySrc.has(ref.srcAbs)) inlineHintsBySrc.set(ref.srcAbs, ref);
+  }
+
+  for (const abs of walkFiles(opts.staticSrc)) {
+    const rel = relative(opts.staticSrc, abs).replace(/\\/g, "/");
+    const outPath = join(outRoot, rel);
+    const inline = inlineHintsBySrc.get(abs);
+    await tagRaster(outPath, {
+      staticRel: rel,
+      publicPath: `${opts.staticDirName}/${rel}`,
+      markdownPath: inline?.markdownPath,
+      sourceMdRel: inline?.sourceMdRel,
+      contentRel: inline?.publicPath,
+    });
+  }
+
+  if (metadataEmbedded > 0) {
+    log(`iptc-xmp: ${metadataEmbedded} image(s) tagged`);
+  }
+  if (rasterSigned > 0) {
+    log(`c2pa: ${rasterSigned} raster asset(s) signed`);
+  }
+
+  return { rasterSigned, rasterCopied, metadataEmbedded, inlineImagesCopied };
+}

package/src/theme-assets.ts

@@ -0,0 +1,16 @@
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+
+/** サイト cwd または親ディレクトリからテーマ資産サブディレクトリを探す。 */
+export function resolveThemeAssetDir(cwd: string, subdir: string): string | null {
+  const rel = join("templates", "default", "assets", subdir);
+  let dir = resolve(cwd);
+  for (let depth = 0; depth < 6; depth++) {
+    const candidate = join(dir, rel);
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}

package/src/validate-heading-structure.ts

@@ -0,0 +1,51 @@
+const FENCE_OPEN_RE = /^(```+|~~~+)/;
+const HEADING_RE = /^(#{1,6})\s+/;
+
+/** Markdown 本文の見出し階層を検査する（warning のみ）。 */
+export function validateHeadingWarnings(body: string): readonly string[] {
+  const warnings: string[] = [];
+  const lines = body.split(/\r?\n/);
+  let inFence = false;
+  let fenceMarker = "";
+  let prevLevel = 0;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]!;
+    const fence = FENCE_OPEN_RE.exec(line);
+    if (fence) {
+      const marker = fence[1]!;
+      if (!inFence) {
+        inFence = true;
+        fenceMarker = marker;
+      } else if (line.startsWith(fenceMarker)) {
+        inFence = false;
+        fenceMarker = "";
+      }
+      continue;
+    }
+    if (inFence) continue;
+
+    const hm = HEADING_RE.exec(line);
+    if (!hm) continue;
+    const level = hm[1]!.length;
+    const lineNo = i + 1;
+
+    if (level === 1) {
+      warnings.push(
+        `heading: h1 in body (line ${lineNo}); page title is already rendered as h1`,
+      );
+    }
+    if (prevLevel === 0 && level >= 3) {
+      warnings.push(
+        `heading: first heading in body is h${level} (line ${lineNo}); prefer starting with h2`,
+      );
+    } else if (prevLevel > 0 && level > prevLevel + 1) {
+      warnings.push(
+        `heading: skip from h${prevLevel} to h${level} (line ${lineNo})`,
+      );
+    }
+    prevLevel = level;
+  }
+
+  return warnings;
+}