canopycms 0.0.25 → 0.0.27

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";
@@ -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";
   }
@@ -1974,6 +1984,119 @@ function stripMdxImports(body) {
   return result.join("\n").replace(/\n{3,}/g, "\n\n").trim();
 }
 
+// dist/ai/transform-components.js
+function parseComponentProps(attrString) {
+  const props = {};
+  if (!attrString)
+    return props;
+  const attrRegex = /(\w+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|\{([^}]*)\}))?/g;
+  let match;
+  while ((match = attrRegex.exec(attrString)) !== null) {
+    const name = match[1];
+    const value = match[2] ?? match[3] ?? match[4] ?? "true";
+    props[name] = value;
+  }
+  return props;
+}
+var ATTR_CONTENT = `(?:[^>"']|"[^"]*"|'[^']*')*`;
+var BLOCK_PREFIX = "<<CODEBLOCK";
+var BLOCK_SUFFIX = ">>";
+var BLOCK_RESTORE_RE = /<<CODEBLOCK(\d+)>>/g;
+var INLINE_PREFIX = "<<INLINECODE";
+var INLINE_SUFFIX = ">>";
+var INLINE_RESTORE_RE = /<<INLINECODE(\d+)>>/g;
+function maskCodeBlocks(body) {
+  const blocks = [];
+  const inlines = [];
+  let masked = body.replace(/^(```|~~~).*\n[\s\S]*?\n\1\s*$/gm, (block) => {
+    const idx = blocks.length;
+    blocks.push(block);
+    return `${BLOCK_PREFIX}${idx}${BLOCK_SUFFIX}`;
+  });
+  masked = masked.replace(/``[^`]+``|`[^`]+`/g, (span) => {
+    const idx = inlines.length;
+    inlines.push(span);
+    return `${INLINE_PREFIX}${idx}${INLINE_SUFFIX}`;
+  });
+  return {
+    masked,
+    restore: (s) => {
+      s = s.replace(INLINE_RESTORE_RE, (_, i) => inlines[Number(i)]);
+      s = s.replace(BLOCK_RESTORE_RE, (_, i) => blocks[Number(i)]);
+      return s;
+    }
+  };
+}
+function applyComponentTransforms(body, transforms) {
+  const names = Object.keys(transforms);
+  if (names.length === 0)
+    return body;
+  const { masked, restore } = maskCodeBlocks(body);
+  let result = masked;
+  const MAX_PASSES = 10;
+  for (let pass = 0; pass < MAX_PASSES; pass++) {
+    let changed = false;
+    for (const name of names) {
+      const transform = transforms[name];
+      const selfClosingRegex = new RegExp(`<${escapeRegex(name)}(\\s${ATTR_CONTENT}?)?\\s*/>`, "g");
+      result = result.replace(selfClosingRegex, (raw, attrStr) => {
+        const props = parseComponentProps(attrStr?.trim() ?? "");
+        const replacement = transform(props, "");
+        if (replacement === void 0)
+          return raw;
+        changed = true;
+        return replacement;
+      });
+      const openRegex = new RegExp(`<${escapeRegex(name)}(\\s${ATTR_CONTENT})?>`, "g");
+      let openMatch;
+      while ((openMatch = openRegex.exec(result)) !== null) {
+        const openStart = openMatch.index;
+        const openEnd = openStart + openMatch[0].length;
+        const attrStr = openMatch[1]?.trim() ?? "";
+        const closeTag = `</${name}>`;
+        const closeIdx = findMatchingClose(result, openEnd, name, closeTag);
+        if (closeIdx === -1)
+          break;
+        const children = result.slice(openEnd, closeIdx);
+        const fullEnd = closeIdx + closeTag.length;
+        const props = parseComponentProps(attrStr);
+        const replacement = transform(props, children);
+        if (replacement === void 0) {
+          openRegex.lastIndex = fullEnd;
+          continue;
+        }
+        result = result.slice(0, openStart) + replacement + result.slice(fullEnd);
+        changed = true;
+        openRegex.lastIndex = openStart + replacement.length;
+      }
+    }
+    if (!changed)
+      break;
+  }
+  return restore(result);
+}
+function findMatchingClose(body, startFrom, name, closeTag) {
+  let depth = 1;
+  const pos = startFrom;
+  const tagRegex = new RegExp(`<${escapeRegex(name)}(?:\\s${ATTR_CONTENT})?>|<${escapeRegex(name)}(?:\\s${ATTR_CONTENT})?\\s*/>|${escapeRegex(closeTag)}`, "g");
+  tagRegex.lastIndex = pos;
+  let match;
+  while ((match = tagRegex.exec(body)) !== null) {
+    const tag = match[0];
+    if (tag === closeTag) {
+      depth--;
+      if (depth === 0)
+        return match.index;
+    } else if (!tag.endsWith("/>")) {
+      depth++;
+    }
+  }
+  return -1;
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
 // dist/ai/json-to-markdown.js
 function entryToMarkdown(entry, config) {
   const parts = [];
@@ -2017,7 +2140,14 @@ function renderMarkdownEntry(entry, config, skipFields) {
     parts.push("");
   }
   if (entry.body) {
-    const body = entry.format === "mdx" ? stripMdxImports(entry.body) : entry.body;
+    let body = entry.format === "mdx" ? stripMdxImports(entry.body) : entry.body;
+    if (config?.componentTransforms && Object.keys(config.componentTransforms).length > 0) {
+      body = applyComponentTransforms(body, config.componentTransforms);
+    }
+    const bodyTransformFn = config?.bodyTransforms?.[entry.entryType];
+    if (bodyTransformFn) {
+      body = bodyTransformFn(body, entry);
+    }
     parts.push(body.trim());
     parts.push("");
   }
@@ -2246,10 +2376,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 = [];
@@ -2261,7 +2604,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);
@@ -2270,7 +2613,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);
@@ -2306,7 +2649,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);
@@ -2327,6 +2670,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);
@@ -2348,7 +2694,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);
@@ -2372,7 +2718,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 = [];
@@ -2392,6 +2738,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);
@@ -2782,97 +3131,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") {
@@ -2886,7 +3144,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) {
@@ -2897,14 +3155,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.
@@ -2920,32 +3178,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) {
@@ -2968,8 +3226,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;
         }
@@ -2980,7 +3238,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",
@@ -3020,7 +3278,7 @@ var GitManager = class _GitManager {
           } catch {
           }
         }
-        log.debug("git", "Remote initialization complete");
+        log2.debug("git", "Remote initialization complete");
       } finally {
         remoteInitLocks.delete(options.remotePath);
       }
@@ -3089,7 +3347,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;
@@ -3142,7 +3400,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 });
@@ -3180,7 +3438,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) {
@@ -3343,13 +3601,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).
@@ -3363,10 +3621,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;
     }
@@ -3382,19 +3640,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;
@@ -3402,7 +3660,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
           });
@@ -3531,7 +3789,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;