obsidian-foundry-sync/scripts/import-missing.ts

#!/usr/bin/env tsx
/**
 * Foundry -> vault: create "unlinked items" — Foundry Campaign Codex entries that
 * have no vault counterpart — as new refined notes (with the foundry: identity block,
 * since entryToObsidian embeds it, so they're immediately pushable). Reads Foundry
 * content from a journal LevelDB snapshot (unlocked copy), matches by normalized name
 * so "- Journal" variants of an existing note don't get duplicated.
 *
 *   npx tsx scripts/import-missing.ts --vault <Refined-dir> --journal <snapshot> [--apply] [--out <sandbox>]
 *
 * default (no --apply): write imported notes to <out>/imported/... for review.
 * --apply: write into the real vault under <vault>/imported/<folder>/<name>.md.
 */
import { readdir, readFile, writeFile, mkdir } from "node:fs/promises";
import { join, dirname, sep } from "node:path";
import { JournalDb } from "../src/db.js";
import { entryToObsidian } from "../src/toObsidian.js";
import { folderPathFromCcType } from "../src/fields.js";

const SKIP_DIRS = new Set([".trash", ".obsidian", "node_modules", "_Templates", ".git", "imported"]);

function norm(s: string): string {
  return s.replace(/\s*-\s*Journal$/i, "").replace(/^"(.*)"$/, "$1").replace(/['']/g, "'").trim().toLowerCase();
}
function safeName(s: string): string {
  return s.replace(/\s*-\s*Journal$/i, "").replace(/^"(.*)"$/, "$1").replace(/[/\\]/g, "-").trim();
}

function parseArgs(argv: string[]) {
  const o: { vault: string; journal: string; apply: boolean; out: string } = { vault: "", journal: "", apply: false, out: "" };
  for (let i = 2; i < argv.length; i++) {
    if (argv[i] === "--vault") o.vault = argv[++i];
    else if (argv[i] === "--journal") o.journal = argv[++i];
    else if (argv[i] === "--apply") o.apply = true;
    else if (argv[i] === "--out") o.out = argv[++i];
    else throw new Error(`unknown flag: ${argv[i]}`);
  }
  if (!o.vault || !o.journal) throw new Error("--vault <Refined-dir> and --journal <snapshot> are required");
  if (!o.apply && !o.out) o.out = "/tmp/devout-dev";
  return o;
}

async function walkMd(root: string): Promise<string[]> {
  let out: string[] = [];
  try {
    for (const ent of await readdir(root, { withFileTypes: true })) {
      if (SKIP_DIRS.has(ent.name)) continue;
      const p = join(root, ent.name);
      if (ent.isDirectory()) out = out.concat(await walkMd(p));
      else if (ent.isFile() && ent.name.toLowerCase().endsWith(".md")) out.push(p);
    }
  } catch { /* missing */ }
  return out;
}

async function main() {
  const opts = parseArgs(process.argv);
  const db = await JournalDb.open(opts.journal);
  try {
    const files = await walkMd(opts.vault);
    const vaultNorm = new Set<string>();
    for (const f of files) vaultNorm.add(norm(f.split(sep).pop()!.replace(/\.md$/i, "")));

    const entries = db.all();
    const stamp = new Date().toISOString();
    const toImport = entries.filter((e) => !vaultNorm.has(norm(e.name)));
    console.log(`vault notes: ${files.length}`);
    console.log(`Foundry CC entries: ${entries.length}`);
    console.log(`unlinked (no vault counterpart): ${toImport.length}`);

    const dest = opts.apply ? opts.vault : opts.out;
    let written = 0;
    for (const e of toImport) {
      const ccType = e.flags?.["campaign-codex"]?.type ?? "shop";
      const note = entryToObsidian(e, db, stamp); // embeds foundry: block
      const subfolder = folderPathFromCcType(ccType);
      const fname = `${safeName(e.name)}.md`;
      const target = join(dest, "imported", subfolder, fname);
      await mkdir(dirname(target), { recursive: true });
      await writeFile(target, note.content, "utf8");
      written++;
      console.log(`  + ${join("imported", subfolder, fname)}`);
    }
    console.log(`\nimported: ${written} -> ${opts.apply ? join(opts.vault, "imported") : join(opts.out, "imported")} [${opts.apply ? "APPLY" : "sandbox"}]`);
  } finally {
    await db.close();
  }
}

main().catch((e) => { console.error(`error: ${(e as Error).message}`); process.exit(1); });