@anokye-labs/kbexplorer-engine 0.1.0

package/dist/chunk-NOGBKE7C.js

@@ -0,0 +1,351 @@
+import { collectNodemapData, resolveStructuredContentPath, hasExplicitStructuredContentPath } from './chunk-XVI6CBSX.js';
+import { loadConfig, fetchFile, fetchIssues, fetchReleases, fetchBranches, fetchRepoMetadata, fetchTree, fetchPullRequests, fetchFiles, fetchCommits } from './chunk-FJ4GTN4U.js';
+import { STAGING_AREA_REL } from '@anokye-labs/kbexplorer-core';
+
+function isStructuralPath(path) {
+  return path.startsWith(".github/") || /(^|\/)CODEOWNERS$/.test(path);
+}
+var MAX_STRUCTURAL_FILE_SIZE = 256 * 1024;
+async function fetchStructuredNodeMap(source, env, cache) {
+  for (const name of ["structured-node-map.yaml", "structured-node-map.yml"]) {
+    try {
+      return await fetchFile(source, name, env, cache);
+    } catch {
+    }
+  }
+  return null;
+}
+async function fetchNodemapRaw(source, env, cache) {
+  for (const name of ["nodemap.yaml", "nodemap.yml"]) {
+    try {
+      return await fetchFile(source, name, env, cache);
+    } catch {
+    }
+  }
+  return null;
+}
+var GitHubApiSource = class {
+  id = "github-api";
+  name = "GitHub API";
+  /** Advisory universe; authoritative affordances live on each retrieval. */
+  possibleAffordances = ["read", "write", "stage", "comment", "close", "merge"];
+  fetchPromise = null;
+  source;
+  preset;
+  env;
+  cache;
+  constructor(source, preset = "standard", env, cache) {
+    this.source = source;
+    this.preset = preset;
+    this.env = env;
+    this.cache = cache;
+  }
+  /** The locator of this repo's staging area (git index). */
+  get stagingHref() {
+    return `git://${this.source.repo}/.git/index`;
+  }
+  /** Fetch (memoized) so `resolveConfig` + `getRepoData` share one round-trip. */
+  fetch() {
+    if (!this.fetchPromise) this.fetchPromise = this.fetchGitHubData();
+    return this.fetchPromise;
+  }
+  /** Resolve the config without re-fetching. */
+  async resolveConfig() {
+    return (await this.fetch()).config;
+  }
+  async resolveThemeFileRaw() {
+    return (await this.fetch()).themeFileRaw;
+  }
+  async getRepoData() {
+    const data = await this.fetch();
+    return {
+      repo: this.source.repo,
+      tree: data.tree,
+      authoredContent: data.authoredContent,
+      nodemapRaw: data.nodemapRaw,
+      // `nodemapFiles`/`nodemapDirs` are omitted (rather than assigned empty
+      // objects) when there's nothing to report — this package enables
+      // exactOptionalPropertyTypes, and the loader/manifest convention is to
+      // leave optional fields unset rather than emit noisy `{}`.
+      ...Object.keys(data.nodemapFiles).length > 0 ? { nodemapFiles: data.nodemapFiles } : {},
+      ...Object.keys(data.nodemapDirs).length > 0 ? { nodemapDirs: data.nodemapDirs } : {},
+      listFiles: async () => [],
+      issues: data.issues,
+      // Reproduce the former remote shaping: no head_branch (so WorkProvider
+      // emits no branch connections), user/assignees retained for people.
+      // (user/assignees are set conditionally because this package's config
+      // enables exactOptionalPropertyTypes — an explicit `undefined` value is
+      // not assignable to the optional target fields.)
+      pullRequests: data.pullRequests.map((pr) => {
+        const mapped = {
+          number: pr.number,
+          title: pr.title,
+          body: pr.body ?? "",
+          state: pr.state,
+          labels: pr.labels.map((l) => ({ name: l.name, color: l.color ?? "" })),
+          html_url: pr.html_url,
+          created_at: pr.created_at,
+          updated_at: pr.updated_at
+        };
+        if (pr.user) mapped.user = pr.user;
+        if (pr.assignees) mapped.assignees = pr.assignees;
+        return mapped;
+      }),
+      commits: data.commits,
+      branches: data.branches,
+      repoMetadata: data.repoMetadata,
+      releases: data.releases,
+      structuralFiles: data.structuralFiles,
+      structuredNodeMapRaw: data.structuredNodeMapRaw,
+      contentModel: data.contentModel ?? null,
+      readme: data.readme,
+      themeFileRaw: data.themeFileRaw
+    };
+  }
+  // ── Formal resource surface (Git ≠ GitHub, per-retrieval affordances) ─────
+  async retrieve(query) {
+    const data = await this.fetch();
+    const kind = query.kind;
+    const worktree = query.worktree === true;
+    const staged = query.staged === true;
+    const out = [];
+    if (kind === "staging-area") {
+      out.push(this.stagingAreaResource());
+      return out;
+    }
+    if (!kind || kind === "file" || kind === "tree") {
+      for (const item of data.tree) {
+        if (kind === "file" && item.type !== "blob") continue;
+        if (kind === "tree" && item.type !== "tree") continue;
+        out.push(this.gitFileResource(item, { worktree, staged }));
+      }
+    }
+    if (!kind || kind === "commit") {
+      for (const c of data.commits) out.push(this.commitResource(c));
+    }
+    if (!kind || kind === "issue") {
+      for (const issue of data.issues) out.push(this.issueResource(issue));
+    }
+    if (!kind || kind === "pull-request") {
+      for (const pr of data.pullRequests) out.push(this.pullRequestResource(pr));
+    }
+    if (!kind || kind === "release") {
+      for (const r of data.releases) out.push(this.releaseResource(r));
+    }
+    return out;
+  }
+  async get(href) {
+    if (href === this.stagingHref) return this.stagingAreaResource();
+    const all = await this.retrieve({});
+    return all.find((r) => r.href === href);
+  }
+  /**
+   * A git file/tree resource. Affordances are situational:
+   *  - plain read → `['read']`
+   *  - writable worktree → `['read','write','stage']`
+   *  - staged → `['read','write','stage']` PLUS a `staging-area` link.
+   */
+  gitFileResource(item, ctx) {
+    const href = `git://${this.source.repo}/${item.path}`;
+    const affordances = ctx.worktree || ctx.staged ? ["read", "write", "stage"] : ["read"];
+    const links = [{ rel: "self", href }];
+    if (ctx.staged) {
+      links.push({ rel: STAGING_AREA_REL, href: this.stagingHref });
+    }
+    return { href, kind: item.type === "tree" ? "tree" : "file", affordances, links, body: { path: item.path } };
+  }
+  stagingAreaResource() {
+    return {
+      href: this.stagingHref,
+      kind: "staging-area",
+      affordances: ["read", "stage"],
+      links: [{ rel: "self", href: this.stagingHref }],
+      body: { repo: this.source.repo }
+    };
+  }
+  commitResource(c) {
+    const href = `git://${this.source.repo}/commit/${c.sha}`;
+    return {
+      href,
+      kind: "commit",
+      affordances: ["read"],
+      links: [{ rel: "self", href }],
+      body: { sha: c.sha, message: c.commit.message }
+    };
+  }
+  issueResource(issue) {
+    const href = `github://${this.source.repo}/issues/${issue.number}`;
+    return {
+      href,
+      kind: "issue",
+      affordances: ["read", "comment", "close"],
+      links: [{ rel: "self", href }],
+      body: { number: issue.number, title: issue.title, state: issue.state }
+    };
+  }
+  pullRequestResource(pr) {
+    const href = `github://${this.source.repo}/pull/${pr.number}`;
+    return {
+      href,
+      kind: "pull-request",
+      affordances: ["read", "comment", "close", "merge"],
+      links: [{ rel: "self", href }],
+      body: { number: pr.number, title: pr.title, state: pr.state }
+    };
+  }
+  releaseResource(r) {
+    const href = `github://${this.source.repo}/releases/${r.tag_name}`;
+    return {
+      href,
+      kind: "release",
+      affordances: ["read"],
+      links: [{ rel: "self", href }],
+      body: { tag: r.tag_name }
+    };
+  }
+  // ── Data path (moved verbatim from the former remote loader) ──────────────
+  async fetchGitHubData() {
+    const source = this.source;
+    const preset = this.preset;
+    const env = this.env;
+    const cache = this.cache;
+    const config = await loadConfig(source, env, cache);
+    const themeFilePromise = config.theme?.themesFile ? fetchFile(source, config.theme.themesFile, env, cache).catch(() => null) : Promise.resolve(null);
+    const [issues, readme, releases, themeFileRaw, branches, repoMetadata, nodemapRaw] = await Promise.all([
+      fetchIssues(source, env, cache).catch(() => []),
+      fetchFile(source, "README.md", env, cache).catch(() => null),
+      fetchReleases(source, 30, env, cache).catch(() => []),
+      themeFilePromise,
+      fetchBranches(source, env, cache).catch(() => []),
+      fetchRepoMetadata(source, env, cache).catch(() => null),
+      fetchNodemapRaw(source, env, cache)
+    ]);
+    let tree = [];
+    let pullRequests = [];
+    let commits = [];
+    const authoredContent = {};
+    const structuralFiles = {};
+    let structuredNodeMapRaw = null;
+    let contentModel = null;
+    let nodemapFiles = {};
+    let nodemapDirs = {};
+    if (preset === "standard" || preset === "full") {
+      const [treeResult, prResult] = await Promise.all([
+        fetchTree(source, void 0, env, cache).catch(() => []),
+        fetchPullRequests(source, env, cache).catch(() => [])
+      ]);
+      tree = treeResult;
+      pullRequests = prResult;
+      if (config.source.path) {
+        try {
+          const contentTree = await fetchTree(source, config.source.path, env, cache);
+          const mdFiles = contentTree.filter((item) => item.type === "blob" && item.path.endsWith(".md")).map((item) => item.path);
+          const files = await fetchFiles(source, mdFiles, env, cache);
+          for (const [path, content] of files) {
+            authoredContent[path] = content;
+          }
+        } catch {
+        }
+      }
+      contentModel = await this.fetchContentModel(config);
+      try {
+        const structuralPaths = tree.filter(
+          (item) => item.type === "blob" && isStructuralPath(item.path) && !(typeof item.size === "number" && item.size > MAX_STRUCTURAL_FILE_SIZE)
+        ).map((item) => item.path);
+        if (structuralPaths.length > 0) {
+          const files = await fetchFiles(source, structuralPaths, env, cache);
+          for (const [path, content] of files) {
+            if (content.length > MAX_STRUCTURAL_FILE_SIZE) continue;
+            structuralFiles[path] = content;
+          }
+        }
+        structuredNodeMapRaw = await fetchStructuredNodeMap(source, env, cache);
+      } catch {
+      }
+      if (nodemapRaw !== null) {
+        try {
+          const collected = await collectNodemapData(
+            nodemapRaw,
+            tree,
+            (path) => fetchFile(source, path, env, cache).catch(() => null),
+            (dir) => this.listNodemapDirFromTree(tree, dir)
+          );
+          nodemapFiles = collected.nodemapFiles;
+          nodemapDirs = collected.nodemapDirs;
+        } catch {
+        }
+      }
+    }
+    if (preset === "full") {
+      commits = await fetchCommits(source, 50, env, cache).catch(() => []);
+    }
+    return {
+      issues,
+      pullRequests,
+      tree,
+      readme,
+      commits,
+      releases,
+      branches,
+      repoMetadata,
+      authoredContent,
+      structuralFiles,
+      structuredNodeMapRaw,
+      contentModel,
+      config,
+      themeFileRaw: themeFileRaw ?? null,
+      nodemapRaw,
+      nodemapFiles,
+      nodemapDirs
+    };
+  }
+  /**
+   * Direct children of `dir` in an already-fetched git tree — a nodemap
+   * `directory:` entry's listing derived with no extra API call. Skips
+   * dotfile-named children, mirroring the local source's `listNodemapDir`.
+   */
+  listNodemapDirFromTree(tree, dir) {
+    const prefix = `${dir}/`;
+    const out = tree.filter((item) => {
+      if (!item.path.startsWith(prefix)) return false;
+      const rest = item.path.slice(prefix.length);
+      if (rest === "" || rest.includes("/")) return false;
+      return !rest.startsWith(".");
+    });
+    return Promise.resolve(out);
+  }
+  async fetchContentModel(config) {
+    const env = this.env;
+    const cache = this.cache;
+    const root = resolveStructuredContentPath(config, env);
+    const explicitPath = hasExplicitStructuredContentPath(config, env);
+    try {
+      const contentModelTree = await fetchTree(this.source, root, env, cache);
+      const paths = contentModelTree.filter((item) => item.type === "blob").map((item) => item.path).filter((path) => !path.slice(root.length + 1).split("/").some((segment) => segment.startsWith(".")));
+      if (paths.length === 0) {
+        if (explicitPath) {
+          console.warn(`[github-api-source] No structured content files found at configured path ${root}`);
+        }
+        return null;
+      }
+      const files = await fetchFiles(this.source, paths, env, cache);
+      const sourceFiles = {};
+      for (const [path, content] of files) {
+        const relativePath = path.startsWith(`${root}/`) ? path.slice(root.length + 1) : path;
+        sourceFiles[relativePath] = content;
+      }
+      if (Object.keys(sourceFiles).length === 0) {
+        if (explicitPath) {
+          console.warn(`[github-api-source] Structured content path ${root} was listed but no files could be fetched`);
+        }
+        return null;
+      }
+      return { root, files: sourceFiles };
+    } catch (error) {
+      console.warn(`[github-api-source] Failed to fetch structured content from ${root}:`, error);
+      return null;
+    }
+  }
+};
+
+export { GitHubApiSource };