ima2-gen 1.1.21 → 1.1.22

package/lib/promptImport/githubSource.ts

@@ -1,257 +0,0 @@
-import { createHash } from "node:crypto";
-import { promptImportError } from "./errors.js";
-import type { GitHubFileSource, PromptImportLimits } from "./types.js";
-
-import { errInfo } from "../errInfo.js";
-const ALLOWED_HOSTS = new Set(["github.com", "raw.githubusercontent.com"]);
-const SUPPORTED_EXTENSIONS = new Set(["md", "markdown", "txt"]);
-const OWNER_REPO_RE = /^[A-Za-z0-9_.-]+$/;
-
-function safeDecode(value: string): string {
-  try {
-    return decodeURIComponent(value);
-  } catch {
-    throw promptImportError("INVALID_GITHUB_SOURCE", "Invalid encoded GitHub path");
-  }
-}
-
-function assertCleanPath(path: string): string {
-  const lower = path.toLowerCase();
-  if (path.includes("\0") || lower.includes("%00")) {
-    throw promptImportError("INVALID_GITHUB_SOURCE", "GitHub path contains a null byte");
-  }
-  if (/%2f|%5c/i.test(path)) {
-    throw promptImportError("INVALID_GITHUB_SOURCE", "GitHub path contains an encoded slash");
-  }
-  const decoded = safeDecode(path);
-  if (decoded.includes("\\") || decoded.split("/").includes("..")) {
-    throw promptImportError("INVALID_GITHUB_SOURCE", "GitHub path traversal is not allowed");
-  }
-  return decoded.replace(/^\/+/, "");
-}
-
-function extensionForPath(path: string): string {
-  const match = /\.([A-Za-z0-9]+)$/.exec(path);
-  return match?.[1]?.toLowerCase() ?? "";
-}
-
-function assertSupportedFilePath(path: string): string {
-  const ext = extensionForPath(path);
-  if (!ext) {
-    throw promptImportError("FOLDER_IMPORT_DEFERRED", "Folder import is planned for a later version", 422);
-  }
-  if (!SUPPORTED_EXTENSIONS.has(ext)) {
-    throw promptImportError("UNSUPPORTED_EXTENSION", "Only .md, .markdown, and .txt files are supported");
-  }
-  return ext;
-}
-
-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 normalizeUrlInput(input: string): GitHubFileSource | null {
-  let url;
-  try {
-    url = new URL(input);
-  } catch {
-    return null;
-  }
-  if (!["http:", "https:"].includes(url.protocol)) {
-    throw promptImportError("INVALID_GITHUB_SOURCE", "Only http(s) GitHub URLs are supported");
-  }
-  if (!ALLOWED_HOSTS.has(url.hostname)) {
-    throw promptImportError("INVALID_GITHUB_SOURCE", "Only GitHub file URLs are supported");
-  }
-
-  const parts = url.pathname.split("/").filter(Boolean);
-  if (url.hostname === "github.com") {
-    const [owner, repo, marker, ref, ...pathParts] = parts;
-    assertOwnerRepo(owner, repo);
-    if (marker !== "blob") {
-      throw promptImportError("FOLDER_IMPORT_DEFERRED", "Only GitHub file URLs are supported in PR1", 422);
-    }
-    if (!ref || pathParts.length === 0) {
-      throw promptImportError("FOLDER_IMPORT_DEFERRED", "Folder import is planned for a later version", 422);
-    }
-    const path = assertCleanPath(pathParts.join("/"));
-    const ext = assertSupportedFilePath(path);
-    return {
-      kind: "github",
-      owner,
-      repo,
-      ref: safeDecode(ref),
-      path,
-      extension: ext,
-      htmlUrl: url.toString(),
-      rawUrl: `https://raw.githubusercontent.com/${owner}/${repo}/${encodeURIComponent(safeDecode(ref))}/${path}`,
-      tags: ["github", `repo:${owner}/${repo}`, `ref:${safeDecode(ref)}`, `file:${path.split("/").pop()}`, `ext:${ext}`],
-    };
-  }
-
-  const [owner, repo, ref, ...pathParts] = parts;
-  assertOwnerRepo(owner, repo);
-  if (!ref || pathParts.length === 0) {
-    throw promptImportError("FOLDER_IMPORT_DEFERRED", "Folder import is planned for a later version", 422);
-  }
-  const path = assertCleanPath(pathParts.join("/"));
-  const ext = assertSupportedFilePath(path);
-  return {
-    kind: "github",
-    owner,
-    repo,
-    ref: safeDecode(ref),
-    path,
-    extension: ext,
-    htmlUrl: `https://github.com/${owner}/${repo}/blob/${safeDecode(ref)}/${path}`,
-    rawUrl: url.toString(),
-    tags: ["github", `repo:${owner}/${repo}`, `ref:${safeDecode(ref)}`, `file:${path.split("/").pop()}`, `ext:${ext}`],
-  };
-}
-
-function normalizeShorthand(input: string): GitHubFileSource {
-  const match = /^([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)(?:@([^:]+))?:(.+)$/.exec(input);
-  if (!match) {
-    throw promptImportError("INVALID_GITHUB_SOURCE", "Enter a GitHub file URL or owner/repo:path");
-  }
-  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 GitHub API folder support planned for PR3");
-  }
-  const path = assertCleanPath(rawPath.trim());
-  const ext = assertSupportedFilePath(path);
-  return {
-    kind: "github",
-    owner,
-    repo,
-    ref,
-    path,
-    extension: ext,
-    htmlUrl: `https://github.com/${owner}/${repo}/blob/${ref}/${path}`,
-    rawUrl: `https://raw.githubusercontent.com/${owner}/${repo}/${encodeURIComponent(ref)}/${path}`,
-    tags: ["github", `repo:${owner}/${repo}`, `ref:${ref}`, `file:${path.split("/").pop()}`, `ext:${ext}`],
-  };
-}
-
-interface BuildRawSourceInput {
-  owner: string;
-  repo: string;
-  ref?: string;
-  path: string;
-}
-
-export function buildGitHubRawFileSource({ owner, repo, ref = "main", path }: BuildRawSourceInput): GitHubFileSource {
-  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: string): void {
-  let url;
-  try {
-    url = new URL(rawUrl);
-  } catch {
-    throw promptImportError("INVALID_GITHUB_SOURCE", "GitHub fetch returned an invalid final URL");
-  }
-  if (!["http:", "https:"].includes(url.protocol)) {
-    throw promptImportError("INVALID_GITHUB_SOURCE", "GitHub fetch returned an unsupported protocol");
-  }
-  if (!ALLOWED_HOSTS.has(url.hostname)) {
-    throw promptImportError("INVALID_GITHUB_SOURCE", "GitHub fetch redirected to an unsupported host");
-  }
-  const parts = url.pathname.split("/").filter(Boolean);
-  if (url.hostname === "github.com") {
-    const marker = parts[2];
-    if (parts.length < 5 || marker !== "blob") {
-      throw promptImportError("INVALID_GITHUB_SOURCE", "GitHub fetch redirected to a non-file page");
-    }
-    const finalPath = assertCleanPath(parts.slice(4).join("/"));
-    assertSupportedFilePath(finalPath);
-    return;
-  }
-  if (parts.length < 4) {
-    throw promptImportError("INVALID_GITHUB_SOURCE", "GitHub fetch returned a non-file path");
-  }
-  const finalPath = assertCleanPath(parts.slice(3).join("/"));
-  assertSupportedFilePath(finalPath);
-}
-
-export function normalizeGitHubSource(input: unknown): GitHubFileSource {
-  const trimmed = typeof input === "string" ? input.trim() : "";
-  if (!trimmed) {
-    throw promptImportError("INVALID_GITHUB_SOURCE", "GitHub source is required");
-  }
-  return normalizeUrlInput(trimmed) ?? normalizeShorthand(trimmed);
-}
-
-interface GitHubFetchResult {
-  text: string;
-  finalUrl: string;
-  etag: string | null;
-  sizeBytes: number;
-  contentHash: string;
-}
-
-export async function fetchGitHubSource(source: GitHubFileSource, limits: PromptImportLimits): Promise<GitHubFetchResult> {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), limits.fetchTimeoutMs);
-  try {
-    const response = await fetch(source.rawUrl, { signal: controller.signal });
-    validateFinalFetchUrl(response.url);
-    if (!response.ok) {
-      throw promptImportError("INVALID_GITHUB_SOURCE", `GitHub file fetch failed with ${response.status}`, 422);
-    }
-    const contentLength = Number(response.headers.get("content-length") || 0);
-    if (contentLength > limits.maxFileBytesForPreview) {
-      throw promptImportError("REMOTE_FILE_TOO_LARGE", "Remote file is too large", 413);
-    }
-    const buffer = await response.arrayBuffer();
-    if (buffer.byteLength > limits.maxFileBytesForPreview) {
-      throw promptImportError("REMOTE_FILE_TOO_LARGE", "Remote file is too large", 413);
-    }
-    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) {
-    const err = errInfo(error);
-    if (err.name === "AbortError") {
-      throw promptImportError("REMOTE_FETCH_TIMEOUT", "GitHub fetch timed out", 504);
-    }
-    throw error;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-export async function fetchGitHubSourceText(source: GitHubFileSource, limits: PromptImportLimits): Promise<string> {
-  const result = await fetchGitHubSource(source, limits);
-  return result.text;
-}
-
-export function isSupportedPromptFileName(filename: string): boolean {
-  return SUPPORTED_EXTENSIONS.has(extensionForPath(filename || ""));
-}

package/lib/promptImport/gptImageHints.ts

@@ -1,70 +0,0 @@
-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],
-];
-
-type HintTuple = [string, RegExp];
-
-function matches(text: string, patterns: HintTuple[]): string[] {
-  return patterns.filter(([, pattern]: HintTuple) => pattern.test(text)).map(([name]: HintTuple) => name);
-}
-
-export function extractGptImageHints(text: unknown) {
-  const value = String(text || "");
-  const modelHints = matches(value, MODEL_HINTS as HintTuple[]);
-  const taskHints = matches(value, TASK_HINTS as HintTuple[]);
-  const sizeHints = matches(value, SIZE_HINTS as HintTuple[]);
-  const qualityHints = matches(value, QUALITY_HINTS as HintTuple[]);
-  const warnings: string[] = [];
-
-  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,
-  };
-}

package/lib/promptImport/parsePromptCandidates.ts

@@ -1,179 +0,0 @@
-import { createHash } from "crypto";
-import type { PromptCandidate, PromptCandidateScoreHints, PromptCandidateSource, PromptImportLimits } from "./types.js";
-
-interface PushCandidateOptions {
-  name: string;
-  tags: string[];
-  warnings?: string[];
-  source: PromptCandidateSource;
-  headingPath?: string | null;
-  scoreHints?: PromptCandidateScoreHints;
-  limits: PromptImportLimits;
-}
-
-interface ParseCommonOptions extends PushCandidateOptions {
-  candidates: PromptCandidate[];
-  baseName: string;
-}
-
-function normalizeWhitespace(text: string): string {
-  return text.replace(/\r\n/g, "\n").replace(/[ \t]+\n/g, "\n").trim();
-}
-
-function stripFrontmatter(text: string): string {
-  return text.replace(/^---\s*\n[\s\S]*?\n---\s*\n/, "");
-}
-
-function isBoilerplate(line: string): boolean {
-  const trimmed = line.trim();
-  return (
-    !trimmed ||
-    /^\[!\[.*\]\(.+\)\]\(.+\)$/.test(trimmed) ||
-    /^!\[.*\]\(.+\)$/.test(trimmed) ||
-    /^\[.*\]\(.+\)$/.test(trimmed)
-  );
-}
-
-function titleFromFilename(filename: string): string {
-  return (filename || "Imported prompt")
-    .replace(/\.(txt|md|markdown)$/i, "")
-    .replace(/[-_]+/g, " ")
-    .trim() || "Imported prompt";
-}
-
-function candidateId(text: string, ordinal: number): string {
-  return `candidate_${ordinal}_${createHash("sha256").update(text).digest("hex").slice(0, 10)}`;
-}
-
-function promptHash(text: string): string {
-  return createHash("sha256").update(normalizeWhitespace(text).toLowerCase()).digest("hex");
-}
-
-function headingName(heading: string | undefined, fallback: string): string {
-  return heading?.replace(/^#+\s*/, "").trim() || fallback;
-}
-
-function allowedCandidate(text: string, limits: PromptImportLimits): boolean {
-  const length = text.trim().length;
-  return length >= limits.minCandidateChars && length <= limits.maxCandidateChars;
-}
-
-function cleanMarkdownBody(text: string): string {
-  return normalizeWhitespace(
-    text
-      .split("\n")
-      .filter((line) => !isBoilerplate(line))
-      .filter((line) => !/^\|.*\|$/.test(line.trim()))
-      .join("\n"),
-  );
-}
-
-function pushCandidate(candidates: PromptCandidate[], rawText: string, options: PushCandidateOptions): void {
-  const text = normalizeWhitespace(rawText);
-  if (!allowedCandidate(text, options.limits)) return;
-  const ordinal = candidates.length + 1;
-  const hash = promptHash(text);
-  candidates.push({
-    id: candidateId(text, ordinal),
-    name: options.name,
-    text,
-    textPreview: text.slice(0, 220),
-    tags: [...new Set(options.tags)],
-    warnings: options.warnings ?? [],
-    source: options.source,
-    headingPath: options.headingPath ?? null,
-    ordinal,
-    promptHash: hash,
-    scoreHints: options.scoreHints ?? {},
-  });
-}
-
-function parseMarkdown(text: string, options: ParseCommonOptions): void {
-  const source = stripFrontmatter(text).slice(0, options.limits.maxSourceCharsScanned);
-  const fencePattern = /```([A-Za-z0-9_-]*)\n([\s\S]*?)```/g;
-  const acceptedFenceLanguages = new Set(["", "prompt", "text", "markdown", "md"]);
-  const ranges: Array<[number, number]> = [];
-
-  for (const match of source.matchAll(fencePattern)) {
-    const language = (match[1] || "").toLowerCase();
-    if (!acceptedFenceLanguages.has(language)) continue;
-    ranges.push([match.index ?? 0, (match.index ?? 0) + match[0].length]);
-    pushCandidate(options.candidates, match[2], {
-      ...options,
-      name: `${options.baseName} ${options.candidates.length + 1}`,
-      headingPath: options.headingPath ?? null,
-    });
-    if (options.candidates.length >= options.limits.maxPromptCandidatesPerFile) return;
-  }
-
-  const withoutFences = source
-    .split("\n")
-    .filter((line, index, lines) => {
-      void line;
-      const offset = lines.slice(0, index).join("\n").length + (index > 0 ? 1 : 0);
-      return !ranges.some(([start, end]) => offset >= start && offset < end);
-    })
-    .join("\n");
-  const sections = withoutFences.split(/(?=^#{1,4}\s+)/gm);
-  for (const section of sections) {
-    const heading = /^#{1,4}\s+(.+)$/m.exec(section)?.[1];
-    const body = cleanMarkdownBody(section.replace(/^#{1,4}\s+.+$/m, ""));
-    pushCandidate(options.candidates, body, {
-      ...options,
-      name: headingName(heading, `${options.baseName} ${options.candidates.length + 1}`),
-      headingPath: headingName(heading, options.baseName),
-    });
-    if (options.candidates.length >= options.limits.maxPromptCandidatesPerFile) return;
-  }
-}
-
-function splitTextPrompts(text: string): string[] {
-  const normalized = normalizeWhitespace(text);
-  const separatorBlocks = normalized.split(/\n\s*---+\s*\n/g).filter(Boolean);
-  const blocks = separatorBlocks.length > 1
-    ? separatorBlocks
-    : normalized.split(/\n\s*\n+/g).filter(Boolean);
-  const numbered = normalized.split(/(?=^\s*\d+[.)]\s+)/gm).filter(Boolean);
-  const longLines = normalized.split("\n").map((line) => line.trim()).filter((line) => line.length >= 80);
-  return blocks.length > 1 ? blocks : numbered.length > 1 ? numbered : longLines.length > 1 ? longLines : [normalized];
-}
-
-function parsePlainText(text: string, options: ParseCommonOptions): void {
-  const chunks = splitTextPrompts(text.slice(0, options.limits.maxSourceCharsScanned));
-  for (const chunk of chunks) {
-    const clean = chunk.replace(/^\s*\d+[.)]\s+/, "");
-    pushCandidate(options.candidates, clean, {
-      ...options,
-      name: `${options.baseName} ${options.candidates.length + 1}`,
-      headingPath: `${options.baseName} ${options.candidates.length + 1}`,
-    });
-    if (options.candidates.length >= options.limits.maxPromptCandidatesPerFile) return;
-  }
-}
-
-interface ParsePromptCandidatesInput {
-  text: string;
-  filename: string;
-  source: PromptCandidateSource;
-  tags?: string[];
-  limits: PromptImportLimits;
-}
-
-export function parsePromptCandidates({ text, filename, source, tags = [], limits }: ParsePromptCandidatesInput): PromptCandidate[] {
-  const candidates: PromptCandidate[] = [];
-  const extension = (filename.split(".").pop() || "").toLowerCase();
-  const baseName = titleFromFilename(filename);
-  const common: ParseCommonOptions = {
-    candidates,
-    limits,
-    baseName,
-    tags,
-    source,
-    name: baseName,
-  };
-
-  if (extension === "txt") parsePlainText(text, common);
-  else parseMarkdown(text, common);
-
-  return candidates.slice(0, limits.maxPromptCandidatesPerFile);
-}