ima2-gen 1.1.7 → 1.1.8

package/lib/promptImport/githubDiscovery.js

@@ -0,0 +1,248 @@
+import { createHash } from "node:crypto";
+import { promptImportError } from "./errors.js";
+import { upsertDiscoveryCandidates } from "./discoveryRegistry.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",
+];
+
+function tokenize(value) {
+  return String(value || "")
+    .toLowerCase()
+    .split(/[^a-z0-9가-힣-]+/i)
+    .filter(Boolean);
+}
+
+function discoveryLimits(ctx) {
+  return {
+    limit: ctx.config.limits.promptImportDiscoverySearchLimit,
+    maxQueries: ctx.config.limits.promptImportDiscoveryMaxQueries,
+    fetchTimeoutMs: ctx.config.limits.promptImportFetchTimeoutMs,
+  };
+}
+
+function validateGitHubApiUrl(rawUrl) {
+  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) {
+  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) {
+  const headers = {
+    Accept: "application/vnd.github+json",
+    "X-GitHub-Api-Version": "2022-11-28",
+    "User-Agent": "ima2-prompt-import-discovery",
+  };
+  const token = ctx.config.github?.token;
+  if (token) headers.Authorization = `Bearer ${token}`;
+  return headers;
+}
+
+export function buildDiscoveryQueries({ q = "", seeds = [], limit = 5 } = {}) {
+  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, context = {}) {
+  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 = [];
+  const warnings = [];
+  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, context = {}) {
+  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) {
+  return createHash("sha256").update(JSON.stringify(input)).digest("hex");
+}
+
+async function searchOneQuery(ctx, query, perPage) {
+  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();
+    const items = Array.isArray(data.items) ? data.items : [];
+    return { items, rateLimit };
+  } catch (error) {
+    if (error?.name === "AbortError") {
+      throw promptImportError("REMOTE_FETCH_TIMEOUT", "GitHub discovery timed out", 504);
+    }
+    throw error;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export async function searchGitHubDiscovery(ctx, options = {}) {
+  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 = [];
+  let rateLimit = null;
+  const byRepo = new Map();
+
+  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.js

@@ -0,0 +1,308 @@
+import { createHash } from "node:crypto";
+import { promptImportError } from "./errors.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_.-]+$/;
+
+function safeDecode(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    throw promptImportError("INVALID_GITHUB_SOURCE", "Invalid encoded GitHub folder path");
+  }
+}
+
+function safePath(path) {
+  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, repo) {
+  if (!OWNER_REPO_RE.test(owner || "") || !OWNER_REPO_RE.test(repo || "")) {
+    throw promptImportError("INVALID_GITHUB_SOURCE", "Invalid GitHub owner or repository");
+  }
+}
+
+function extensionForPath(path) {
+  const match = /\.([A-Za-z0-9]+)$/.exec(path);
+  return match?.[1]?.toLowerCase() ?? "";
+}
+
+function supportedExtension(path) {
+  const extension = extensionForPath(path);
+  return SUPPORTED_EXTENSIONS.has(extension) ? extension : "";
+}
+
+function encodeApiPath(path) {
+  return path
+    .split("/")
+    .filter(Boolean)
+    .map((part) => encodeURIComponent(part))
+    .join("/");
+}
+
+function buildApiUrl({ owner, repo, ref, path }) {
+  const encodedPath = encodeApiPath(path);
+  const suffix = encodedPath ? `/${encodedPath}` : "";
+  return `https://${GITHUB_API_HOST}/repos/${owner}/${repo}/contents${suffix}?ref=${encodeURIComponent(ref)}`;
+}
+
+function folderTags(source) {
+  return ["github", `repo:${source.owner}/${source.repo}`, `ref:${source.ref}`, `folder:${source.path || "/"}`];
+}
+
+function fromUrl(input) {
+  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) {
+  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) });
+}
+
+function makeSource({ owner, repo, ref, path, fromTreeUrl = false, ambiguousTree = false }) {
+  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) {
+  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) {
+  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");
+  }
+}
+
+function normalizeItem(source, item) {
+  if (!item || typeof item !== "object") return { warning: "invalid-item" };
+  const type = typeof item.type === "string" ? item.type : "";
+  const path = safePath(item.path || "");
+  const name = typeof item.name === "string" ? item.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 item.download_url !== "string" || !item.download_url) {
+    return { warning: `${path || name}: missing-download-url` };
+  }
+  return {
+    file: {
+      name,
+      path,
+      extension,
+      sizeBytes: Number(item.size || 0),
+      htmlUrl: typeof item.html_url === "string" ? item.html_url : "",
+      downloadUrl: item.download_url,
+      selected: false,
+      warnings: [],
+    },
+  };
+}
+
+function insideFolder(folderPath, filePath) {
+  if (!folderPath) return true;
+  return filePath === folderPath || filePath.startsWith(`${folderPath}/`);
+}
+
+async function fetchJson(url, limits) {
+  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) {
+    if (error?.name === "AbortError") {
+      throw promptImportError("REMOTE_FETCH_TIMEOUT", "GitHub folder fetch timed out", 504);
+    }
+    throw error;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export function normalizeGitHubFolderSource(input) {
+  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;
+}
+
+export async function fetchGitHubFolderFiles(source, limits) {
+  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 = [];
+  if (fetched.json.length > limits.maxFolderFiles) {
+    warnings.push(`folder-raw-too-large:${fetched.json.length}`);
+  }
+  const files = [];
+  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 > limits.maxFolderFiles) {
+    warnings.push(`folder-too-large:${files.length}`);
+  }
+  return { source, files: files.slice(0, limits.maxFolderFiles), warnings };
+}
+
+function assertSelectedPath(source, rawPath, allowed) {
+  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 async function fetchSelectedGitHubFolderFiles(source, selectedPaths, limits) {
+  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) {
+    throw promptImportError("GITHUB_FOLDER_SELECTION_TOO_LARGE", "Too many folder files selected", 413);
+  }
+
+  const listing = await fetchGitHubFolderFiles(source, limits);
+  const allowed = new Map(listing.files.map((file) => [file.path, file]));
+  const paths = selected.map((path) => assertSelectedPath(source, path, allowed));
+  const warnings = [...listing.warnings];
+  const files = [];
+  let firstError = null;
+
+  for (const path of paths) {
+    const file = allowed.get(path);
+    try {
+      const fetched = await fetchRawFile(file.downloadUrl, limits);
+      files.push({ ...file, text: fetched.text, contentHash: fetched.contentHash });
+    } catch (error) {
+      if (!firstError) firstError = error;
+      warnings.push(`${path}: ${error?.message || "file fetch failed"}`);
+    }
+  }
+  if (files.length === 0 && firstError) throw firstError;
+  return { source, files, warnings };
+}
+
+async function fetchRawFile(rawUrl, limits) {
+  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) {
+    if (error?.name === "AbortError") {
+      throw promptImportError("REMOTE_FETCH_TIMEOUT", "GitHub folder file fetch timed out", 504);
+    }
+    throw error;
+  } finally {
+    clearTimeout(timer);
+  }
+}

package/lib/promptImport/githubSource.js

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import { promptImportError } from "./errors.js";
 
 const ALLOWED_HOSTS = new Set(["github.com", "raw.githubusercontent.com"]);
@@ -134,6 +135,27 @@ function normalizeShorthand(input) {
   };
 }
 
+export function buildGitHubRawFileSource({ owner, repo, ref = "main", path }) {
+  assertOwnerRepo(owner, repo);
+  const cleanRef = safeDecode(String(ref || "main").trim());
+  if (!cleanRef || cleanRef.includes("/")) {
+    throw promptImportError("AMBIGUOUS_GITHUB_REF", "Branches with slashes need GitHub API folder support planned for PR3");
+  }
+  const cleanPath = assertCleanPath(String(path || "").trim());
+  const ext = assertSupportedFilePath(cleanPath);
+  return {
+    kind: "github",
+    owner,
+    repo,
+    ref: cleanRef,
+    path: cleanPath,
+    extension: ext,
+    htmlUrl: `https://github.com/${owner}/${repo}/blob/${cleanRef}/${cleanPath}`,
+    rawUrl: `https://raw.githubusercontent.com/${owner}/${repo}/${encodeURIComponent(cleanRef)}/${cleanPath}`,
+    tags: ["github", `repo:${owner}/${repo}`, `ref:${cleanRef}`, `file:${cleanPath.split("/").pop()}`, `ext:${ext}`],
+  };
+}
+
 function validateFinalFetchUrl(rawUrl) {
   let url;
   try {
@@ -172,7 +194,7 @@ export function normalizeGitHubSource(input) {
   return normalizeUrlInput(trimmed) ?? normalizeShorthand(trimmed);
 }
 
-export async function fetchGitHubSourceText(source, limits) {
+export async function fetchGitHubSource(source, limits) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), limits.fetchTimeoutMs);
   try {
@@ -189,7 +211,14 @@ export async function fetchGitHubSourceText(source, limits) {
     if (buffer.byteLength > limits.maxFileBytesForPreview) {
       throw promptImportError("REMOTE_FILE_TOO_LARGE", "Remote file is too large", 413);
     }
-    return new TextDecoder("utf-8", { fatal: false }).decode(buffer);
+    const text = new TextDecoder("utf-8", { fatal: false }).decode(buffer);
+    return {
+      text,
+      finalUrl: response.url,
+      etag: response.headers.get("etag"),
+      sizeBytes: buffer.byteLength,
+      contentHash: createHash("sha256").update(Buffer.from(buffer)).digest("hex"),
+    };
   } catch (error) {
     if (error?.name === "AbortError") {
       throw promptImportError("REMOTE_FETCH_TIMEOUT", "GitHub fetch timed out", 504);
@@ -200,6 +229,11 @@ export async function fetchGitHubSourceText(source, limits) {
   }
 }
 
+export async function fetchGitHubSourceText(source, limits) {
+  const result = await fetchGitHubSource(source, limits);
+  return result.text;
+}
+
 export function isSupportedPromptFileName(filename) {
   return SUPPORTED_EXTENSIONS.has(extensionForPath(filename || ""));
 }

package/lib/promptImport/gptImageHints.js

@@ -0,0 +1,68 @@
+const MODEL_HINTS = [
+  ["gpt-image-2", /\bgpt[- ]?image[- ]?2\b/i],
+  ["gpt-image", /\bgpt[- ]?image\b/i],
+  ["nano-banana", /\bnano[- ]?banana\b/i],
+  ["midjourney", /\bmidjourney\b/i],
+  ["stable-diffusion", /\bstable[- ]?diffusion\b/i],
+];
+
+const TASK_HINTS = [
+  ["image_generation", /\b(image generation|generate an image|text to image)\b/i],
+  ["reference-image", /\b(reference image|keep the same|preserve|consistent character|same face)\b/i],
+  ["mask-edit", /\b(mask|inpaint|outpaint|replace only|change only)\b/i],
+  ["typography", /\b(typography|headline|readable text|lettering|poster text|title text)\b/i],
+  ["layout", /\b(layout|grid|composition|poster|diagram|infographic)\b/i],
+  ["product-shot", /\b(product photo|product shot|packaging|label|reflection)\b/i],
+];
+
+const SIZE_HINTS = [
+  ["2k", /\b2k\b/i],
+  ["4k", /\b4k\b/i],
+  ["square", /\bsquare\b/i],
+  ["portrait", /\bportrait|vertical\b/i],
+  ["landscape", /\blandscape|horizontal\b/i],
+];
+
+const QUALITY_HINTS = [
+  ["low", /\blow\b/i],
+  ["medium", /\bmedium\b/i],
+  ["high", /\bhigh\b/i],
+  ["auto", /\bauto\b/i],
+  ["draft", /\bdraft|thumbnail|iteration\b/i],
+  ["final", /\bfinal|production[- ]ready\b/i],
+];
+
+function matches(text, patterns) {
+  return patterns.filter(([, pattern]) => pattern.test(text)).map(([name]) => name);
+}
+
+export function extractGptImageHints(text) {
+  const value = String(text || "");
+  const modelHints = matches(value, MODEL_HINTS);
+  const taskHints = matches(value, TASK_HINTS);
+  const sizeHints = matches(value, SIZE_HINTS);
+  const qualityHints = matches(value, QUALITY_HINTS);
+  const warnings = [];
+
+  if (/\btransparent|alpha channel|no background|cutout\b/i.test(value)) {
+    warnings.push("transparent-unsupported-gpt-image-2");
+  }
+  if (/\bexact text|small text|dense text|legal copy\b/i.test(value)) {
+    warnings.push("text-rendering-sensitive");
+  }
+  if (/\bcomplex layout|multi[- ]panel|precise diagram\b/i.test(value)) {
+    warnings.push("layout-sensitive");
+  }
+  if (/\b4k|high resolution|ultra[- ]high\b/i.test(value)) {
+    warnings.push("high-res-cost-warning");
+  }
+
+  return {
+    modelHints,
+    generationSurfaceHints: taskHints.includes("image_generation") ? ["responses-image-tool"] : [],
+    taskHints,
+    sizeHints,
+    qualityHints,
+    warnings,
+  };
+}