ima2-gen 1.1.21 → 1.1.23

package/lib/promptImport/githubDiscovery.ts

@@ -1,309 +0,0 @@
-import { createHash } from "node:crypto";
-import { promptImportError } from "./errors.js";
-import { upsertDiscoveryCandidates } from "./discoveryRegistry.js";
-import { requireRuntimeContext } from "../runtimeContext.js";
-import type { DiscoveryRepo, PromptImportCtx } from "./types.js";
-
-import { errInfo } from "../errInfo.js";
-const GITHUB_API_HOST = "api.github.com";
-const DEFAULT_DISCOVERY_SEEDS = [
-  "gpt-image-2 prompt",
-  "image generation prompts",
-  "nano banana prompts",
-  "product photography prompt",
-  "typography image prompt",
-  "reference image prompt",
-];
-
-interface DiscoveryRateLimit {
-  limit: number | null;
-  remaining: number | null;
-  resetAt: string | null;
-}
-
-interface DiscoveryCandidate {
-  id: string;
-  repo: string;
-  owner: string | undefined;
-  name: string | undefined;
-  fullName: string;
-  htmlUrl: string | null | undefined;
-  description: string;
-  defaultBranch: string;
-  stars: number;
-  forks: number;
-  openIssues: number;
-  updatedAt: string | null | undefined;
-  pushedAt: string | null | undefined;
-  licenseSpdx: string;
-  topics: string[];
-  language: string | null | undefined;
-  score: number;
-  scoreReasons: string[];
-  warnings: string[];
-  status: string;
-  query: string;
-  discoveredAt: string;
-}
-
-interface DiscoveryContext {
-  query?: string;
-  seeds?: string[];
-}
-
-interface DiscoveryQueryOptions {
-  q?: string;
-  seeds?: string[];
-  limit?: number;
-}
-
-interface DiscoverySearchOptions {
-  q?: string;
-  seeds?: string[];
-  limit?: number;
-  maxQueries?: number;
-}
-
-function tokenize(value: unknown): string[] {
-  return String(value || "")
-    .toLowerCase()
-    .split(/[^a-z0-9가-힣-]+/i)
-    .filter(Boolean);
-}
-
-function discoveryLimits(ctx: PromptImportCtx) {
-  const limits = ctx.config?.limits as Record<string, number> | undefined;
-  return {
-    limit: limits?.promptImportDiscoverySearchLimit ?? 0,
-    maxQueries: limits?.promptImportDiscoveryMaxQueries ?? 0,
-    fetchTimeoutMs: limits?.promptImportFetchTimeoutMs ?? 0,
-  };
-}
-
-function validateGitHubApiUrl(rawUrl: string): void {
-  let url;
-  try {
-    url = new URL(rawUrl);
-  } catch {
-    throw promptImportError("GITHUB_DISCOVERY_FAILED", "GitHub discovery returned an invalid URL");
-  }
-  if (!["https:", "http:"].includes(url.protocol) || url.hostname !== GITHUB_API_HOST) {
-    throw promptImportError("GITHUB_DISCOVERY_FAILED", "GitHub discovery redirected to an unsupported host");
-  }
-}
-
-function rateLimitFromHeaders(headers: Headers): DiscoveryRateLimit {
-  const remaining = Number(headers.get("x-ratelimit-remaining") || Number.NaN);
-  const reset = Number(headers.get("x-ratelimit-reset") || Number.NaN);
-  const limit = Number(headers.get("x-ratelimit-limit") || Number.NaN);
-  return {
-    limit: Number.isFinite(limit) ? limit : null,
-    remaining: Number.isFinite(remaining) ? remaining : null,
-    resetAt: Number.isFinite(reset) ? new Date(reset * 1000).toISOString() : null,
-  };
-}
-
-function searchHeaders(ctx: PromptImportCtx): Record<string, string> {
-  const headers: Record<string, string> = {
-    Accept: "application/vnd.github+json",
-    "X-GitHub-Api-Version": "2022-11-28",
-    "User-Agent": "ima2-prompt-import-discovery",
-  };
-  const github = (ctx.config as { github?: { token?: string } } | undefined)?.github;
-  const token = github?.token;
-  if (token) headers.Authorization = `Bearer ${token}`;
-  return headers;
-}
-
-export function buildDiscoveryQueries({ q = "", seeds = [], limit = 5 }: DiscoveryQueryOptions = {}): string[] {
-  const raw = [q, ...seeds, ...DEFAULT_DISCOVERY_SEEDS]
-    .map((item) => String(item || "").trim())
-    .filter(Boolean);
-  const unique = [...new Set(raw)];
-  if (unique.length === 0) {
-    throw promptImportError("GITHUB_DISCOVERY_QUERY_EMPTY", "Discovery query is required", 422);
-  }
-  return unique.slice(0, Math.max(1, Number(limit) || 1));
-}
-
-export function scoreDiscoveryRepository(repo: DiscoveryRepo, context: DiscoveryContext = {}) {
-  const terms = tokenize([context.query, ...(context.seeds || [])].join(" "));
-  const nameText = `${repo.full_name || ""} ${repo.description || ""} ${(repo.topics || []).join(" ")}`.toLowerCase();
-  const pushedAt = repo.pushed_at ? Date.parse(repo.pushed_at) : 0;
-  const daysSincePush = pushedAt ? (Date.now() - pushedAt) / 86_400_000 : Number.POSITIVE_INFINITY;
-  const scoreReasons: string[] = [];
-  const warnings: string[] = [];
-  let score = 0;
-
-  const stars = Number(repo.stargazers_count || 0);
-  if (stars > 1000) {
-    score += 20;
-    scoreReasons.push("popular-repo");
-  } else if (stars > 100) {
-    score += 12;
-    scoreReasons.push("known-repo");
-  } else if (stars > 10) {
-    score += 5;
-    scoreReasons.push("some-stars");
-  }
-
-  if (daysSincePush <= 365) {
-    score += 10;
-    scoreReasons.push("recently-updated");
-  } else {
-    score -= 6;
-    warnings.push("stale-repo");
-  }
-
-  if (repo.license?.spdx_id) {
-    score += 8;
-    scoreReasons.push("license-present");
-  } else {
-    score -= 8;
-    warnings.push("no-license");
-  }
-
-  if (repo.archived || repo.disabled) {
-    score -= 20;
-    warnings.push("archived-or-disabled");
-  }
-  if (repo.fork) {
-    score -= 4;
-    warnings.push("fork-source");
-  }
-  if (!repo.default_branch) {
-    score -= 10;
-    warnings.push("missing-default-branch");
-  } else if (String(repo.default_branch).includes("/")) {
-    warnings.push("discovery-default-branch-unsupported");
-  }
-
-  const promptTerms = ["prompt", "image", "generation", "gpt-image", "nano", "typography", "reference"];
-  if (promptTerms.some((term) => nameText.includes(term))) {
-    score += 14;
-    scoreReasons.push("prompt-like");
-  }
-  for (const term of terms) {
-    if (term && nameText.includes(term)) score += 3;
-  }
-  if (!repo.html_url || !String(repo.html_url).startsWith("https://github.com/")) {
-    score -= 20;
-    warnings.push("non-github-url");
-  }
-
-  return { score, scoreReasons: [...new Set(scoreReasons)], warnings: [...new Set(warnings)] };
-}
-
-export function normalizeDiscoveryCandidate(repo: DiscoveryRepo, context: DiscoveryContext = {}): DiscoveryCandidate {
-  const fullName = String(repo.full_name || "").trim();
-  const [owner, name] = fullName.split("/");
-  const scored = scoreDiscoveryRepository(repo, context);
-  return {
-    id: `github:${fullName}`,
-    repo: fullName,
-    owner,
-    name,
-    fullName,
-    htmlUrl: repo.html_url,
-    description: repo.description || "",
-    defaultBranch: repo.default_branch || "main",
-    stars: Number(repo.stargazers_count || 0),
-    forks: Number(repo.forks_count || 0),
-    openIssues: Number(repo.open_issues_count || 0),
-    updatedAt: repo.updated_at || null,
-    pushedAt: repo.pushed_at || null,
-    licenseSpdx: repo.license?.spdx_id || "NOASSERTION",
-    topics: Array.isArray(repo.topics) ? repo.topics : [],
-    language: repo.language || null,
-    score: scored.score,
-    scoreReasons: scored.scoreReasons,
-    warnings: scored.warnings,
-    status: "candidate",
-    query: context.query || "",
-    discoveredAt: new Date().toISOString(),
-  };
-}
-
-export function discoveryCacheKey(input: unknown): string {
-  return createHash("sha256").update(JSON.stringify(input)).digest("hex");
-}
-
-interface SearchOneQueryResult {
-  items: DiscoveryRepo[];
-  rateLimit: DiscoveryRateLimit;
-}
-
-async function searchOneQuery(ctx: PromptImportCtx, query: string, perPage: number): Promise<SearchOneQueryResult> {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), discoveryLimits(ctx).fetchTimeoutMs);
-  const url = new URL("https://api.github.com/search/repositories");
-  url.searchParams.set("q", `${query} in:name,description`);
-  url.searchParams.set("sort", "stars");
-  url.searchParams.set("order", "desc");
-  url.searchParams.set("per_page", String(perPage));
-  try {
-    const response = await fetch(url, {
-      headers: searchHeaders(ctx),
-      signal: controller.signal,
-    });
-    validateGitHubApiUrl(response.url);
-    const rateLimit = rateLimitFromHeaders(response.headers);
-    if (response.status === 403 || response.status === 429) {
-      throw promptImportError("GITHUB_RATE_LIMITED", "GitHub discovery rate limit reached", 429);
-    }
-    if (!response.ok) {
-      throw promptImportError("GITHUB_DISCOVERY_FAILED", `GitHub discovery failed with ${response.status}`, 422);
-    }
-    const data = (await response.json()) as { items?: DiscoveryRepo[] };
-    const items = Array.isArray(data.items) ? data.items : [];
-    return { items, rateLimit };
-  } catch (error) {
-    const err = errInfo(error);
-    if (err.name === "AbortError") {
-      throw promptImportError("REMOTE_FETCH_TIMEOUT", "GitHub discovery timed out", 504);
-    }
-    throw error;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-export async function searchGitHubDiscovery(ctxIn: PromptImportCtx, options: DiscoverySearchOptions = {}) {
-  const ctx = requireRuntimeContext(ctxIn);
-  const limits = discoveryLimits(ctx);
-  const queryLimit = Math.min(Number(options.maxQueries) || limits.maxQueries, limits.maxQueries);
-  const queries = buildDiscoveryQueries({
-    q: options.q,
-    seeds: options.seeds,
-    limit: queryLimit,
-  });
-  const requestedLimit = Math.min(Number(options.limit) || limits.limit, limits.limit);
-  const perQuery = Math.max(1, Math.ceil(requestedLimit / queries.length));
-  const warnings: string[] = [];
-  let rateLimit: DiscoveryRateLimit | null = null;
-  const byRepo = new Map<string, DiscoveryCandidate>();
-
-  for (const query of queries) {
-    const result = await searchOneQuery(ctx, query, perQuery);
-    rateLimit = result.rateLimit;
-    for (const repo of result.items) {
-      const candidate = normalizeDiscoveryCandidate(repo, {
-        query,
-        seeds: options.seeds,
-      });
-      const existing = byRepo.get(candidate.fullName);
-      if (!existing || candidate.score > existing.score) {
-        byRepo.set(candidate.fullName, candidate);
-      }
-    }
-  }
-
-  const candidates = [...byRepo.values()]
-    .filter((candidate) => candidate.fullName && candidate.htmlUrl?.startsWith("https://github.com/"))
-    .sort((a, b) => b.score - a.score || b.stars - a.stars)
-    .slice(0, requestedLimit);
-
-  await upsertDiscoveryCandidates(ctx, candidates);
-  if (rateLimit?.remaining === 0) warnings.push("github-rate-limit-exhausted");
-  return { candidates, warnings, rateLimit, cacheKey: discoveryCacheKey({ queries, requestedLimit }) };
-}

package/lib/promptImport/githubFolder.ts

@@ -1,397 +0,0 @@
-import { createHash } from "node:crypto";
-import { promptImportError } from "./errors.js";
-import type { PromptImportLimits } from "./types.js";
-
-import { errInfo } from "../errInfo.js";
-const GITHUB_HOST = "github.com";
-const GITHUB_API_HOST = "api.github.com";
-const RAW_HOST = "raw.githubusercontent.com";
-const SUPPORTED_EXTENSIONS = new Set(["md", "markdown", "txt"]);
-const OWNER_REPO_RE = /^[A-Za-z0-9_.-]+$/;
-
-export interface GitHubFolderSource {
-  kind: "github-folder";
-  owner: string;
-  repo: string;
-  ref: string;
-  path: string;
-  htmlUrl: string;
-  apiUrl: string;
-  tags: string[];
-  fromTreeUrl: boolean;
-  ambiguousTree: boolean;
-}
-
-export interface GitHubFolderFile {
-  name: string;
-  path: string;
-  extension: string;
-  sizeBytes: number;
-  htmlUrl: string;
-  downloadUrl: string;
-  selected: boolean;
-  warnings: string[];
-}
-
-interface GitHubFolderItemRaw {
-  type?: unknown;
-  path?: unknown;
-  name?: unknown;
-  size?: unknown;
-  html_url?: unknown;
-  download_url?: unknown;
-}
-
-function safeDecode(value: string): string {
-  try {
-    return decodeURIComponent(value);
-  } catch {
-    throw promptImportError("INVALID_GITHUB_SOURCE", "Invalid encoded GitHub folder path");
-  }
-}
-
-function safePath(path: unknown): string {
-  const raw = String(path || "").trim();
-  const lower = raw.toLowerCase();
-  if (raw.includes("\0") || lower.includes("%00")) {
-    throw promptImportError("INVALID_GITHUB_SOURCE", "GitHub folder path contains a null byte");
-  }
-  if (/%2f|%5c/i.test(raw)) {
-    throw promptImportError("INVALID_GITHUB_SOURCE", "GitHub folder path contains an encoded slash");
-  }
-  const decoded = safeDecode(raw);
-  if (decoded.includes("\\") || decoded.split("/").includes("..")) {
-    throw promptImportError("INVALID_GITHUB_SOURCE", "GitHub folder traversal is not allowed");
-  }
-  return decoded.replace(/^\/+|\/+$/g, "");
-}
-
-function assertOwnerRepo(owner: string | undefined, repo: string | undefined): void {
-  if (!OWNER_REPO_RE.test(owner || "") || !OWNER_REPO_RE.test(repo || "")) {
-    throw promptImportError("INVALID_GITHUB_SOURCE", "Invalid GitHub owner or repository");
-  }
-}
-
-function extensionForPath(path: string): string {
-  const match = /\.([A-Za-z0-9]+)$/.exec(path);
-  return match?.[1]?.toLowerCase() ?? "";
-}
-
-function supportedExtension(path: string): string {
-  const extension = extensionForPath(path);
-  return SUPPORTED_EXTENSIONS.has(extension) ? extension : "";
-}
-
-function encodeApiPath(path: string): string {
-  return path
-    .split("/")
-    .filter(Boolean)
-    .map((part) => encodeURIComponent(part))
-    .join("/");
-}
-
-interface BuildApiUrlInput {
-  owner: string;
-  repo: string;
-  ref: string;
-  path: string;
-}
-
-function buildApiUrl({ owner, repo, ref, path }: BuildApiUrlInput): string {
-  const encodedPath = encodeApiPath(path);
-  const suffix = encodedPath ? `/${encodedPath}` : "";
-  return `https://${GITHUB_API_HOST}/repos/${owner}/${repo}/contents${suffix}?ref=${encodeURIComponent(ref)}`;
-}
-
-function folderTags(source: GitHubFolderSource): string[] {
-  return ["github", `repo:${source.owner}/${source.repo}`, `ref:${source.ref}`, `folder:${source.path || "/"}`];
-}
-
-function fromUrl(input: string): GitHubFolderSource | null {
-  let url;
-  try {
-    url = new URL(input);
-  } catch {
-    return null;
-  }
-  if (!["http:", "https:"].includes(url.protocol) || url.hostname !== GITHUB_HOST) {
-    throw promptImportError("GITHUB_FOLDER_UNSUPPORTED", "Only github.com folder URLs are supported", 400);
-  }
-  const [owner, repo, marker, rawRef, ...pathParts] = url.pathname.split("/").filter(Boolean);
-  assertOwnerRepo(owner, repo);
-  if (marker !== "tree") {
-    throw promptImportError("GITHUB_FOLDER_UNSUPPORTED", "Enter a GitHub folder URL or owner/repo:path/", 422);
-  }
-  const ref = safeDecode(rawRef || "main");
-  const path = safePath(pathParts.join("/"));
-  return makeSource({ owner, repo, ref, path, fromTreeUrl: true, ambiguousTree: path.includes("/") });
-}
-
-function fromShorthand(input: string): GitHubFolderSource {
-  const match = /^([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)(?:@([^:]+))?:(.*)$/.exec(input);
-  if (!match) {
-    throw promptImportError("GITHUB_FOLDER_UNSUPPORTED", "Enter a GitHub folder URL or owner/repo:path/", 422);
-  }
-  const [, owner, repo, rawRef, rawPath] = match;
-  assertOwnerRepo(owner, repo);
-  const ref = rawRef ? safeDecode(rawRef.trim()) : "main";
-  if (ref.includes("/")) {
-    throw promptImportError("AMBIGUOUS_GITHUB_REF", "Branches with slashes need a later Git ref resolver", 422);
-  }
-  return makeSource({ owner, repo, ref, path: safePath(rawPath) });
-}
-
-interface MakeSourceInput {
-  owner: string;
-  repo: string;
-  ref: string;
-  path: string;
-  fromTreeUrl?: boolean;
-  ambiguousTree?: boolean;
-}
-
-function makeSource({ owner, repo, ref, path, fromTreeUrl = false, ambiguousTree = false }: MakeSourceInput): GitHubFolderSource {
-  return {
-    kind: "github-folder",
-    owner,
-    repo,
-    ref,
-    path,
-    htmlUrl: `https://${GITHUB_HOST}/${owner}/${repo}/tree/${encodeURIComponent(ref)}${path ? `/${path}` : ""}`,
-    apiUrl: buildApiUrl({ owner, repo, ref, path }),
-    tags: [],
-    fromTreeUrl,
-    ambiguousTree,
-  };
-}
-
-function assertGithubApiUrl(rawUrl: string): void {
-  let url;
-  try {
-    url = new URL(rawUrl);
-  } catch {
-    throw promptImportError("INVALID_GITHUB_SOURCE", "GitHub folder fetch returned an invalid URL");
-  }
-  if (!["http:", "https:"].includes(url.protocol) || url.hostname !== GITHUB_API_HOST) {
-    throw promptImportError("INVALID_GITHUB_SOURCE", "GitHub folder fetch used an unsupported host");
-  }
-}
-
-function assertRawDownloadUrl(rawUrl: string): void {
-  let url;
-  try {
-    url = new URL(rawUrl);
-  } catch {
-    throw promptImportError("INVALID_GITHUB_SOURCE", "GitHub folder file has an invalid download URL");
-  }
-  if (!["http:", "https:"].includes(url.protocol) || url.hostname !== RAW_HOST) {
-    throw promptImportError("INVALID_GITHUB_SOURCE", "GitHub folder file download host is unsupported");
-  }
-  const path = safePath(url.pathname.split("/").filter(Boolean).slice(3).join("/"));
-  if (!supportedExtension(path)) {
-    throw promptImportError("UNSUPPORTED_EXTENSION", "Only .md, .markdown, and .txt files are supported");
-  }
-}
-
-interface NormalizeItemResult {
-  warning?: string;
-  file?: GitHubFolderFile;
-}
-
-function normalizeItem(source: GitHubFolderSource, item: unknown): NormalizeItemResult {
-  if (!item || typeof item !== "object") return { warning: "invalid-item" };
-  const raw = item as GitHubFolderItemRaw;
-  const type = typeof raw.type === "string" ? raw.type : "";
-  const path = safePath(raw.path);
-  const name = typeof raw.name === "string" ? raw.name : (path.split("/").pop() || "");
-  const extension = supportedExtension(path);
-  if (type !== "file") return { warning: `${path || name}: folder-deferred` };
-  if (!extension) return { warning: `${path || name}: unsupported-extension` };
-  if (!insideFolder(source.path, path)) return { warning: `${path || name}: outside-folder` };
-  if (typeof raw.download_url !== "string" || !raw.download_url) {
-    return { warning: `${path || name}: missing-download-url` };
-  }
-  return {
-    file: {
-      name,
-      path,
-      extension,
-      sizeBytes: Number(raw.size || 0),
-      htmlUrl: typeof raw.html_url === "string" ? raw.html_url : "",
-      downloadUrl: raw.download_url,
-      selected: false,
-      warnings: [],
-    },
-  };
-}
-
-function insideFolder(folderPath: string, filePath: string): boolean {
-  if (!folderPath) return true;
-  return filePath === folderPath || filePath.startsWith(`${folderPath}/`);
-}
-
-interface FetchJsonResult {
-  notFound?: boolean;
-  json?: unknown;
-}
-
-async function fetchJson(url: string, limits: PromptImportLimits): Promise<FetchJsonResult> {
-  assertGithubApiUrl(url);
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), limits.fetchTimeoutMs);
-  try {
-    const response = await fetch(url, {
-      signal: controller.signal,
-      headers: { Accept: "application/vnd.github+json" },
-    });
-    assertGithubApiUrl(response.url || url);
-    if (response.status === 404) return { notFound: true };
-    if (!response.ok) {
-      throw promptImportError("GITHUB_FOLDER_NOT_FOUND", `GitHub folder fetch failed with ${response.status}`, 422);
-    }
-    return { json: await response.json() };
-  } catch (error) {
-    const err = errInfo(error);
-    if (err.name === "AbortError") {
-      throw promptImportError("REMOTE_FETCH_TIMEOUT", "GitHub folder fetch timed out", 504);
-    }
-    throw error;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-export function normalizeGitHubFolderSource(input: unknown): GitHubFolderSource {
-  const trimmed = typeof input === "string" ? input.trim() : "";
-  if (!trimmed) {
-    throw promptImportError("GITHUB_FOLDER_UNSUPPORTED", "GitHub folder source is required", 400);
-  }
-  const source = fromUrl(trimmed) ?? fromShorthand(trimmed);
-  source.tags = folderTags(source);
-  return source;
-}
-
-interface FolderFetchResult {
-  source: GitHubFolderSource;
-  files: GitHubFolderFile[];
-  warnings: string[];
-}
-
-export async function fetchGitHubFolderFiles(source: GitHubFolderSource, limits: PromptImportLimits): Promise<FolderFetchResult> {
-  const fetched = await fetchJson(source.apiUrl, limits);
-  if (fetched.notFound && source.ambiguousTree) {
-    throw promptImportError("AMBIGUOUS_GITHUB_REF", "GitHub tree URL is ambiguous; slash branches are not resolved in PR3", 422);
-  }
-  if (fetched.notFound) {
-    throw promptImportError("GITHUB_FOLDER_NOT_FOUND", "GitHub folder was not found", 404);
-  }
-  if (!Array.isArray(fetched.json)) {
-    throw promptImportError("GITHUB_FOLDER_UNSUPPORTED", "GitHub source is not a folder", 422);
-  }
-
-  const warnings: string[] = [];
-  const maxFolderFiles = limits.maxFolderFiles ?? Infinity;
-  if (fetched.json.length > maxFolderFiles) {
-    warnings.push(`folder-raw-too-large:${fetched.json.length}`);
-  }
-  const files: GitHubFolderFile[] = [];
-  for (const item of fetched.json) {
-    const normalized = normalizeItem(source, item);
-    if (normalized.warning) warnings.push(normalized.warning);
-    if (normalized.file) files.push(normalized.file);
-  }
-  if (files.length > maxFolderFiles) {
-    warnings.push(`folder-too-large:${files.length}`);
-  }
-  return { source, files: files.slice(0, maxFolderFiles), warnings };
-}
-
-function assertSelectedPath(source: GitHubFolderSource, rawPath: unknown, allowed: Map<string, GitHubFolderFile>): string {
-  const path = safePath(rawPath);
-  if (!path || !supportedExtension(path) || !insideFolder(source.path, path) || !allowed.has(path)) {
-    throw promptImportError("GITHUB_FOLDER_SELECTION_EMPTY", `Selected file is not in the listed folder: ${path}`, 422);
-  }
-  return path;
-}
-
-export interface SelectedGitHubFolderFile extends GitHubFolderFile {
-  text: string;
-  contentHash: string;
-}
-
-interface SelectedFolderResult {
-  source: GitHubFolderSource;
-  files: SelectedGitHubFolderFile[];
-  warnings: string[];
-}
-
-export async function fetchSelectedGitHubFolderFiles(source: GitHubFolderSource, selectedPaths: unknown, limits: PromptImportLimits): Promise<SelectedFolderResult> {
-  const selected = Array.isArray(selectedPaths) ? selectedPaths : [];
-  if (selected.length === 0) {
-    throw promptImportError("GITHUB_FOLDER_SELECTION_EMPTY", "Select at least one folder file to preview", 422);
-  }
-  if (selected.length > (limits.maxFolderPreviewFiles ?? Infinity)) {
-    throw promptImportError("GITHUB_FOLDER_SELECTION_TOO_LARGE", "Too many folder files selected", 413);
-  }
-
-  const listing = await fetchGitHubFolderFiles(source, limits);
-  const allowed = new Map<string, GitHubFolderFile>(listing.files.map((file) => [file.path, file]));
-  const paths = selected.map((path) => assertSelectedPath(source, path, allowed));
-  const warnings: string[] = [...listing.warnings];
-  const files: SelectedGitHubFolderFile[] = [];
-  let firstError: unknown = null;
-
-  for (const path of paths) {
-    const file = allowed.get(path);
-    if (!file) continue;
-    try {
-      const fetched = await fetchRawFile(file.downloadUrl, limits);
-      files.push({ ...file, text: fetched.text, contentHash: fetched.contentHash });
-    } catch (error) {
-      const err = errInfo(error);
-      if (!firstError) firstError = error;
-      warnings.push(`${path}: ${err.message || "file fetch failed"}`);
-    }
-  }
-  if (files.length === 0 && firstError) throw firstError;
-  return { source, files, warnings };
-}
-
-interface RawFileResult {
-  text: string;
-  contentHash: string;
-}
-
-async function fetchRawFile(rawUrl: string, limits: PromptImportLimits): Promise<RawFileResult> {
-  assertRawDownloadUrl(rawUrl);
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), limits.fetchTimeoutMs);
-  try {
-    const response = await fetch(rawUrl, { signal: controller.signal });
-    assertRawDownloadUrl(response.url || rawUrl);
-    if (!response.ok) {
-      throw promptImportError("INVALID_GITHUB_SOURCE", `GitHub folder file fetch failed with ${response.status}`, 422);
-    }
-    const contentLength = Number(response.headers.get("content-length") || 0);
-    if (contentLength > limits.maxFileBytesForPreview) {
-      throw promptImportError("GITHUB_FOLDER_FILE_TOO_LARGE", "Folder file is too large", 413);
-    }
-    const buffer = await response.arrayBuffer();
-    if (buffer.byteLength > limits.maxFileBytesForPreview) {
-      throw promptImportError("GITHUB_FOLDER_FILE_TOO_LARGE", "Folder file is too large", 413);
-    }
-    const text = new TextDecoder("utf-8", { fatal: false }).decode(buffer);
-    return {
-      text,
-      contentHash: createHash("sha256").update(Buffer.from(buffer)).digest("hex"),
-    };
-  } catch (error) {
-    const err = errInfo(error);
-    if (err.name === "AbortError") {
-      throw promptImportError("REMOTE_FETCH_TIMEOUT", "GitHub folder file fetch timed out", 504);
-    }
-    throw error;
-  } finally {
-    clearTimeout(timer);
-  }
-}