comfy-pr 0.2.26 → 1.0.1

package/src/matchRelatedPulls.ts

@@ -8,7 +8,7 @@ export type RelatedPullsWithComments = Awaited<ReturnType<typeof fetchRelatedPul
 export type RelatedPull = Awaited<ReturnType<typeof matchRelatedPulls>>[number];
 export async function matchRelatedPulls(pulls: GithubPullParsed[]): Promise<
   {
-    type: "pyproject" | "publishcr" | "licence-update";
+    type: "pyproject" | "publishcr" | "licence-update" | "gpl3-license";
     pull: {
       title: string;
       number: number;
@@ -24,9 +24,10 @@ export async function matchRelatedPulls(pulls: GithubPullParsed[]): Promise<
     };
   }[]
 > {
-  const pyproject = await readTemplateTitle("add-toml.md");
-  const publishcr = await readTemplateTitle("add-action.md");
-  const licenseUpdate = await readTemplateTitle("update-toml-license.md");
+  const pyproject = await readTemplateTitle("./templates/add-toml.md");
+  const publishcr = await readTemplateTitle("./templates/add-action.md");
+  const licenseUpdate = await readTemplateTitle("./templates/update-toml-license.md");
+  const gpl3License = await readTemplateTitle("./templates/add-gpl3-license.md");
   const relatedPulls = await pMap(pulls, async (pull) =>
     match(pull)
       .with({ title: pyproject }, (pull) => ({
@@ -41,6 +42,10 @@ export async function matchRelatedPulls(pulls: GithubPullParsed[]): Promise<
         type: "publishcr" as const,
         pull,
       }))
+      .with({ title: gpl3License }, (pull) => ({
+        type: "gpl3-license" as const,
+        pull,
+      }))
       .otherwise(() => null),
   );
   return relatedPulls.flatMap((e) => (e ? [e] : []));

package/src/normalizeGithubUrl.spec.ts

@@ -0,0 +1,131 @@
+import { describe, expect, test } from "bun:test";
+import {
+  normalizeGithubUrl,
+  normalizeGithubUrls,
+  normalizeGithubUrlsInObject,
+} from "./normalizeGithubUrl";
+
+describe("normalizeGithubUrl", () => {
+  test("should normalize comfyanonymous to Comfy-Org", () => {
+    const url = "https://github.com/comfyanonymous/ComfyUI/issues/123";
+    const expected = "https://github.com/Comfy-Org/ComfyUI/issues/123";
+    expect(normalizeGithubUrl(url)).toBe(expected);
+  });
+
+  test("should handle already normalized URLs", () => {
+    const url = "https://github.com/Comfy-Org/ComfyUI/issues/123";
+    expect(normalizeGithubUrl(url)).toBe(url);
+  });
+
+  test("should be case insensitive", () => {
+    const url = "https://github.com/ComfyAnonymous/ComfyUI/issues/123";
+    const expected = "https://github.com/Comfy-Org/ComfyUI/issues/123";
+    expect(normalizeGithubUrl(url)).toBe(expected);
+  });
+
+  test("should handle pull request URLs", () => {
+    const url = "https://github.com/comfyanonymous/ComfyUI/pull/456";
+    const expected = "https://github.com/Comfy-Org/ComfyUI/pull/456";
+    expect(normalizeGithubUrl(url)).toBe(expected);
+  });
+
+  test("should handle comment URLs", () => {
+    const url = "https://github.com/comfyanonymous/ComfyUI/issues/123#issuecomment-456789";
+    const expected = "https://github.com/Comfy-Org/ComfyUI/issues/123#issuecomment-456789";
+    expect(normalizeGithubUrl(url)).toBe(expected);
+  });
+
+  test("should handle release URLs", () => {
+    const url = "https://github.com/comfyanonymous/ComfyUI/releases/tag/v1.0.0";
+    const expected = "https://github.com/Comfy-Org/ComfyUI/releases/tag/v1.0.0";
+    expect(normalizeGithubUrl(url)).toBe(expected);
+  });
+
+  test("should not affect other GitHub repos (Comfy-Org)", () => {
+    const url = "https://github.com/Comfy-Org/ComfyUI_frontend/issues/123";
+    expect(normalizeGithubUrl(url)).toBe(url);
+  });
+
+  test("should not affect other comfyanonymous repos", () => {
+    // Only ComfyUI was migrated — other hypothetical repos under comfyanonymous should be untouched
+    const url = "https://github.com/comfyanonymous/some-other-repo/issues/1";
+    expect(normalizeGithubUrl(url)).toBe(url);
+  });
+
+  test("should handle repo URL without trailing path", () => {
+    const url = "https://github.com/comfyanonymous/ComfyUI";
+    const expected = "https://github.com/Comfy-Org/ComfyUI";
+    expect(normalizeGithubUrl(url)).toBe(expected);
+  });
+
+  test("should handle empty string", () => {
+    expect(normalizeGithubUrl("")).toBe("");
+  });
+
+  test("should handle non-GitHub URLs", () => {
+    const url = "https://example.com/path";
+    expect(normalizeGithubUrl(url)).toBe(url);
+  });
+});
+
+describe("normalizeGithubUrls", () => {
+  test("should normalize multiple URLs", () => {
+    const urls = [
+      "https://github.com/comfyanonymous/ComfyUI/issues/123",
+      "https://github.com/Comfy-Org/ComfyUI/issues/456",
+      "https://github.com/comfyanonymous/ComfyUI/pull/789",
+    ];
+    const expected = [
+      "https://github.com/Comfy-Org/ComfyUI/issues/123",
+      "https://github.com/Comfy-Org/ComfyUI/issues/456",
+      "https://github.com/Comfy-Org/ComfyUI/pull/789",
+    ];
+    expect(normalizeGithubUrls(urls)).toEqual(expected);
+  });
+
+  test("should handle empty array", () => {
+    expect(normalizeGithubUrls([])).toEqual([]);
+  });
+});
+
+describe("normalizeGithubUrlsInObject", () => {
+  test("should normalize URL fields in object", () => {
+    const obj = {
+      sourceIssueUrl: "https://github.com/comfyanonymous/ComfyUI/issues/123",
+      targetIssueUrl: "https://github.com/Comfy-Org/ComfyUI_frontend/issues/456",
+      otherField: "not a url",
+    };
+    const result = normalizeGithubUrlsInObject(obj, ["sourceIssueUrl", "targetIssueUrl"]);
+    expect(result.sourceIssueUrl).toBe("https://github.com/Comfy-Org/ComfyUI/issues/123");
+    expect(result.targetIssueUrl).toBe("https://github.com/Comfy-Org/ComfyUI_frontend/issues/456");
+    expect(result.otherField).toBe("not a url");
+  });
+
+  test("should not modify non-URL fields", () => {
+    const obj = {
+      url: "https://github.com/comfyanonymous/ComfyUI/issues/123",
+      count: 42,
+      flag: true,
+    };
+    const result = normalizeGithubUrlsInObject(obj, ["url"]);
+    expect(result.url).toBe("https://github.com/Comfy-Org/ComfyUI/issues/123");
+    expect(result.count).toBe(42);
+    expect(result.flag).toBe(true);
+  });
+
+  test("should handle objects with no URL fields", () => {
+    const obj = { name: "test", value: 123 };
+    const result = normalizeGithubUrlsInObject(obj, []);
+    expect(result).toEqual(obj);
+  });
+
+  test("should create a new object (not mutate)", () => {
+    const obj = {
+      url: "https://github.com/comfyanonymous/ComfyUI/issues/123",
+    };
+    const result = normalizeGithubUrlsInObject(obj, ["url"]);
+    expect(result).not.toBe(obj);
+    expect(obj.url).toBe("https://github.com/comfyanonymous/ComfyUI/issues/123");
+    expect(result.url).toBe("https://github.com/Comfy-Org/ComfyUI/issues/123");
+  });
+});

package/src/normalizeGithubUrl.ts

@@ -0,0 +1,64 @@
+/**
+ * Normalize GitHub URLs to use the canonical Comfy-Org organization name
+ *
+ * This ensures that URLs pointing to the same resource but with different
+ * organization names (comfyanonymous vs Comfy-Org) are treated as identical.
+ *
+ * @param url - GitHub URL to normalize
+ * @returns Normalized URL with comfyanonymous replaced by Comfy-Org
+ *
+ * @example
+ * normalizeGithubUrl("https://github.com/comfyanonymous/ComfyUI/issues/123")
+ * // => "https://github.com/Comfy-Org/ComfyUI/issues/123"
+ *
+ * normalizeGithubUrl("https://github.com/Comfy-Org/ComfyUI/issues/123")
+ * // => "https://github.com/Comfy-Org/ComfyUI/issues/123"
+ */
+export function normalizeGithubUrl(url: string): string {
+  if (!url) return url;
+
+  // Only ComfyUI was migrated from comfyanonymous to Comfy-Org
+  return url.replace(
+    /github\.com\/comfyanonymous\/ComfyUI([/?#]|$)/gi,
+    "github.com/Comfy-Org/ComfyUI$1",
+  );
+}
+
+/**
+ * Normalize multiple GitHub URLs at once
+ *
+ * @param urls - Array of GitHub URLs to normalize
+ * @returns Array of normalized URLs
+ */
+export function normalizeGithubUrls(urls: string[]): string[] {
+  return urls.map(normalizeGithubUrl);
+}
+
+/**
+ * Normalize GitHub URLs in an object's properties
+ *
+ * @param obj - Object containing URL properties
+ * @param urlFields - Array of field names that contain URLs
+ * @returns New object with normalized URLs
+ *
+ * @example
+ * normalizeGithubUrlsInObject(
+ *   { sourceIssueUrl: "https://github.com/comfyanonymous/ComfyUI/issues/123" },
+ *   ["sourceIssueUrl"]
+ * )
+ * // => { sourceIssueUrl: "https://github.com/Comfy-Org/ComfyUI/issues/123" }
+ */
+export function normalizeGithubUrlsInObject<T extends Record<string, unknown>>(
+  obj: T,
+  urlFields: (keyof T)[],
+): T {
+  const result = { ...obj };
+
+  for (const field of urlFields) {
+    if (typeof result[field] === "string") {
+      result[field] = normalizeGithubUrl(result[field] as string) as T[keyof T];
+    }
+  }
+
+  return result;
+}

package/src/parseIssueUrl.spec.ts

@@ -0,0 +1,95 @@
+import { parseIssueUrl } from "./parseIssueUrl";
+
+describe("parseIssueUrl", () => {
+  it("should parse a valid pull request URL", () => {
+    const url = "https://github.com/owner/repo/pull/123";
+    const result = parseIssueUrl(url);
+
+    expect(result).toEqual({
+      owner: "owner",
+      repo: "repo",
+      issue_number: 123,
+    });
+  });
+
+  it("should parse a valid issue URL", () => {
+    const url = "https://github.com/owner/repo/issues/456";
+    const result = parseIssueUrl(url);
+
+    expect(result).toEqual({
+      owner: "owner",
+      repo: "repo",
+      issue_number: 456,
+    });
+  });
+
+  it("should handle owner and repo names with hyphens", () => {
+    const url = "https://github.com/my-org/my-repo/pull/789";
+    const result = parseIssueUrl(url);
+
+    expect(result).toEqual({
+      owner: "my-org",
+      repo: "my-repo",
+      issue_number: 789,
+    });
+  });
+
+  it("should handle numeric issue numbers correctly", () => {
+    const url = "https://github.com/test/test/issues/1";
+    const result = parseIssueUrl(url);
+
+    expect(result).toEqual({
+      owner: "test",
+      repo: "test",
+      issue_number: 1,
+    });
+  });
+
+  it("should handle large issue numbers", () => {
+    const url = "https://github.com/test/test/pull/999999";
+    const result = parseIssueUrl(url);
+
+    expect(result).toEqual({
+      owner: "test",
+      repo: "test",
+      issue_number: 999999,
+    });
+  });
+
+  it("should throw an error for invalid URL format", () => {
+    const invalidUrl = "https://github.com/owner/repo/invalid/123";
+
+    expect(() => parseIssueUrl(invalidUrl)).toThrow();
+  });
+
+  it("should throw an error for non-GitHub URLs", () => {
+    const invalidUrl = "https://gitlab.com/owner/repo/pull/123";
+
+    expect(() => parseIssueUrl(invalidUrl)).toThrow();
+  });
+
+  it("should throw an error for URLs without issue/pull number", () => {
+    const invalidUrl = "https://github.com/owner/repo/pull/";
+
+    expect(() => parseIssueUrl(invalidUrl)).toThrow();
+  });
+
+  it("should throw an error for URLs with non-numeric issue numbers", () => {
+    const invalidUrl = "https://github.com/owner/repo/pull/abc";
+
+    expect(() => parseIssueUrl(invalidUrl)).toThrow();
+  });
+
+  it("should throw an error for incomplete URLs", () => {
+    const invalidUrl = "https://github.com/owner";
+
+    expect(() => parseIssueUrl(invalidUrl)).toThrow();
+  });
+
+  it("should handle URLs with trailing slashes", () => {
+    // Note: The current regex doesn't handle trailing slashes, so this should fail
+    const url = "https://github.com/owner/repo/pull/123/";
+
+    expect(() => parseIssueUrl(url)).toThrow();
+  });
+});

package/src/parseIssueUrl.ts

@@ -1,6 +1,20 @@
+import DIE from "@snomiao/die";
+
+/**
+ * Parse pull or issue url, get issue_number
+ */
 export function parseIssueUrl(issueUrl: string) {
-  const [owner, repo, strNumber] = issueUrl
-    .match(/^https:\/\/github\.com\/([\w-]+)\/([\w-]+)\/(?:pull|issues)\/(\d+)$/)!
-    .slice(1);
+  const m =
+    issueUrl.match(
+      /^https:\/\/github\.com\/([\w-]+)\/([\w-]+)\/(?:pull|issues)\/(\d+)(?:\/files)?(?:#.*)?$/,
+    ) || DIE(`Invalid issue URL: ${issueUrl}`);
+  const [owner, repo, strNumber] = m.slice(1);
+  if (!owner || !repo || !strNumber) {
+    throw new Error(`Invalid issue URL: ${issueUrl}`);
+  }
   return { owner, repo, issue_number: Number(strNumber) };
 }
+
+export function stringifyIssueUrl({ owner, repo, issue_number }: ReturnType<typeof parseIssueUrl>) {
+  return `https://github.com/${owner}/${repo}/issues/${issue_number}`;
+}

package/src/parseOwnerRepo.spec.ts

@@ -0,0 +1,147 @@
+import {
+  parseGithubRepoUrl,
+  stringifyGithubOrigin,
+  stringifyGithubRepoUrl,
+  stringifyOwnerRepo,
+} from "./parseOwnerRepo";
+
+describe("parseOwnerRepo", () => {
+  describe("parseGithubRepoUrl", () => {
+    it("should parse SSH GitHub URL", () => {
+      const result = parseGithubRepoUrl("git@github.com:owner/repo");
+      expect(result).toEqual({
+        owner: "owner",
+        repo: "repo",
+      });
+    });
+
+    it("should parse SSH GitHub URL with .git extension", () => {
+      const result = parseGithubRepoUrl("git@github.com:owner/repo.git");
+      expect(result).toEqual({
+        owner: "owner",
+        repo: "repo",
+      });
+    });
+
+    it("should parse HTTPS GitHub URL", () => {
+      const result = parseGithubRepoUrl("https://github.com/owner/repo");
+      expect(result).toEqual({
+        owner: "owner",
+        repo: "repo",
+      });
+    });
+
+    it("should parse HTTPS GitHub URL with .git extension", () => {
+      const result = parseGithubRepoUrl("https://github.com/owner/repo.git");
+      expect(result).toEqual({
+        owner: "owner",
+        repo: "repo",
+      });
+    });
+
+    it("should handle owner/repo with hyphens and underscores", () => {
+      const result = parseGithubRepoUrl("git@github.com:my-org_name/my-repo_name");
+      expect(result).toEqual({
+        owner: "my-org_name",
+        repo: "my-repo_name",
+      });
+    });
+
+    it("should handle owner/repo with numbers", () => {
+      const result = parseGithubRepoUrl("https://github.com/user123/repo456");
+      expect(result).toEqual({
+        owner: "user123",
+        repo: "repo456",
+      });
+    });
+
+    it("should handle real-world example URLs", () => {
+      const result1 = parseGithubRepoUrl("git@github.com:Comfy-Org/ComfyUI-Registry");
+      expect(result1).toEqual({
+        owner: "Comfy-Org",
+        repo: "ComfyUI-Registry",
+      });
+
+      const result2 = parseGithubRepoUrl("https://github.com/snomiao/ComfyUI-FD-Tagger.git");
+      expect(result2).toEqual({
+        owner: "snomiao",
+        repo: "ComfyUI-FD-Tagger",
+      });
+    });
+  });
+
+  describe("stringifyOwnerRepo", () => {
+    it("should stringify owner and repo", () => {
+      const result = stringifyOwnerRepo({ owner: "owner", repo: "repo" });
+      expect(result).toBe("owner/repo");
+    });
+
+    it("should handle special characters", () => {
+      const result = stringifyOwnerRepo({ owner: "my-org_name", repo: "my-repo_name" });
+      expect(result).toBe("my-org_name/my-repo_name");
+    });
+
+    it("should handle numbers", () => {
+      const result = stringifyOwnerRepo({ owner: "user123", repo: "repo456" });
+      expect(result).toBe("user123/repo456");
+    });
+  });
+
+  describe("stringifyGithubRepoUrl", () => {
+    it("should create HTTPS GitHub URL", () => {
+      const result = stringifyGithubRepoUrl({ owner: "owner", repo: "repo" });
+      expect(result).toBe("https://github.com/owner/repo");
+    });
+
+    it("should handle special characters", () => {
+      const result = stringifyGithubRepoUrl({ owner: "my-org_name", repo: "my-repo_name" });
+      expect(result).toBe("https://github.com/my-org_name/my-repo_name");
+    });
+
+    it("should handle real-world examples", () => {
+      const result = stringifyGithubRepoUrl({ owner: "Comfy-Org", repo: "ComfyUI-Registry" });
+      expect(result).toBe("https://github.com/Comfy-Org/ComfyUI-Registry");
+    });
+  });
+
+  describe("stringifyGithubOrigin", () => {
+    it("should return SSH URL regardless of token presence", async () => {
+      // The function always returns SSH URL according to the current implementation
+      const result = await stringifyGithubOrigin({ owner: "owner", repo: "repo" });
+      expect(result).toBe("git@github.com:owner/repo");
+    });
+
+    it("should handle special characters in owner/repo", async () => {
+      const result = await stringifyGithubOrigin({ owner: "my-org_name", repo: "my-repo_name" });
+      expect(result).toBe("git@github.com:my-org_name/my-repo_name");
+    });
+
+    it("should handle real-world examples", async () => {
+      const result = await stringifyGithubOrigin({ owner: "Comfy-Org", repo: "ComfyUI-Registry" });
+      expect(result).toBe("git@github.com:Comfy-Org/ComfyUI-Registry");
+    });
+  });
+
+  describe("integration tests", () => {
+    it("should work end-to-end with parseGithubRepoUrl and stringifyOwnerRepo", () => {
+      const originalUrl = "git@github.com:Comfy-Org/ComfyUI-Registry.git";
+      const parsed = parseGithubRepoUrl(originalUrl);
+      const stringified = stringifyOwnerRepo(parsed);
+      expect(stringified).toBe("Comfy-Org/ComfyUI-Registry");
+    });
+
+    it("should work end-to-end with parseGithubRepoUrl and stringifyGithubRepoUrl", () => {
+      const originalUrl = "git@github.com:snomiao/ComfyUI-FD-Tagger";
+      const parsed = parseGithubRepoUrl(originalUrl);
+      const httpsUrl = stringifyGithubRepoUrl(parsed);
+      expect(httpsUrl).toBe("https://github.com/snomiao/ComfyUI-FD-Tagger");
+    });
+
+    it("should work end-to-end with parseGithubRepoUrl and stringifyGithubOrigin", async () => {
+      const originalUrl = "https://github.com/owner/repo.git";
+      const parsed = parseGithubRepoUrl(originalUrl);
+      const sshUrl = await stringifyGithubOrigin(parsed);
+      expect(sshUrl).toBe("git@github.com:owner/repo");
+    });
+  });
+});

package/src/parseOwnerRepo.ts

@@ -2,21 +2,24 @@ import { basename, dirname } from "path";
 
 /**
  * Parse owner and repo obj
- * @param gitUrl git@github.ocm:owner/repo or https://github.ocm/owner/repo
+ * @param gitUrl git@github.com:owner/repo or https://github.com/owner/repo
  */
-export function parseUrlRepoOwner(gitUrl: string) {
+export function parseGithubRepoUrl(gitUrl: string) {
   return {
     owner: basename(dirname(gitUrl.replace(/:/, "/"))),
     repo: basename(gitUrl.replace(/:/, "/")).replace(/\.git$/, ""),
   };
 }
-export function stringifyOwnerRepo({ owner, repo }: ReturnType<typeof parseUrlRepoOwner>) {
+export function stringifyOwnerRepo({ owner, repo }: ReturnType<typeof parseGithubRepoUrl>) {
   return owner + "/" + repo;
 }
-export function stringifyGithubRepoUrl({ owner, repo }: ReturnType<typeof parseUrlRepoOwner>) {
+export function stringifyGithubRepoUrl({ owner, repo }: ReturnType<typeof parseGithubRepoUrl>) {
   return "https://github.com/" + owner + "/" + repo;
 }
-export async function stringifyGithubOrigin({ owner, repo }: ReturnType<typeof parseUrlRepoOwner>) {
+export async function stringifyGithubOrigin({
+  owner,
+  repo,
+}: ReturnType<typeof parseGithubRepoUrl>) {
   const PR_TOKEN = process.env.GH_TOKEN_COMFY_PR;
   if (PR_TOKEN) {
     // fails: maybe permission issue

package/src/parsePullsState.ts

@@ -1,5 +1,5 @@
-import type { GithubPull } from "./gh/GithubPull";
-import { parsePull } from "./gh/parsePull";
+import type { GithubPull } from "@/lib/github/GithubPull";
+import { parsePull } from "@/lib/github/parsePull";
 export type GithubPullParsed = ReturnType<typeof parsePulls>[number];
 export function parsePulls(data: GithubPull[]) {
   return data.map((e) => parsePull(e));

package/src/parseTitleBodyOfMarkdown.ts

@@ -1,7 +1,7 @@
 import DIE from "@snomiao/die";
 
 export function parseTitleBodyOfMarkdown(tmpl: string) {
-  tmpl.startsWith("# ") || DIE("Unrecognized template format:" + tmpl);
+  if (!tmpl.startsWith("# ")) DIE("Unrecognized template format:" + tmpl);
   const title = tmpl.split("\n")[0].slice(1).trim();
   const body = tmpl.split("\n").slice(1).join("\n").trim();
   return { title, body };

package/src/pickRepoInfo.ts

@@ -0,0 +1,37 @@
+import { gh } from "@/lib/github";
+
+type GithubRepo = Awaited<ReturnType<typeof gh.repos.get>>["data"];
+
+/**
+ * Pick only the fields we need from a GitHub repository response.
+ * This reduces document size from ~5KB to ~300 bytes.
+ *
+ * Fields kept based on actual usage in codebase:
+ * - html_url: repository links
+ * - archived: statistics and filtering
+ * - default_branch: branch operations
+ * - private: access control
+ * - owner.login: author tracking
+ * - license: license checks
+ * - updated_at: activity tracking
+ */
+export function pickRepoInfo(repo: GithubRepo) {
+  return {
+    html_url: repo.html_url,
+    archived: repo.archived,
+    default_branch: repo.default_branch,
+    private: repo.private,
+    updated_at: repo.updated_at,
+    owner: {
+      login: repo.owner.login,
+    },
+    license: repo.license
+      ? {
+          spdx_id: repo.license.spdx_id,
+          name: repo.license.name,
+        }
+      : null,
+  };
+}
+
+export type PickedRepoInfo = ReturnType<typeof pickRepoInfo>;

package/src/postSlackMessage.ts

@@ -1,8 +1,12 @@
 import DIE from "@snomiao/die";
-import { slack } from "./slack";
+import { getSlack } from "@/lib/slack";
 
+/**
+ * @deprecated use upsertSlackMessage from gh-desktop-release-notification/upsertSlackMessage.ts
+ */
 export async function postSlackMessage(text: string) {
   const channel = process.env.SLACK_BOT_CHANNEL || DIE(new Error("missing env.SLACK_BOT_CHANNEL"));
+  const slack = getSlack();
   // this api will auto retry if failed
   const response = await slack.chat.postMessage({
     channel,

package/src/preload.ts

@@ -1,30 +1,33 @@
-await Bun.plugin({
-  name: "YAML",
-  async setup(build) {
-    const { load } = await import("js-yaml");
+void (async () => {
+  await Bun.plugin({
+    name: "YAML",
+    async setup(build) {
+      const { load } = await import("js-yaml");
 
-    // when a .yaml file is imported...
-    build.onLoad({ filter: /\.(yaml|yml)$/ }, async (args) => {
-      // read and parse the file
-      const text = await Bun.file(args.path).text();
-      const exports = load(text) as Record<string, any>;
+      // when a .yaml file is imported...
+      build.onLoad({ filter: /\.(yaml|yml)$/ }, async (args) => {
+        // read and parse the file
+        const text = await Bun.file(args.path).text();
+        const exports = load(text) as Record<string, unknown>;
 
-      // and returns it as a module
-      return {
-        exports,
-        loader: "object", // special loader for JS objects
-      };
-    });
-  },
-});
+        // and returns it as a module
+        return {
+          exports,
+          loader: "object", // special loader for JS objects
+        };
+      });
+    },
+  });
+})();
 
-Bun.plugin({
-  name: "preload-plugin",
-  setup(builder) {
-    builder.onLoad({ filter: /\.ts$/ }, async (args) => {
-      const text = await Bun.file(args.path).text();
-      // console.log("text", text);
-      return { contents: text, loader: args.loader };
-    });
-  },
-});
+// 2025-08-15 seems unnecessary
+// Bun.plugin({
+//   name: "preload-plugin",
+//   setup(builder) {
+//     builder.onLoad({ filter: /\.ts$/ }, async (args) => {
+//       const text = await Bun.file(args.path).text();
+//       // console.log("text", text);
+//       return { contents: text, loader: args.loader };
+//     });
+//   },
+// });

package/src/readTemplateTitle.ts

@@ -5,7 +5,5 @@ export async function readTemplateTitle(filename: string) {
   return await readTemplate(filename).then((e) => e.title);
 }
 export async function readTemplate(filename: string) {
-  return readFile("./templates/" + filename, "utf8").then(
-    parseTitleBodyOfMarkdown,
-  );
+  return readFile(filename, "utf8").then(parseTitleBodyOfMarkdown);
 }