@astrofoundry/pi-astro 0.6.4 → 0.6.5

package/extensions/gemini-image/index.ts

@@ -20,6 +20,7 @@ import {
 } from "./models.ts";
 import { parseTweaks } from "./parseTweaks.ts";
 import { estimateCost, formatUsd, hasPricing } from "./pricing.ts";
+import { formatResolution, resolveResolution } from "./resolution.ts";
 
 const DEFAULT_SAVE_SUBDIR = ".gemini-images";
 
@@ -233,12 +234,16 @@ function saveImages(images: DecodedImage[], dir: string, prompt: string): string
 
 function renderPreview(model: ImageModel, p: Params, estimate: { estimatedUsd: number; breakdown: string }): string {
     const nImages = isImagen(model) ? p.number_of_images ?? 1 : 1;
+    const aspect = p.aspect_ratio ?? "1:1";
+    const size = p.image_size ?? "1K";
+    const resolution = formatResolution(resolveResolution(model, aspect, size));
     const lines: string[] = [];
     lines.push(`Model: ${model}`);
     lines.push(`Prompt: "${p.prompt}"`);
-    if (p.image_size) lines.push(`Size: ${p.image_size}`);
-    if (p.aspect_ratio) lines.push(`Aspect ratio: ${p.aspect_ratio}`);
-    lines.push(`Images: ${nImages}`);
+    lines.push(`Aspect: ${aspect}${p.aspect_ratio ? "" : " (default)"}`);
+    lines.push(`Size: ${size}${p.image_size ? "" : " (default)"}`);
+    lines.push(`Resolution: ${resolution}`);
+    lines.push(`Images: ${nImages}${p.number_of_images === undefined && isImagen(model) ? " (default)" : ""}`);
     if (p.negative_prompt) lines.push(`Negative: "${p.negative_prompt.slice(0, 80)}"`);
     if (p.seed !== undefined) lines.push(`Seed: ${p.seed}`);
     if (p.person_generation) lines.push(`People: ${p.person_generation}`);

package/extensions/gemini-image/resolution.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from "vitest";
+import { formatResolution, resolveResolution } from "./resolution.ts";
+
+describe("resolveResolution", () => {
+    it("defaults to 1:1 1K = 1024×1024", () => {
+        const r = resolveResolution("gemini-2.5-flash-image", undefined, undefined);
+        expect(r.width).toBe(1024);
+        expect(r.height).toBe(1024);
+        expect(r.approximate).toBe(false);
+    });
+
+    it("scales 2K as 2x", () => {
+        const r = resolveResolution("gemini-2.5-flash-image", "1:1", "2K");
+        expect(r.width).toBe(2048);
+        expect(r.height).toBe(2048);
+    });
+
+    it("scales 4K as 4x", () => {
+        const r = resolveResolution("gemini-3-pro-image-preview", "1:1", "4K");
+        expect(r.width).toBe(4096);
+        expect(r.height).toBe(4096);
+    });
+
+    it("16:9 at 1K → 1344×768", () => {
+        const r = resolveResolution("gemini-2.5-flash-image", "16:9", "1K");
+        expect(r.width).toBe(1344);
+        expect(r.height).toBe(768);
+    });
+
+    it("21:9 at 1K → 1536×672", () => {
+        const r = resolveResolution("gemini-2.5-flash-image", "21:9", "1K");
+        expect(r.width).toBe(1536);
+        expect(r.height).toBe(672);
+    });
+
+    it("Imagen flagged as approximate", () => {
+        const r = resolveResolution("imagen-4.0-generate-001", "1:1", "1K");
+        expect(r.approximate).toBe(true);
+    });
+
+    it("unknown aspect falls back to 1:1", () => {
+        const r = resolveResolution("gemini-2.5-flash-image", "7:3", "1K");
+        expect(r.width).toBe(1024);
+        expect(r.height).toBe(1024);
+    });
+});
+
+describe("formatResolution", () => {
+    it("exact Gemini is shown without tilde", () => {
+        expect(formatResolution({ width: 1024, height: 1024, approximate: false })).toBe("1024×1024");
+    });
+
+    it("approximate Imagen gets tilde prefix", () => {
+        expect(formatResolution({ width: 1024, height: 1024, approximate: true })).toBe("~1024×1024");
+    });
+});

package/extensions/gemini-image/resolution.ts

@@ -0,0 +1,62 @@
+/**
+ * Resolve the expected output resolution for a given (model, aspect_ratio, image_size).
+ *
+ * Base table is the documented Gemini 2.5 Flash Image matrix. 2K/4K scale the
+ * base by 2x/4x. Imagen's published resolutions vary per model and aren't in
+ * the public docs at the same granularity, so we use the same base and flag
+ * the result as approximate.
+ */
+
+import { isImagen, type ImageModel } from "./models.ts";
+
+type AspectRatio =
+    | "1:1"
+    | "2:3"
+    | "3:2"
+    | "3:4"
+    | "4:3"
+    | "4:5"
+    | "5:4"
+    | "9:16"
+    | "16:9"
+    | "21:9";
+
+// Gemini 2.5 Flash Image 1K dimensions, per ai.google.dev/gemini-api/docs/image-generation.
+const BASE_1K: Record<AspectRatio, [number, number]> = {
+    "1:1": [1024, 1024],
+    "2:3": [832, 1248],
+    "3:2": [1248, 832],
+    "3:4": [864, 1184],
+    "4:3": [1184, 864],
+    "4:5": [896, 1152],
+    "5:4": [1152, 896],
+    "9:16": [768, 1344],
+    "16:9": [1344, 768],
+    "21:9": [1536, 672],
+};
+
+export interface ResolutionInfo {
+    width: number;
+    height: number;
+    approximate: boolean;
+}
+
+export function resolveResolution(
+    model: ImageModel,
+    aspectRatio: string | undefined,
+    imageSize: "1K" | "2K" | "4K" | undefined,
+): ResolutionInfo {
+    const ratio = (aspectRatio ?? "1:1") as AspectRatio;
+    const base = BASE_1K[ratio] ?? BASE_1K["1:1"];
+    const size = imageSize ?? "1K";
+    const multiplier = size === "4K" ? 4 : size === "2K" ? 2 : 1;
+    return {
+        width: base[0] * multiplier,
+        height: base[1] * multiplier,
+        approximate: isImagen(model),
+    };
+}
+
+export function formatResolution(info: ResolutionInfo): string {
+    return `${info.approximate ? "~" : ""}${info.width}×${info.height}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrofoundry/pi-astro",
-  "version": "0.6.4",
+  "version": "0.6.5",
   "description": "Personal pi customizations (extensions, skills, prompts, themes) for the pi coding agent.",
   "keywords": [
     "pi-package"