canopycms 0.0.26 → 0.0.28

package/dist/cli/generate-ai-content.js

@@ -23,6 +23,15 @@ function createLogicalPath(...segments) {
   }
   return normalized;
 }
+function trimSlashes(path13) {
+  let start = 0;
+  let end = path13.length;
+  while (start < end && path13[start] === "/")
+    start++;
+  while (end > start && path13[end - 1] === "/")
+    end--;
+  return path13.slice(start, end);
+}
 var init_normalize = __esm({
   "dist/paths/normalize.js"() {
     "use strict";
@@ -237,7 +246,7 @@ var init_collection = __esm({
     }).transform((val) => val.split(/[\\/]+/).filter(Boolean).join("/"));
     entryTypeSchema = z2.object({
       name: z2.string().min(1),
-      format: z2.enum(["md", "mdx", "json"]),
+      format: z2.enum(["md", "mdx", "json", "yaml"]),
       schema: z2.array(z2.lazy(() => fieldSchema)).min(1),
       label: z2.string().optional(),
       description: z2.string().optional(),
@@ -348,7 +357,8 @@ var init_config = __esm({
       contentRoot: contentRootSchema.default("content"),
       sourceRoot: sourceRootSchema.optional(),
       editor: editorConfigSchema.optional(),
-      authPlugin: z4.custom().optional()
+      authPlugin: z4.custom().optional(),
+      entryLinkUrl: z4.custom().optional()
     });
     DEFAULT_PROD_WORKSPACE = "/mnt/efs/workspace";
   }
@@ -691,6 +701,7 @@ import path11 from "node:path";
 import fs4 from "node:fs/promises";
 import path5 from "node:path";
 import matter from "gray-matter";
+import { parse as yamlParse, stringify as yamlStringify } from "yaml";
 
 // dist/utils/atomic-write.js
 import fs from "node:fs/promises";
@@ -1046,8 +1057,12 @@ var getFormatExtension = (format) => {
     return ".md";
   if (format === "mdx")
     return ".mdx";
+  if (format === "yaml")
+    return ".yaml";
   return ".json";
 };
+var isDataOnlyFormat = (format) => format === "json" || format === "yaml";
+var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
 
 // dist/paths/index.js
 init_normalize();
@@ -1288,7 +1303,7 @@ var ContentStore = class {
       fields = defaultEntry?.schema || [];
     }
     if (format === "json") {
-      const data = JSON.parse(raw);
+      const data = asRecord(JSON.parse(raw));
       doc = {
         collection: schemaItem.logicalPath,
         collectionName: schemaItem.name,
@@ -1297,6 +1312,16 @@ var ContentStore = class {
         relativePath,
         absolutePath
       };
+    } else if (format === "yaml") {
+      const data = asRecord(yamlParse(raw));
+      doc = {
+        collection: schemaItem.logicalPath,
+        collectionName: schemaItem.name,
+        format: "yaml",
+        data,
+        relativePath,
+        absolutePath
+      };
     } else {
       const parsed = matter(raw);
       doc = {
@@ -1343,25 +1368,28 @@ var ContentStore = class {
       entryTypeName
     });
     await fs4.mkdir(path5.dirname(absolutePath), { recursive: true });
+    const updateIdIndex = () => {
+      if (!id)
+        return;
+      const existing = idIndex.findById(id);
+      if (existing) {
+        if (existing.relativePath !== relativePath) {
+          idIndex.updatePath(existing.id, relativePath);
+        }
+      } else {
+        idIndex.add({
+          type: "entry",
+          relativePath,
+          collection: collectionPath,
+          slug: slug || void 0
+        });
+      }
+    };
     if (input.format === "json") {
       const json = JSON.stringify(input.data ?? {}, null, 2);
       await atomicWriteFile(absolutePath, `${json}
 `);
-      if (id) {
-        const existing = idIndex.findById(id);
-        if (existing) {
-          if (existing.relativePath !== relativePath) {
-            idIndex.updatePath(existing.id, relativePath);
-          }
-        } else {
-          idIndex.add({
-            type: "entry",
-            relativePath,
-            collection: collectionPath,
-            slug: slug || void 0
-          });
-        }
-      }
+      updateIdIndex();
       return {
         collection: schemaItem.logicalPath,
         collectionName: schemaItem.name,
@@ -1371,23 +1399,22 @@ var ContentStore = class {
         absolutePath
       };
     }
+    if (input.format === "yaml") {
+      const yaml = yamlStringify(input.data ?? {});
+      await atomicWriteFile(absolutePath, yaml);
+      updateIdIndex();
+      return {
+        collection: schemaItem.logicalPath,
+        collectionName: schemaItem.name,
+        format: "yaml",
+        data: input.data ?? {},
+        relativePath,
+        absolutePath
+      };
+    }
     const file = matter.stringify(input.body, input.data ?? {});
     await atomicWriteFile(absolutePath, file);
-    if (id) {
-      const existing = idIndex.findById(id);
-      if (existing) {
-        if (existing.relativePath !== relativePath) {
-          idIndex.updatePath(existing.id, relativePath);
-        }
-      } else {
-        idIndex.add({
-          type: "entry",
-          relativePath,
-          collection: collectionPath,
-          slug: slug || void 0
-        });
-      }
-    }
+    updateIdIndex();
     return {
       collection: schemaItem.logicalPath,
       collectionName: schemaItem.name,
@@ -1613,7 +1640,7 @@ import { z as z6 } from "zod";
 import chokidar from "chokidar";
 var entryTypeMetaSchema = z6.object({
   name: z6.string().min(1),
-  format: z6.enum(["md", "mdx", "json"]),
+  format: z6.enum(["md", "mdx", "json", "yaml"]),
   schema: z6.string().min(1),
   // Entry schema registry key (validated at resolution time)
   label: z6.string().optional(),
@@ -2366,10 +2393,223 @@ function yamlValue(value) {
   return value;
 }
 
+// dist/utils/debug.js
+var LOG_LEVELS = {
+  DEBUG: 0,
+  INFO: 1,
+  WARN: 2,
+  ERROR: 3
+};
+var DebugLogger = class {
+  constructor(options = {}) {
+    this.timers = /* @__PURE__ */ new Map();
+    this.options = options;
+  }
+  shouldLog(level) {
+    const enabled = this.options.enabled ?? process.env.CANOPYCMS_DEBUG === "true";
+    if (!enabled)
+      return false;
+    const minLevel = this.options.minLevel ?? "DEBUG";
+    return LOG_LEVELS[level] >= LOG_LEVELS[minLevel];
+  }
+  formatMessage(level, category, message) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const prefix = this.options.prefix ?? "CanopyCMS";
+    return `[${timestamp}] [${prefix}:${category}] [${level}] ${message}`;
+  }
+  debug(category, message, data) {
+    if (this.shouldLog("DEBUG")) {
+      console.log(this.formatMessage("DEBUG", category, message), data ?? "");
+    }
+  }
+  info(category, message, data) {
+    if (this.shouldLog("INFO")) {
+      console.log(this.formatMessage("INFO", category, message), data ?? "");
+    }
+  }
+  warn(category, message, data) {
+    if (this.shouldLog("WARN")) {
+      console.warn(this.formatMessage("WARN", category, message), data ?? "");
+    }
+  }
+  error(category, message, data) {
+    const msg = this.formatMessage("ERROR", category, message);
+    if (this.shouldLog("ERROR")) {
+      console.error(msg, data ?? "");
+    }
+    const throwOnError = this.options.throwOnError ?? false;
+    if (throwOnError) {
+      const errorMsg = data ? `${message}: ${JSON.stringify(data)}` : message;
+      throw new Error(errorMsg);
+    }
+  }
+  /**
+   * Start timing an operation
+   */
+  time(label) {
+    this.timers.set(label, Date.now());
+  }
+  /**
+   * End timing an operation and log the duration
+   */
+  timeEnd(category, label) {
+    const start = this.timers.get(label);
+    if (start === void 0) {
+      this.warn(category, `Timer '${label}' does not exist`);
+      return;
+    }
+    const duration = Date.now() - start;
+    this.timers.delete(label);
+    this.debug(category, `${label} completed`, { durationMs: duration });
+    return duration;
+  }
+  /**
+   * Wrap an async function with automatic timing
+   */
+  async timed(category, label, fn) {
+    this.time(label);
+    try {
+      return await fn();
+    } finally {
+      this.timeEnd(category, label);
+    }
+  }
+};
+function createDebugLogger(options) {
+  return new DebugLogger(options);
+}
+var testLogger = createDebugLogger({
+  enabled: process.env.E2E_DEBUG === "true",
+  prefix: "E2E",
+  throwOnError: false
+});
+
+// dist/utils/entry-url.js
+init_normalize();
+function computeEntryUrl(collection, slug, contentRoot) {
+  const root = trimSlashes(contentRoot);
+  let stripped = collection;
+  if (root && collection.startsWith(`${root}/`)) {
+    stripped = collection.slice(root.length + 1);
+  } else if (collection === root) {
+    stripped = "";
+  }
+  const segments = stripped.split("/").filter(Boolean);
+  if (slug && slug !== "index") {
+    segments.push(slug);
+  }
+  const path13 = segments.length > 0 ? `/${segments.join("/")}` : "/";
+  return path13.toLowerCase();
+}
+
+// dist/entry-link-resolver.js
+var log = createDebugLogger({ prefix: "EntryLinks" });
+var BASE58_CHAR = "[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]";
+var ENTRY_LINK_PATTERN = new RegExp(`entry:(${BASE58_CHAR}{12})(#[^\\s)>"']*)?`, "g");
+function resolveEntryUrl(location, contentRoot) {
+  return computeEntryUrl(location.collection ?? "", location.slug ?? "", contentRoot);
+}
+function resolveEntryLinksInText(text, idIndex, contentRoot, customResolver) {
+  const parts = splitByCodeRegions(text);
+  return parts.map((part) => {
+    if (part.isCode)
+      return part.text;
+    return part.text.replace(ENTRY_LINK_PATTERN, (_match, id, anchor) => {
+      const location = idIndex.findById(id);
+      if (!location || location.type !== "entry" || !location.collection || !location.slug) {
+        log.warn("resolve", `Entry link target not found: entry:${id}`);
+        return anchor ?? "#";
+      }
+      let url;
+      if (customResolver) {
+        url = customResolver({
+          collection: location.collection,
+          slug: location.slug,
+          id
+        });
+      } else {
+        url = resolveEntryUrl(location, contentRoot);
+      }
+      return `${url}${anchor ?? ""}`;
+    });
+  }).join("");
+}
+function splitByCodeRegions(text) {
+  const parts = [];
+  let current = "";
+  let i = 0;
+  while (i < text.length) {
+    if ((text[i] === "`" || text[i] === "~") && i + 2 < text.length && text[i + 1] === text[i] && text[i + 2] === text[i]) {
+      const fence = text[i];
+      let fenceLen = 0;
+      while (i + fenceLen < text.length && text[i + fenceLen] === fence)
+        fenceLen++;
+      const lineEnd = text.indexOf("\n", i + fenceLen);
+      if (lineEnd === -1) {
+        if (current)
+          parts.push({ text: current, isCode: false });
+        parts.push({ text: text.slice(i), isCode: true });
+        return parts;
+      }
+      const closingPattern = fence.repeat(fenceLen);
+      let closeStart = lineEnd + 1;
+      let found = false;
+      while (closeStart < text.length) {
+        const nextNewline = text.indexOf("\n", closeStart);
+        const lineContent = nextNewline === -1 ? text.slice(closeStart) : text.slice(closeStart, nextNewline);
+        if (lineContent.trim().startsWith(closingPattern)) {
+          const endPos = nextNewline === -1 ? text.length : nextNewline + 1;
+          if (current)
+            parts.push({ text: current, isCode: false });
+          current = "";
+          parts.push({ text: text.slice(i, endPos), isCode: true });
+          i = endPos;
+          found = true;
+          break;
+        }
+        if (nextNewline === -1)
+          break;
+        closeStart = nextNewline + 1;
+      }
+      if (!found) {
+        if (current)
+          parts.push({ text: current, isCode: false });
+        parts.push({ text: text.slice(i), isCode: true });
+        return parts;
+      }
+      continue;
+    }
+    if (text[i] === "`") {
+      let ticks = 0;
+      while (i + ticks < text.length && text[i + ticks] === "`")
+        ticks++;
+      const closer = "`".repeat(ticks);
+      const closeIdx = text.indexOf(closer, i + ticks);
+      if (closeIdx !== -1) {
+        if (current)
+          parts.push({ text: current, isCode: false });
+        current = "";
+        parts.push({ text: text.slice(i, closeIdx + ticks), isCode: true });
+        i = closeIdx + ticks;
+        continue;
+      }
+      current += text.slice(i, i + ticks);
+      i += ticks;
+      continue;
+    }
+    current += text[i];
+    i++;
+  }
+  if (current)
+    parts.push({ text: current, isCode: false });
+  return parts;
+}
+
 // dist/ai/generate.js
 async function generateAIContent(options) {
-  const { store, flatSchema, contentRoot, config } = options;
+  const { store, flatSchema, contentRoot, config, entryLinkUrl } = options;
   const files = /* @__PURE__ */ new Map();
+  const idIndex = await store.idIndex();
   const collections = flatSchema.filter((item) => item.type === "collection");
   const allEntries = [];
   const manifestCollections = [];
@@ -2381,7 +2621,7 @@ async function generateAIContent(options) {
       continue;
     if (collection.parentPath && collection.parentPath !== contentRoot)
       continue;
-    const collectionResult = await processCollection(store, collection, flatSchema, contentRoot, config);
+    const collectionResult = await processCollection(store, collection, flatSchema, contentRoot, config, idIndex, entryLinkUrl);
     allEntries.push(...collectionResult.entries);
     for (const [filePath, content] of collectionResult.files) {
       files.set(filePath, content);
@@ -2390,7 +2630,7 @@ async function generateAIContent(options) {
   }
   const rootCollection = collections.find((c) => c.logicalPath === contentRoot);
   if (rootCollection?.entries) {
-    const rootResult = await processRootEntries(store, rootCollection, contentRoot, config);
+    const rootResult = await processRootEntries(store, rootCollection, contentRoot, config, idIndex, entryLinkUrl);
     allEntries.push(...rootResult.entries);
     for (const [filePath, content] of rootResult.files) {
       files.set(filePath, content);
@@ -2426,7 +2666,7 @@ async function generateAIContent(options) {
   files.set("manifest.json", JSON.stringify(manifest, null, 2));
   return { manifest, files };
 }
-async function processCollection(store, collection, flatSchema, contentRoot, config) {
+async function processCollection(store, collection, flatSchema, contentRoot, config, idIndex, entryLinkUrl) {
   const files = /* @__PURE__ */ new Map();
   const entries = [];
   const cleanPath = stripContentRoot(collection.logicalPath, contentRoot);
@@ -2447,6 +2687,9 @@ async function processCollection(store, collection, flatSchema, contentRoot, con
         resolveReferences: false
       });
       const aiEntry = docToAIEntry(doc, listEntry.slug, entryTypeName, entryTypeConfig, cleanPath);
+      if (aiEntry.body && idIndex) {
+        aiEntry.body = resolveEntryLinksInText(aiEntry.body, idIndex, contentRoot, entryLinkUrl);
+      }
       if (config?.exclude?.where?.(aiEntry))
         continue;
       entries.push(aiEntry);
@@ -2468,7 +2711,7 @@ async function processCollection(store, collection, flatSchema, contentRoot, con
   for (const sub of subcollections) {
     if (isCollectionExcluded(sub.logicalPath, contentRoot, config))
       continue;
-    const subResult = await processCollection(store, sub, flatSchema, contentRoot, config);
+    const subResult = await processCollection(store, sub, flatSchema, contentRoot, config, idIndex, entryLinkUrl);
     entries.push(...subResult.entries);
     for (const [filePath, content] of subResult.files) {
       files.set(filePath, content);
@@ -2492,7 +2735,7 @@ async function processCollection(store, collection, flatSchema, contentRoot, con
   };
   return { entries, files, manifestCollection };
 }
-async function processRootEntries(store, rootCollection, contentRoot, config) {
+async function processRootEntries(store, rootCollection, contentRoot, config, idIndex, entryLinkUrl) {
   const files = /* @__PURE__ */ new Map();
   const entries = [];
   const manifestEntries = [];
@@ -2512,6 +2755,9 @@ async function processRootEntries(store, rootCollection, contentRoot, config) {
         resolveReferences: false
       });
       const aiEntry = docToAIEntry(doc, listEntry.slug, entryTypeName, entryTypeConfig, "");
+      if (aiEntry.body && idIndex) {
+        aiEntry.body = resolveEntryLinksInText(aiEntry.body, idIndex, contentRoot, entryLinkUrl);
+      }
       if (config?.exclude?.where?.(aiEntry))
         continue;
       entries.push(aiEntry);
@@ -2556,7 +2802,7 @@ function docToAIEntry(doc, slug, entryTypeName, entryTypeConfig, cleanCollection
     entryType: entryTypeName,
     format: doc.format,
     data: doc.data,
-    body: doc.format !== "json" ? doc.body : void 0,
+    body: !isDataOnlyFormat(doc.format) ? doc.body : void 0,
     fields: entryTypeConfig.schema
   };
 }
@@ -2902,97 +3148,6 @@ import fs9 from "node:fs/promises";
 import path10 from "node:path";
 import { simpleGit as simpleGit2 } from "simple-git";
 
-// dist/utils/debug.js
-var LOG_LEVELS = {
-  DEBUG: 0,
-  INFO: 1,
-  WARN: 2,
-  ERROR: 3
-};
-var DebugLogger = class {
-  constructor(options = {}) {
-    this.timers = /* @__PURE__ */ new Map();
-    this.options = options;
-  }
-  shouldLog(level) {
-    const enabled = this.options.enabled ?? process.env.CANOPYCMS_DEBUG === "true";
-    if (!enabled)
-      return false;
-    const minLevel = this.options.minLevel ?? "DEBUG";
-    return LOG_LEVELS[level] >= LOG_LEVELS[minLevel];
-  }
-  formatMessage(level, category, message) {
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    const prefix = this.options.prefix ?? "CanopyCMS";
-    return `[${timestamp}] [${prefix}:${category}] [${level}] ${message}`;
-  }
-  debug(category, message, data) {
-    if (this.shouldLog("DEBUG")) {
-      console.log(this.formatMessage("DEBUG", category, message), data ?? "");
-    }
-  }
-  info(category, message, data) {
-    if (this.shouldLog("INFO")) {
-      console.log(this.formatMessage("INFO", category, message), data ?? "");
-    }
-  }
-  warn(category, message, data) {
-    if (this.shouldLog("WARN")) {
-      console.warn(this.formatMessage("WARN", category, message), data ?? "");
-    }
-  }
-  error(category, message, data) {
-    const msg = this.formatMessage("ERROR", category, message);
-    if (this.shouldLog("ERROR")) {
-      console.error(msg, data ?? "");
-    }
-    const throwOnError = this.options.throwOnError ?? false;
-    if (throwOnError) {
-      const errorMsg = data ? `${message}: ${JSON.stringify(data)}` : message;
-      throw new Error(errorMsg);
-    }
-  }
-  /**
-   * Start timing an operation
-   */
-  time(label) {
-    this.timers.set(label, Date.now());
-  }
-  /**
-   * End timing an operation and log the duration
-   */
-  timeEnd(category, label) {
-    const start = this.timers.get(label);
-    if (start === void 0) {
-      this.warn(category, `Timer '${label}' does not exist`);
-      return;
-    }
-    const duration = Date.now() - start;
-    this.timers.delete(label);
-    this.debug(category, `${label} completed`, { durationMs: duration });
-    return duration;
-  }
-  /**
-   * Wrap an async function with automatic timing
-   */
-  async timed(category, label, fn) {
-    this.time(label);
-    try {
-      return await fn();
-    } finally {
-      this.timeEnd(category, label);
-    }
-  }
-};
-function createDebugLogger(options) {
-  return new DebugLogger(options);
-}
-var testLogger = createDebugLogger({
-  enabled: process.env.E2E_DEBUG === "true",
-  prefix: "E2E",
-  throwOnError: false
-});
-
 // dist/utils/git.js
 import { simpleGit } from "simple-git";
 async function detectHeadBranch(repoRoot, fallback = "main") {
@@ -3006,7 +3161,7 @@ async function detectHeadBranch(repoRoot, fallback = "main") {
 }
 
 // dist/git-manager.js
-var log = createDebugLogger({ prefix: "GitManager" });
+var log2 = createDebugLogger({ prefix: "GitManager" });
 var remoteInitLocks = /* @__PURE__ */ new Map();
 var GitManager = class _GitManager {
   constructor(options, gitOptions) {
@@ -3017,14 +3172,14 @@ var GitManager = class _GitManager {
     this.git.env("GIT_CEILING_DIRECTORIES", path10.dirname(this.repoPath));
   }
   static async cloneRepo(remoteUrl, targetPath, baseBranch = "main") {
-    log.debug("git", "Cloning repository", {
+    log2.debug("git", "Cloning repository", {
       remoteUrl,
       targetPath,
       baseBranch
     });
     const git = simpleGit2();
     await git.clone(remoteUrl, targetPath, ["--branch", baseBranch, "--single-branch"]);
-    log.debug("git", "Clone complete");
+    log2.debug("git", "Clone complete");
   }
   /**
    * Initializes a local bare git repository to simulate a remote for dev mode.
@@ -3040,32 +3195,32 @@ var GitManager = class _GitManager {
   static async ensureLocalSimulatedRemote(options) {
     const existingLock = remoteInitLocks.get(options.remotePath);
     if (existingLock) {
-      log.debug("git", "Waiting for existing remote initialization", {
+      log2.debug("git", "Waiting for existing remote initialization", {
         remotePath: options.remotePath
       });
       await existingLock;
       try {
         const stat = await fs9.stat(options.remotePath);
         if (stat.isDirectory()) {
-          log.debug("git", "Remote exists after waiting for lock");
+          log2.debug("git", "Remote exists after waiting for lock");
           return;
         }
       } catch (err) {
         if (!isNotFoundError(err))
           throw err;
-        log.debug("git", "Remote does not exist after lock, will retry initialization");
+        log2.debug("git", "Remote does not exist after lock, will retry initialization");
       }
     }
-    const lockPromise = log.timed("git", "ensureLocalSimulatedRemote", async () => {
+    const lockPromise = log2.timed("git", "ensureLocalSimulatedRemote", async () => {
       try {
-        log.debug("git", "Initializing local simulated remote", {
+        log2.debug("git", "Initializing local simulated remote", {
           remotePath: options.remotePath,
           baseBranch: options.baseBranch
         });
         try {
           const stat = await fs9.stat(options.remotePath);
           if (stat.isDirectory()) {
-            log.debug("git", "Remote already exists, skipping");
+            log2.debug("git", "Remote already exists, skipping");
             return;
           }
         } catch (err) {
@@ -3088,8 +3243,8 @@ var GitManager = class _GitManager {
         }
         let hasCommits = false;
         try {
-          const log3 = await sourceGit.log(["-1"]);
-          hasCommits = log3.total > 0;
+          const log4 = await sourceGit.log(["-1"]);
+          hasCommits = log4.total > 0;
         } catch {
           hasCommits = false;
         }
@@ -3100,7 +3255,7 @@ var GitManager = class _GitManager {
         if (!branches.all.includes(options.baseBranch)) {
           throw new Error(`Cannot initialize local simulated remote: base branch '${options.baseBranch}' does not exist locally. Please checkout '${options.baseBranch}' first or provide an explicit remoteUrl.`);
         }
-        log.debug("git", "Creating bare remote repository");
+        log2.debug("git", "Creating bare remote repository");
         await fs9.mkdir(path10.dirname(options.remotePath), { recursive: true });
         await simpleGit2().raw([
           "init",
@@ -3140,7 +3295,7 @@ var GitManager = class _GitManager {
           } catch {
           }
         }
-        log.debug("git", "Remote initialization complete");
+        log2.debug("git", "Remote initialization complete");
       } finally {
         remoteInitLocks.delete(options.remotePath);
       }
@@ -3209,7 +3364,7 @@ var GitManager = class _GitManager {
       try {
         const stat = await fs9.stat(config.autoDetectRemotePath);
         if (stat.isDirectory()) {
-          log.debug("git", "Auto-detected local remote", {
+          log2.debug("git", "Auto-detected local remote", {
             path: config.autoDetectRemotePath
           });
           return config.autoDetectRemotePath;
@@ -3262,7 +3417,7 @@ var GitManager = class _GitManager {
       try {
         const stat = await fs9.stat(gitPath);
         if (stat.isDirectory()) {
-          log.debug("git", "Removing corrupt .git directory", {
+          log2.debug("git", "Removing corrupt .git directory", {
             workspacePath: options.workspacePath
           });
           await fs9.rm(gitPath, { recursive: true });
@@ -3300,7 +3455,7 @@ var GitManager = class _GitManager {
     await git.git.addConfig("canopycms.managed", "true");
     await git.git.addConfig("user.name", options.gitBotAuthorName);
     await git.git.addConfig("user.email", options.gitBotAuthorEmail);
-    log.debug("git", "Marked workspace as CanopyCMS-managed", {
+    log2.debug("git", "Marked workspace as CanopyCMS-managed", {
       workspacePath: options.workspacePath
     });
     if (!justCloned) {
@@ -3463,13 +3618,13 @@ var GitManager = class _GitManager {
     }
     const lines = content.split("\n");
     if (lines.some((line) => line.trim() === pattern)) {
-      log.debug("git", "Pattern already in .git/info/exclude", { pattern });
+      log2.debug("git", "Pattern already in .git/info/exclude", { pattern });
       return;
     }
     const needsLeadingNewline = content.length > 0 && !content.endsWith("\n");
     const newContent = content + (needsLeadingNewline ? "\n" : "") + pattern + "\n";
     await fs9.writeFile(excludePath, newContent, "utf-8");
-    log.debug("git", "Added pattern to .git/info/exclude", { pattern });
+    log2.debug("git", "Added pattern to .git/info/exclude", { pattern });
   }
   /**
    * Create an orphan branch for settings (permissions/groups).
@@ -3483,10 +3638,10 @@ var GitManager = class _GitManager {
    * @param initialFiles - Files to commit to the new branch (e.g., { 'permissions.json': '{}', 'groups.json': '{}' })
    */
   async createOrphanSettingsBranch(branchName, initialFiles) {
-    log.debug("git", "Creating orphan settings branch", { branchName });
+    log2.debug("git", "Creating orphan settings branch", { branchName });
     const branches = await this.git.branch();
     if (branches.all.includes(branchName)) {
-      log.debug("git", "Orphan branch already exists", { branchName });
+      log2.debug("git", "Orphan branch already exists", { branchName });
       await this.git.checkout(branchName);
       return;
     }
@@ -3502,19 +3657,19 @@ var GitManager = class _GitManager {
       await this.git.add(filePath);
     }
     await this.git.commit("Initialize settings branch", ["--allow-empty"]);
-    log.debug("git", "Orphan settings branch created", { branchName });
+    log2.debug("git", "Orphan settings branch created", { branchName });
   }
 };
 
 // dist/branch-workspace.js
-var log2 = createDebugLogger({ prefix: "BranchWorkspace" });
+var log3 = createDebugLogger({ prefix: "BranchWorkspace" });
 var workspaceInitLocks = /* @__PURE__ */ new Map();
 var BranchWorkspaceManager = class {
   constructor(config) {
     this.config = config;
   }
   async ensureGitWorkspace(options) {
-    return log2.timed("workspace", "ensureGitWorkspace", async () => {
+    return log3.timed("workspace", "ensureGitWorkspace", async () => {
       const existingLock = workspaceInitLocks.get(options.branchRoot);
       if (existingLock) {
         await existingLock;
@@ -3522,7 +3677,7 @@ var BranchWorkspaceManager = class {
       }
       const lockPromise = (async () => {
         try {
-          log2.debug("workspace", "Ensuring git workspace", {
+          log3.debug("workspace", "Ensuring git workspace", {
             branchName: options.branchName,
             mode: options.mode
           });
@@ -3651,7 +3806,8 @@ async function generateAIContentFiles(options) {
     store,
     flatSchema,
     contentRoot: contentRootName,
-    config: aiConfig
+    config: aiConfig,
+    entryLinkUrl: config.entryLinkUrl
   });
   const absoluteOutputDir = path11.resolve(outputDir) + path11.sep;
   let fileCount = 0;