@anokye-labs/kbexplorer-engine 0.1.0

package/dist/chunk-FJ4GTN4U.js

@@ -0,0 +1,973 @@
+import { assignIdentity } from './chunk-JNQVSNLC.js';
+import { resolveAccessExclusion, DEFAULT_ACCESS_EXCLUSION, normalizeAccessLabel, coerceAccessLabel, isExcludedByDefault } from '@anokye-labs/kbexplorer-core';
+import { Marked } from 'marked';
+import sanitizeHtml from 'sanitize-html';
+import yaml from 'yaml';
+
+var TEMPLATE_SENSITIVE_CLASSIFICATIONS = /* @__PURE__ */ new Set(["restricted", "confidential", "unknown"]);
+var TEMPLATE_SENSITIVE_VISIBILITIES = /* @__PURE__ */ new Set(["private"]);
+var TEMPLATE_KNOWN_CLASSIFICATIONS = /* @__PURE__ */ new Set(["public", "internal", "confidential", "restricted", "unknown"]);
+var TEMPLATE_CORE_EXCLUSION = resolveAccessExclusion(DEFAULT_ACCESS_EXCLUSION);
+function normalizeAccessValue(value) {
+  return normalizeAccessLabel(value) ?? coerceAccessLabel(value);
+}
+function isTemplateCoreExcluded(label) {
+  if (!label) return false;
+  const classification = label.classification?.trim().toLowerCase();
+  if (classification && !TEMPLATE_KNOWN_CLASSIFICATIONS.has(classification)) {
+    return false;
+  }
+  return isExcludedByDefault(label, TEMPLATE_CORE_EXCLUSION);
+}
+function isAccessWithheld(node) {
+  const access = node.access;
+  if (!access) return false;
+  const label = normalizeAccessValue(access);
+  if (!label) return false;
+  const classification = label.classification?.trim().toLowerCase();
+  if (classification && TEMPLATE_SENSITIVE_CLASSIFICATIONS.has(classification)) {
+    return true;
+  }
+  const visibility = label.visibility?.trim().toLowerCase();
+  if (visibility && TEMPLATE_SENSITIVE_VISIBILITIES.has(visibility)) {
+    return true;
+  }
+  return isTemplateCoreExcluded(label);
+}
+function filterAccessWithheld(nodes) {
+  const kept = nodes.filter((n) => !isAccessWithheld(n));
+  return kept.length === nodes.length ? nodes : kept;
+}
+function parseAccessLabel(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const label = normalizeAccessLabel(value);
+  if (!label) return void 0;
+  const sanitized = {};
+  if (typeof label.classification === "string" && label.classification.trim()) {
+    sanitized.classification = label.classification.trim();
+  }
+  if (typeof label.visibility === "string" && label.visibility.trim()) {
+    sanitized.visibility = label.visibility.trim();
+  }
+  if (Array.isArray(label.labels)) {
+    const labels = label.labels.filter((item) => typeof item === "string" && item.trim() !== "");
+    if (labels.length > 0) sanitized.labels = labels;
+  }
+  return Object.keys(sanitized).length > 0 ? sanitized : void 0;
+}
+var SANITIZE_OPTIONS = {
+  allowedTags: [
+    // Blocks / structure
+    "p",
+    "br",
+    "hr",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "ul",
+    "ol",
+    "li",
+    "blockquote",
+    "pre",
+    "code",
+    "div",
+    "span",
+    // Inline formatting
+    "em",
+    "strong",
+    "del",
+    "a",
+    "img",
+    // Tables (GFM)
+    "table",
+    "thead",
+    "tbody",
+    "tr",
+    "td",
+    "th",
+    // Collapsible sections + theme-aware images (used in real issue/PR/README HTML)
+    "details",
+    "summary",
+    "picture",
+    "source",
+    // GFM task-list checkboxes are markdown-generated (`- [ ]` / `- [x]`)
+    "input"
+  ],
+  allowedAttributes: {
+    a: ["href", "title"],
+    img: ["src", "alt", "title", "width", "height"],
+    source: ["srcset", "media", "type", "sizes"],
+    // `start` is markdown-generated for ordered lists that don't begin at 1
+    // (`4.` → `<ol start="4">`); `reversed`/`type` are safe presentational
+    // siblings. Dropping `start` would silently reset list numbering.
+    ol: ["start", "reversed", "type"],
+    // GFM column alignment renders as `align` on the header/data cells
+    // (`|:-:|` → `<th align="center">`); the rest are safe structural/a11y
+    // attributes real HTML tables use. All are presentational — no script sink.
+    th: ["align", "colspan", "rowspan", "scope"],
+    td: ["align", "colspan", "rowspan"],
+    // Only the attributes marked emits for task-list checkboxes — no `on*`,
+    // no `src`/`formaction`, so an allowed `<input>` is inert.
+    input: ["type", "checked", "disabled"],
+    // `class` carries `language-*` on fenced code, which the diagram/mermaid
+    // detection and syntax styling read. Kept minimal — no `style`, no `id`.
+    code: ["class"],
+    pre: ["class"],
+    span: ["class"],
+    div: ["class"]
+  },
+  // URL schemes permitted on href/src/srcset after entity + whitespace
+  // normalization. Relative targets (no scheme) are always allowed; anything
+  // with a `javascript:`/`data:`/`vbscript:`/etc. scheme is dropped.
+  allowedSchemes: ["http", "https", "mailto"],
+  allowedSchemesAppliedToAttributes: ["href", "src", "srcset"],
+  // Reject protocol-relative (`//host/…`) targets — they inherit the page
+  // scheme and can point at an arbitrary host.
+  allowProtocolRelative: false,
+  // Non-allowlisted tags become visible escaped text rather than being dropped,
+  // preserving the previous renderer's "hostile markup shows as inert text"
+  // property for tags like <script>/<style>/<iframe>/<svg>.
+  disallowedTagsMode: "escape"
+};
+var markdown = new Marked();
+function renderSafeMarkdown(body) {
+  const html = markdown.parse(body, { async: false });
+  return sanitizeHtml(html, SANITIZE_OPTIONS);
+}
+
+// src/default-config.ts
+var DEFAULT_CONFIG = {
+  title: "kbexplorer",
+  subtitle: "Interactive Knowledge Base Explorer",
+  author: "Anokye Labs",
+  source: { owner: "anokye-labs", repo: "kbexplorer", path: "content", branch: "main" },
+  clusters: {
+    // Each cluster may also carry an optional `tokens` delta (Fluent token name
+    // → CSS value, same shape as theme.tokens) to shift only that cluster's
+    // scoped surfaces (cards/badges/reading header). Omitted here so defaults
+    // inherit the active global theme unchanged.
+    feature: { name: "Feature", color: "#4A9CC8" },
+    task: { name: "Task", color: "#8CB050" },
+    bug: { name: "Bug", color: "#C04040" },
+    epic: { name: "Epic", color: "#E8A838" },
+    code: { name: "Code", color: "#9A8A78" },
+    docs: { name: "Documentation", color: "#D4A050" },
+    "pull-request": { name: "Pull Request", color: "#A86FDF" },
+    commits: { name: "Commits", color: "#5A98A8" },
+    releases: { name: "Releases", color: "#F78166" }
+  },
+  visuals: {
+    mode: "emoji",
+    fallback: "emoji"
+  },
+  theme: {
+    default: "dark",
+    font: {
+      heading: "'Segoe UI Variable', 'Segoe UI', system-ui, sans-serif",
+      body: "'Segoe UI Variable', 'Segoe UI', system-ui, sans-serif",
+      mono: "'Cascadia Code', 'Cascadia Mono', Consolas, monospace"
+    }
+    // brand / tokens / themes are optional, additive overrides (see KBConfig.theme).
+    // Left unset by default so the built-in dark/light/sepia themes are unchanged.
+    // themesFile (also unset by default) may point at a dedicated theme file in the
+    // host repo (e.g. "content/themes/extra.yaml"); when set it is fetched at runtime
+    // like config.yaml and its named themes are merged into the THEME_MAP, overriding
+    // any inline theme.themes of the same name. Unset means no fetch, no behavior change.
+    // moduleUrl (also unset by default) is the most powerful escape hatch: a
+    // security-sensitive opt-in that dynamically import()s a host-provided ESM JS
+    // module exporting a Fluent Theme / BrandVariants and registers it into the
+    // THEME_MAP. Off by default, meaning no import, pure no-op. Only set it for a
+    // module you trust (ideally self-hosted in this repo) and tighten CSP accordingly
+    // — see the theming docs' CSP note.
+  },
+  graph: {
+    physics: true,
+    layout: "force-atlas-2"
+  },
+  features: {
+    hud: true,
+    minimap: true,
+    readingTools: true,
+    keyboardNav: true,
+    sparkAnimation: false,
+    search: true
+  }
+  // branding omitted by default — host repos may set branding.logo (a repo-relative
+  // image path) to render a logo on the HomePage hero and HUD header, and
+  // branding.favicon (a repo-relative image path) to swap the favicon at
+  // runtime, and branding.css (a repo-relative path or URL) to inject a raw CSS
+  // override sheet last in <head> for full control over --colorNeutral*/
+  // --colorBrand*/--kbe-* variables. Text title and the static /favicon.svg are
+  // used as graceful fallbacks; branding.css is unset by default so nothing is
+  // injected.
+};
+
+// src/github-client.ts
+var GITHUB_ENDPOINT_PATTERNS = [
+  "contents/",
+  "git/trees/",
+  "issues",
+  "pulls",
+  "commits",
+  "releases",
+  "branches",
+  "languages"
+];
+var DEFAULT_GH_API_BASE = "https://api.github.com";
+function resolveApiBase(env) {
+  return env?.VITE_GH_API_BASE ?? DEFAULT_GH_API_BASE;
+}
+async function ghFetch(path, env, etag) {
+  const headers = {
+    Accept: "application/vnd.github.v3+json"
+  };
+  const token = env?.GITHUB_TOKEN ?? env?.GH_TOKEN;
+  if (token) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  const res = await fetch(`${resolveApiBase(env)}${path}`, { headers });
+  if (res.status === 304) {
+    throw new NotModifiedError();
+  }
+  if (res.status === 403 && res.headers.get("X-RateLimit-Remaining") === "0") {
+    const reset = res.headers.get("X-RateLimit-Reset");
+    throw new RateLimitError(reset ? new Date(Number(reset) * 1e3) : void 0);
+  }
+  if (!res.ok) {
+    throw new GitHubApiError(res.status, await res.text());
+  }
+  const data = await res.json();
+  const responseEtag = res.headers.get("ETag");
+  return responseEtag ? { data, etag: responseEtag } : { data };
+}
+var NotModifiedError = class extends Error {
+  constructor() {
+    super("Not modified");
+    this.name = "NotModifiedError";
+  }
+};
+var RateLimitError = class extends Error {
+  resetAt;
+  constructor(resetAt) {
+    super(`GitHub API rate limit exceeded${resetAt ? `. Resets at ${resetAt.toISOString()}` : ""}`);
+    this.name = "RateLimitError";
+    if (resetAt) this.resetAt = resetAt;
+  }
+};
+var GitHubApiError = class extends Error {
+  status;
+  constructor(status, body) {
+    super(`GitHub API error ${status}: ${body}`);
+    this.name = "GitHubApiError";
+    this.status = status;
+  }
+};
+async function fetchFile(source, path, env, cache) {
+  const branch = source.branch ?? "main";
+  const key = `file:${source.owner}/${source.repo}:${path}`;
+  const hit = cache?.get(key);
+  if (hit !== void 0) return hit;
+  const { data } = await ghFetch(
+    `/repos/${source.owner}/${source.repo}/contents/${path}?ref=${branch}`,
+    env
+  );
+  const binary = atob(data.content);
+  const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0));
+  const decoded = new TextDecoder().decode(bytes);
+  cache?.set(key, decoded);
+  return decoded;
+}
+async function fetchTree(source, path, env, cache) {
+  const branch = source.branch ?? "main";
+  const key = `tree:${source.owner}/${source.repo}:${path ?? ""}`;
+  const hit = cache?.get(key);
+  if (hit !== void 0) return hit;
+  const { data } = await ghFetch(
+    `/repos/${source.owner}/${source.repo}/git/trees/${branch}?recursive=1`,
+    env
+  );
+  const items = path ? data.tree.filter((item) => item.path.startsWith(path + "/")) : data.tree;
+  cache?.set(key, items);
+  return items;
+}
+async function fetchIssues(source, env, cache) {
+  const key = `issues:${source.owner}/${source.repo}`;
+  const hit = cache?.get(key);
+  if (hit !== void 0) return hit;
+  const allIssues = [];
+  let page = 1;
+  const perPage = 100;
+  while (true) {
+    const { data } = await ghFetch(
+      `/repos/${source.owner}/${source.repo}/issues?state=all&per_page=${perPage}&page=${page}`,
+      env
+    );
+    const issues = data.filter((i) => !i.pull_request);
+    allIssues.push(...issues);
+    if (data.length < perPage) break;
+    page++;
+  }
+  cache?.set(key, allIssues);
+  return allIssues;
+}
+async function fetchPullRequests(source, env, cache) {
+  const key = `prs:${source.owner}/${source.repo}`;
+  const hit = cache?.get(key);
+  if (hit !== void 0) return hit;
+  const allPRs = [];
+  let page = 1;
+  const perPage = 100;
+  while (true) {
+    const { data } = await ghFetch(
+      `/repos/${source.owner}/${source.repo}/pulls?state=all&per_page=${perPage}&page=${page}`,
+      env
+    );
+    allPRs.push(...data);
+    if (data.length < perPage) break;
+    page++;
+  }
+  cache?.set(key, allPRs);
+  return allPRs;
+}
+async function fetchCommits(source, count = 30, env, cache) {
+  const key = `commits:${source.owner}/${source.repo}`;
+  const hit = cache?.get(key);
+  if (hit !== void 0) return hit;
+  const branch = source.branch ?? "main";
+  const { data } = await ghFetch(
+    `/repos/${source.owner}/${source.repo}/commits?sha=${branch}&per_page=${count}`,
+    env
+  );
+  cache?.set(key, data);
+  return data;
+}
+async function fetchReleases(source, limit = 30, env, cache) {
+  const key = `releases:${source.owner}/${source.repo}`;
+  const hit = cache?.get(key);
+  if (hit !== void 0) return hit;
+  const { data } = await ghFetch(`/repos/${source.owner}/${source.repo}/releases?per_page=${limit}`, env);
+  const releases = data.filter((r) => !r.draft).sort((a, b) => new Date(b.published_at ?? 0).getTime() - new Date(a.published_at ?? 0).getTime()).slice(0, limit).map((r) => ({
+    tag_name: r.tag_name ?? "",
+    name: r.name ?? r.tag_name ?? "",
+    body: r.body ?? "",
+    html_url: r.html_url ?? "",
+    published_at: r.published_at ?? "",
+    prerelease: r.prerelease ?? false
+  }));
+  cache?.set(key, releases);
+  return releases;
+}
+async function fetchFiles(source, paths, env, cache) {
+  const results = /* @__PURE__ */ new Map();
+  const settled = await Promise.allSettled(
+    paths.map(async (path) => {
+      const content = await fetchFile(source, path, env, cache);
+      return { path, content };
+    })
+  );
+  for (const result of settled) {
+    if (result.status === "fulfilled") {
+      results.set(result.value.path, result.value.content);
+    }
+  }
+  return results;
+}
+async function fetchBranches(source, env, cache) {
+  const key = `branches:${source.owner}/${source.repo}`;
+  const hit = cache?.get(key);
+  if (hit !== void 0) return hit;
+  const all = [];
+  let page = 1;
+  const perPage = 100;
+  while (true) {
+    const { data } = await ghFetch(
+      `/repos/${source.owner}/${source.repo}/branches?per_page=${perPage}&page=${page}`,
+      env
+    );
+    all.push(...data.map((b) => ({ name: b.name, protected: b.protected ?? false })));
+    if (data.length < perPage) break;
+    page++;
+  }
+  cache?.set(key, all);
+  return all;
+}
+async function fetchRepoMetadata(source, env, cache) {
+  const key = `repoMetadata:${source.owner}/${source.repo}`;
+  const hit = cache?.get(key);
+  if (hit !== void 0) return hit;
+  const [{ data: repo }, languagesMap] = await Promise.all([
+    ghFetch(`/repos/${source.owner}/${source.repo}`, env),
+    ghFetch(`/repos/${source.owner}/${source.repo}/languages`, env).then((r) => r.data).catch(() => ({}))
+  ]);
+  const languages = Object.entries(languagesMap).sort((a, b) => b[1] - a[1]).map(([name, size]) => ({ name, size }));
+  const metadata = {
+    name: repo.name ?? "",
+    description: repo.description ?? "",
+    html_url: repo.html_url ?? "",
+    homepage: repo.homepage ?? "",
+    default_branch: repo.default_branch ?? "main",
+    stargazers_count: repo.stargazers_count ?? 0,
+    forks_count: repo.forks_count ?? 0,
+    private: repo.private ?? false,
+    topics: repo.topics ?? [],
+    primary_language: repo.language ?? "",
+    languages,
+    owner: {
+      login: repo.owner?.login ?? "",
+      avatar_url: repo.owner?.avatar_url ?? ""
+    }
+  };
+  cache?.set(key, metadata);
+  return metadata;
+}
+var DATE_FORMAT = { month: "short", day: "numeric", year: "numeric", timeZone: "UTC" };
+function buildPageTheme(fm) {
+  const page = {};
+  if (typeof fm.accent === "string" && fm.accent.trim()) page.accent = fm.accent.trim();
+  if (typeof fm.theme === "string" && fm.theme.trim()) page.theme = fm.theme.trim();
+  if (fm.tokens && typeof fm.tokens === "object" && !Array.isArray(fm.tokens)) {
+    const tokens = {};
+    for (const [k, v] of Object.entries(fm.tokens)) {
+      if (typeof v === "string") tokens[k] = v;
+    }
+    if (Object.keys(tokens).length > 0) page.tokens = tokens;
+  }
+  return page.accent || page.theme || page.tokens ? page : void 0;
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function normalizeText(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed ? trimmed : void 0;
+}
+function normalizeWeight(value) {
+  if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  const numeric = Number(trimmed);
+  return Number.isFinite(numeric) ? numeric : void 0;
+}
+function parseAuthoredConnections(value) {
+  if (!Array.isArray(value)) return [];
+  const connections = [];
+  for (const item of value) {
+    const conn = asRecord(item);
+    if (!conn) continue;
+    const to = normalizeText(conn.to);
+    if (!to) continue;
+    const type = normalizeText(conn.type);
+    const relation = normalizeText(conn.relation);
+    const weight = normalizeWeight(conn.weight);
+    connections.push({
+      to,
+      type: type ?? "frontmatter",
+      description: typeof conn.description === "string" ? conn.description : "",
+      source: "frontmatter",
+      ...weight !== void 0 ? { weight } : {},
+      ...relation ? { relation } : {}
+    });
+  }
+  return connections;
+}
+function parseFrontmatter(raw) {
+  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+  if (!match) return { data: {}, content: raw };
+  try {
+    const data = yaml.parse(match[1]);
+    return { data: data ?? {}, content: match[2] };
+  } catch {
+    return { data: {}, content: raw };
+  }
+}
+function parseMarkdownFile(path, raw) {
+  const { data, content } = parseFrontmatter(raw);
+  const fm = data;
+  const id = fm.id ?? path.replace(/\.md$/, "").replace(/.*\//, "");
+  const html = renderSafeMarkdown(content);
+  const connections = parseAuthoredConnections(fm.connections);
+  const connectedTo = new Set(connections.map((c) => c.to));
+  for (const m of content.matchAll(/\[([^\]]+)\]\(([^)]+)\)/g)) {
+    const target = m[2].trim();
+    if (target.startsWith("http") || target.startsWith("#") || target.startsWith("/")) continue;
+    if (target.match(/\.(png|jpg|jpeg|gif|svg|webp)$/i)) continue;
+    if (connectedTo.has(target)) continue;
+    connections.push({ to: target, type: "references", description: m[1], source: "inline" });
+    connectedTo.add(target);
+  }
+  for (const m of content.matchAll(/(?:src|scripts|content|public)\/[\w./-]+\.\w+/g)) {
+    const filePath = m[0];
+    const fileNodeId = `file-${filePath}`;
+    if (connectedTo.has(fileNodeId)) continue;
+    connections.push({ to: fileNodeId, type: "references", description: `References ${filePath}`, source: "inferred" });
+    connectedTo.add(fileNodeId);
+  }
+  const sourceFileId = `file-${path}`;
+  if (!connectedTo.has(sourceFileId)) {
+    connections.push({ to: sourceFileId, type: "derived_from", description: "Derived from", source: "inferred" });
+  }
+  const node = {
+    id,
+    title: fm.title ?? id,
+    cluster: fm.cluster ?? "default",
+    content: html,
+    rawContent: content,
+    ...fm.emoji !== void 0 ? { emoji: fm.emoji } : {},
+    ...fm.image !== void 0 ? { image: fm.image } : {},
+    ...fm.sprite !== void 0 ? { sprite: fm.sprite } : {},
+    ...fm.parent !== void 0 ? { parent: fm.parent } : {},
+    derived: fm.derived === true,
+    ...fm.display !== void 0 ? { display: fm.display } : {},
+    connections,
+    source: { type: "authored", file: path }
+  };
+  const pageTheme = buildPageTheme(fm);
+  if (pageTheme) node.pageTheme = pageTheme;
+  const access = parseAccessLabel(fm.access) ?? coerceAccessLabel(fm.access);
+  if (access) node.access = access;
+  if (typeof fm.identity === "string" && fm.identity.trim()) {
+    node.identity = fm.identity.trim();
+  } else {
+    const identity = assignIdentity(node);
+    if (identity !== void 0) node.identity = identity;
+  }
+  return node;
+}
+async function loadAuthoredContent(source, contentPath, env, cache) {
+  const tree = await fetchTree(source, contentPath, env, cache);
+  const mdFiles = tree.filter((item) => item.type === "blob" && item.path.endsWith(".md")).map((item) => item.path);
+  const files = await fetchFiles(source, mdFiles, env, cache);
+  const nodes = [];
+  for (const [path, content] of files) {
+    try {
+      nodes.push(parseMarkdownFile(path, content));
+    } catch {
+      console.warn(`[kbexplorer] Failed to parse ${path}, skipping`);
+    }
+  }
+  return nodes;
+}
+var ISSUE_TYPE_ICON = {
+  epic: "Flag",
+  feature: "Sparkle",
+  task: "Wrench",
+  bug: "Bug",
+  enhancement: "Lightbulb",
+  documentation: "Document",
+  question: "QuestionCircle"
+};
+function issueIcon(labels) {
+  for (const label of labels) {
+    const lower = label.toLowerCase();
+    if (ISSUE_TYPE_ICON[lower]) return ISSUE_TYPE_ICON[lower];
+  }
+  return "Pin";
+}
+function extractIssueRefs(body) {
+  if (!body) return [];
+  const matches = body.matchAll(/#(\d+)/g);
+  return [...matches].map((m) => Number(m[1]));
+}
+function issueToNode(issue, options = {}) {
+  const labels = issue.labels.map((l) => l.name);
+  const cluster = "work";
+  const body = issue.body ?? "";
+  const remappedBody = body.replace(/https?:\/\/github\.com\/[^/]+\/[^/]+\/issues\/(\d+)/g, (_m, num) => `issue-${num}`).replace(/https?:\/\/github\.com\/[^/]+\/[^/]+\/pull\/(\d+)/g, (_m, num) => `pr-${num}`);
+  const refs = extractIssueRefs(body);
+  const stateEmoji = issue.state === "open" ? "\u{1F7E2}" : "\u{1F7E3}";
+  const labelBadges = labels.map((l) => `\`${l}\``).join(" ");
+  const assigneeList = issue.assignees?.length ? issue.assignees.map((a) => `@${a.login}`).join(", ") : "";
+  const created = new Date(issue.created_at).toLocaleDateString("en-US", DATE_FORMAT);
+  const updated = new Date(issue.updated_at).toLocaleDateString("en-US", DATE_FORMAT);
+  const metaLines = [
+    `${stateEmoji} **${issue.state.toUpperCase()}** \xB7 #${issue.number}`,
+    labelBadges ? `Labels: ${labelBadges}` : "",
+    assigneeList ? `Assignees: ${assigneeList}` : "",
+    `Created: ${created} \xB7 Updated: ${updated}`,
+    `[View on GitHub \u2197](${issue.html_url})`
+  ].filter(Boolean).join("\n\n");
+  const fullContent = `${metaLines}
+
+---
+
+${remappedBody}`;
+  const html = renderSafeMarkdown(fullContent);
+  const connections = [];
+  const seen = /* @__PURE__ */ new Set();
+  const { knownIssueNumbers, knownPrNumbers, repoNodeId } = options;
+  for (const n of refs) {
+    if (n === issue.number) continue;
+    if (knownIssueNumbers && knownIssueNumbers.has(n)) {
+      const to = `issue-${n}`;
+      if (!seen.has(to)) {
+        connections.push({ to, type: "cross_references", description: `References #${n}`, source: "inline" });
+        seen.add(to);
+      }
+    } else if (knownPrNumbers && knownPrNumbers.has(n)) {
+      const to = `pr-${n}`;
+      if (!seen.has(to)) {
+        connections.push({ to, type: "cross_references", description: `References #${n}`, source: "inline" });
+        seen.add(to);
+      }
+    } else if (!knownIssueNumbers && !knownPrNumbers) {
+      const to = `issue-${n}`;
+      if (!seen.has(to)) {
+        connections.push({ to, type: "cross_references", description: `References #${n}`, source: "inline" });
+        seen.add(to);
+      }
+    }
+  }
+  if (repoNodeId) {
+    connections.push({
+      to: repoNodeId,
+      type: "contains",
+      relation: "tracked-in",
+      description: "Tracked in repository",
+      source: "inferred"
+    });
+  }
+  const node = {
+    id: `issue-${issue.number}`,
+    title: issue.title,
+    cluster,
+    content: html,
+    rawContent: fullContent,
+    emoji: issueIcon(labels),
+    connections,
+    source: { type: "issue", number: issue.number, state: issue.state, labels }
+  };
+  if (repoNodeId) node.parent = repoNodeId;
+  const issueIdentity = assignIdentity(node);
+  if (issueIdentity !== void 0) node.identity = issueIdentity;
+  return node;
+}
+function splitIntoSections(parentId, parentTitle, rawContent, cluster, emoji, source, allNodes) {
+  const lines = rawContent.split("\n");
+  const sections = [];
+  let currentSection = null;
+  const introLines = [];
+  for (const line of lines) {
+    const headingMatch = line.match(/^##\s+(.+)/);
+    if (headingMatch) {
+      if (currentSection) sections.push(currentSection);
+      currentSection = { title: headingMatch[1].trim(), lines: [] };
+    } else if (currentSection) {
+      currentSection.lines.push(line);
+    } else {
+      introLines.push(line);
+    }
+  }
+  if (currentSection) sections.push(currentSection);
+  if (sections.length < 2) return [];
+  const result = [];
+  const introContent = introLines.join("\n").trim();
+  const introHtml = introContent ? renderSafeMarkdown(introContent) : "";
+  const sectionIds = sections.map((s, i) => `${parentId}/${slugify(s.title, i)}`);
+  const parentNode = {
+    id: parentId,
+    title: parentTitle,
+    cluster,
+    content: introHtml,
+    rawContent: introContent,
+    emoji,
+    nodeType: "parent",
+    connections: sectionIds.map((sid) => ({ to: sid, type: "contains", description: "Contains", source: "inferred" })),
+    source
+  };
+  const lower = rawContent.toLowerCase();
+  for (const n of allNodes) {
+    if (n.id === parentId) continue;
+    const titleWords = n.title.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
+    if (titleWords.length === 0) continue;
+    const matchCount = titleWords.filter((w) => lower.includes(w)).length;
+    if (matchCount >= Math.ceil(titleWords.length * 0.6)) {
+      parentNode.connections.push({ to: n.id, type: "mentions", description: "Mentions", source: "inferred" });
+    }
+  }
+  result.push(parentNode);
+  for (let i = 0; i < sections.length; i++) {
+    const s = sections[i];
+    const sectionId = sectionIds[i];
+    const sectionBody = s.lines.join("\n").trim();
+    const sectionHtml = sectionBody ? renderSafeMarkdown(sectionBody) : "";
+    const sectionNode = {
+      id: sectionId,
+      title: s.title,
+      cluster,
+      content: sectionHtml,
+      rawContent: sectionBody,
+      emoji,
+      parent: parentId,
+      nodeType: "section",
+      connections: [],
+      source
+    };
+    const sLower = sectionBody.toLowerCase();
+    const refs = extractIssueRefs(sectionBody);
+    for (const num of refs) {
+      const refId = `issue-${num}`;
+      if (allNodes.some((n) => n.id === refId)) {
+        sectionNode.connections.push({ to: refId, type: "cross_references", description: `References #${num}`, source: "inline" });
+      }
+    }
+    for (const n of allNodes) {
+      if (n.source.type === "file") {
+        const dirName = n.title.replace(/\/$/, "").toLowerCase();
+        if (sLower.includes(`${dirName}/`) || sLower.includes(`\`${dirName}\``)) {
+          sectionNode.connections.push({ to: n.id, type: "references", description: `References ${n.title}`, source: "inferred" });
+        }
+      }
+    }
+    result.push(sectionNode);
+  }
+  return result;
+}
+function slugify(title, idx) {
+  const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  return slug || `section-${idx}`;
+}
+var KEY_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".md", ".json", ".yaml", ".yml", ".css"]);
+var SKIP_FILES = /* @__PURE__ */ new Set(["package-lock.json", ".gitignore", ".eslintrc.json"]);
+function treeToNodes(tree, repoName, excludePaths) {
+  const nodes = [];
+  const dirs = /* @__PURE__ */ new Map();
+  const excludeSet = new Set(excludePaths ?? []);
+  for (const item of tree) {
+    if (item.path.startsWith(".")) continue;
+    const parts = item.path.split("/");
+    if (parts[0].startsWith(".")) continue;
+    if (excludeSet.has(parts[0])) continue;
+    if (item.type === "tree") continue;
+    const dirPath = parts.length > 1 ? parts.slice(0, Math.min(2, parts.length - 1)).join("/") : "";
+    if (dirPath) {
+      if (!dirs.has(dirPath)) dirs.set(dirPath, []);
+      dirs.get(dirPath).push(item);
+    }
+  }
+  const topDirs = [...dirs.keys()].filter((d) => !d.includes("/"));
+  const rootFiles = tree.filter((i) => i.type === "blob" && !i.path.includes("/") && !i.path.startsWith("."));
+  const rootContent = `## ${repoName}
+
+${topDirs.length} directories, ${rootFiles.length} root files`;
+  const rootHtml = renderSafeMarkdown(rootContent);
+  const rootNode = {
+    id: "repo-root",
+    title: repoName,
+    cluster: "infra",
+    content: rootHtml,
+    rawContent: rootContent,
+    emoji: "Folder",
+    nodeType: "parent",
+    connections: [],
+    source: { type: "file", path: "/" }
+  };
+  const rootIdentity = assignIdentity(rootNode);
+  if (rootIdentity !== void 0) rootNode.identity = rootIdentity;
+  nodes.push(rootNode);
+  for (const [dirPath, files] of dirs) {
+    const depth = dirPath.split("/").length;
+    const parentId = depth === 1 ? "repo-root" : `dir-${dirPath.split("/")[0]}`;
+    const fileList = files.slice(0, 15).map((f) => `- \`${f.path}\``).join("\n");
+    const content = `## ${dirPath}/
+
+${files.length} files
+
+${fileList}`;
+    const html = renderSafeMarkdown(content);
+    nodes.push({
+      id: `dir-${dirPath}`,
+      title: `${dirPath}/`,
+      cluster: "infra",
+      content: html,
+      rawContent: content,
+      emoji: "Folder",
+      parent: parentId,
+      nodeType: depth === 1 ? "parent" : "section",
+      connections: [],
+      identity: `urn:file:${dirPath}`,
+      source: { type: "file", path: dirPath }
+    });
+  }
+  for (const item of tree) {
+    if (item.type !== "blob") continue;
+    if (item.path.startsWith(".")) continue;
+    const parts = item.path.split("/");
+    if (parts[0].startsWith(".")) continue;
+    if (excludeSet.has(parts[0])) continue;
+    if (SKIP_FILES.has(parts[parts.length - 1])) continue;
+    const ext = "." + item.path.split(".").pop()?.toLowerCase();
+    if (!KEY_EXTENSIONS.has(ext)) continue;
+    if (item.path === "README.md") continue;
+    const parentDir = parts.length > 2 ? `dir-${parts[0]}/${parts[1]}` : parts.length > 1 ? `dir-${parts[0]}` : "repo-root";
+    nodes.push({
+      id: `file-${item.path}`,
+      title: parts[parts.length - 1],
+      cluster: "infra",
+      content: `<p><code>${item.path}</code></p>`,
+      rawContent: item.path,
+      emoji: "Document",
+      parent: parentDir,
+      nodeType: "section",
+      connections: [],
+      identity: `urn:file:${item.path}`,
+      source: { type: "file", path: item.path }
+    });
+  }
+  return nodes;
+}
+async function loadRepoContent(source, env, cache) {
+  const [issues, tree, readme] = await Promise.all([
+    fetchIssues(source, env, cache).catch(() => []),
+    fetchTree(source, void 0, env, cache).catch(() => []),
+    fetchFile(source, "README.md", env, cache).catch(() => null)
+  ]);
+  const nodes = [];
+  const knownIssueNumbers = new Set(issues.filter((i) => !i.pull_request).map((i) => i.number));
+  const knownPrNumbers = new Set(issues.filter((i) => i.pull_request).map((i) => i.number));
+  const issueNodes = issues.map((i) => issueToNode(i, {
+    knownIssueNumbers,
+    knownPrNumbers,
+    repoNodeId: "repo-meta"
+  }));
+  const dirNodes = treeToNodes(tree, source.repo);
+  nodes.push(...issueNodes);
+  nodes.push(...dirNodes);
+  if (readme) {
+    const readmeConns = [];
+    const lower = readme.toLowerCase();
+    const issueRefs = extractIssueRefs(readme);
+    for (const num of issueRefs) {
+      const id = `issue-${num}`;
+      if (issueNodes.some((n) => n.id === id)) {
+        readmeConns.push({ to: id, type: "cross_references", description: `References #${num}`, source: "inline" });
+      }
+    }
+    for (const node of issueNodes) {
+      if (readmeConns.some((c) => c.to === node.id)) continue;
+      const titleWords = node.title.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
+      if (titleWords.length === 0) continue;
+      const matchCount = titleWords.filter((w) => lower.includes(w)).length;
+      if (matchCount >= Math.ceil(titleWords.length * 0.6)) {
+        readmeConns.push({ to: node.id, type: "mentions", description: "Mentions", source: "inferred" });
+      }
+    }
+    for (const dir of dirNodes) {
+      const dirName = dir.title.replace(/\/$/, "");
+      if (lower.includes(`${dirName}/`) || lower.includes(`\`${dirName}\``)) {
+        readmeConns.push({ to: dir.id, type: "references", description: `References ${dirName}/`, source: "inferred" });
+      }
+    }
+    readmeConns.push({ to: "repo-root", type: "contains", description: "Documents", source: "inferred" });
+    const readmeConnectedTo = new Set(readmeConns.map((c) => c.to));
+    for (const m of readme.matchAll(/\[([^\]]+)\]\(([^)]+)\)/g)) {
+      const target = m[2]?.trim();
+      if (!target) continue;
+      if (target.startsWith("http") || target.startsWith("#") || target.startsWith("/")) continue;
+      if (target.match(/\.(png|jpg|jpeg|gif|svg|webp|md)$/i)) continue;
+      if (readmeConnectedTo.has(target)) continue;
+      readmeConns.push({ to: target, type: "references", description: m[1] ?? "", source: "inline" });
+      readmeConnectedTo.add(target);
+    }
+    const html = renderSafeMarkdown(readme);
+    nodes.push({
+      id: "readme",
+      title: "README",
+      cluster: "docs",
+      content: html,
+      rawContent: readme,
+      emoji: "Document",
+      parent: "repo-root",
+      identity: "urn:content:readme",
+      connections: readmeConns,
+      source: { type: "readme" }
+    });
+  }
+  const expandedIssues = [];
+  for (const node of issueNodes) {
+    const sectionNodes = splitIntoSections(
+      node.id,
+      node.title,
+      node.rawContent,
+      node.cluster,
+      node.emoji ?? "Pin",
+      node.source,
+      [...issueNodes, ...dirNodes]
+    );
+    if (sectionNodes.length > 0) {
+      const idx = nodes.indexOf(node);
+      if (idx >= 0) nodes.splice(idx, 1);
+      expandedIssues.push(...sectionNodes);
+    }
+  }
+  nodes.push(...expandedIssues);
+  const dirNames = dirNodes.map((d) => d.title.replace(/\/$/, ""));
+  for (const node of issueNodes) {
+    for (let i = 0; i < dirNames.length; i++) {
+      const dir = dirNames[i];
+      const dirNode = dirNodes[i];
+      if (!dir || !dirNode) continue;
+      if (node.rawContent && (node.rawContent.includes(`${dir}/`) || node.rawContent.includes(`\`${dir}\``) || node.rawContent.toLowerCase().includes(dir.toLowerCase()))) {
+        node.connections.push({ to: dirNode.id, type: "references", description: `References ${dir}/`, source: "inferred" });
+      }
+    }
+  }
+  return nodes;
+}
+function extractClusters(nodes, config) {
+  const configClusters = new Map(
+    Object.entries(config.clusters).map(([id, c]) => [id, { id, ...c }])
+  );
+  const palette = [
+    "#E8A838",
+    "#4A9CC8",
+    "#8CB050",
+    "#C07840",
+    "#D4A050",
+    "#5A98A8",
+    "#9A8A78",
+    "#C04040",
+    "#A86FDF",
+    "#39FF14",
+    "#FF6B6B",
+    "#4ECDC4"
+  ];
+  let colorIdx = 0;
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const node of nodes) {
+    if (!seenIds.has(node.cluster)) {
+      seenIds.add(node.cluster);
+      if (!configClusters.has(node.cluster)) {
+        configClusters.set(node.cluster, {
+          id: node.cluster,
+          name: node.cluster.split(/[-_]/).map((w) => w.length <= 3 ? w.toUpperCase() : w.charAt(0).toUpperCase() + w.slice(1)).join(" "),
+          color: palette[colorIdx % palette.length]
+        });
+        colorIdx++;
+      }
+    }
+  }
+  return [...configClusters.values()];
+}
+async function loadConfig(source, env, cache) {
+  try {
+    const raw = await fetchFile(
+      source,
+      source.path ? `${source.path}/config.yaml` : "content/config.yaml",
+      env,
+      cache
+    );
+    const parsed = yaml.parse(raw);
+    return { ...DEFAULT_CONFIG, ...parsed, source };
+  } catch {
+    return { ...DEFAULT_CONFIG, source };
+  }
+}
+
+export { DEFAULT_CONFIG, GITHUB_ENDPOINT_PATTERNS, GitHubApiError, NotModifiedError, RateLimitError, extractClusters, extractIssueRefs, fetchBranches, fetchCommits, fetchFile, fetchFiles, fetchIssues, fetchPullRequests, fetchReleases, fetchRepoMetadata, fetchTree, filterAccessWithheld, isAccessWithheld, issueToNode, loadAuthoredContent, loadConfig, loadRepoContent, parseAccessLabel, parseMarkdownFile, renderSafeMarkdown, splitIntoSections, treeToNodes };