waypoi 0.0.0

package/tests/cliLegacyRewrite.test.ts

@@ -0,0 +1,45 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { rewriteLegacyArgv } from "../cli/legacyRewrite.ts";
+
+test("rewrites provider model ls to models <provider>", () => {
+  const result = rewriteLegacyArgv(["provider", "model", "ls", "pcai"]);
+  assert.equal(result.legacyUsed, true);
+  assert.deepEqual(result.argv, ["models", "pcai"]);
+  assert.equal(result.ruleId, "provider-model-list");
+});
+
+test("rewrites provider models to models <provider>", () => {
+  const result = rewriteLegacyArgv(["provider", "models", "pcai"]);
+  assert.equal(result.legacyUsed, true);
+  assert.deepEqual(result.argv, ["models", "pcai"]);
+  assert.equal(result.ruleId, "provider-models-list");
+});
+
+test("rewrites provider model show to models show provider/model", () => {
+  const result = rewriteLegacyArgv(["provider", "model", "show", "pcai", "gpt-4o"]);
+  assert.equal(result.legacyUsed, true);
+  assert.deepEqual(result.argv, ["models", "show", "pcai/gpt-4o"]);
+  assert.equal(result.ruleId, "provider-model-show");
+});
+
+test("rewrites provider model set-key to models set-key provider/model", () => {
+  const result = rewriteLegacyArgv([
+    "provider",
+    "model",
+    "set-key",
+    "pcai",
+    "gpt-4o",
+    "--env-var",
+    "PCAI_KEY",
+  ]);
+  assert.equal(result.legacyUsed, true);
+  assert.deepEqual(result.argv, ["models", "set-key", "pcai/gpt-4o", "--env-var", "PCAI_KEY"]);
+  assert.equal(result.ruleId, "provider-model-set-key");
+});
+
+test("leaves canonical commands unchanged", () => {
+  const result = rewriteLegacyArgv(["models", "pcai"]);
+  assert.equal(result.legacyUsed, false);
+  assert.deepEqual(result.argv, ["models", "pcai"]);
+});

package/tests/imageGeneration.service.test.ts

@@ -0,0 +1,107 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import os from "os";
+import path from "path";
+import { promises as fs } from "fs";
+import {
+  normalizeChatImagePayload,
+  normalizeImageGenerationPayload,
+} from "../src/services/imageGeneration";
+import { StoragePaths } from "../src/storage/files";
+
+function makePaths(baseDir: string): StoragePaths {
+  return {
+    baseDir,
+    configPath: path.join(baseDir, "config.yaml"),
+    healthPath: path.join(baseDir, "health.json"),
+    providerHealthPath: path.join(baseDir, "providers_health.json"),
+    requestLogPath: path.join(baseDir, "request_logs.jsonl"),
+    providersPath: path.join(baseDir, "providers.json"),
+    poolsPath: path.join(baseDir, "pools.json"),
+    poolStatePath: path.join(baseDir, "pool_state.json"),
+  };
+}
+
+test("normalizeImageGenerationPayload preserves mixed url+b64 fields", async () => {
+  const baseDir = await fs.mkdtemp(path.join(os.tmpdir(), "waypoi-img-norm-"));
+  const result = await normalizeImageGenerationPayload(
+    makePaths(baseDir),
+    {
+      created: 1730000000,
+      data: [
+        {
+          url: "https://example.com/image.png",
+          b64_json: "AAA",
+          revised_prompt: "cat",
+        },
+      ],
+    },
+    "provider/model"
+  );
+  assert.equal(result.model, "provider/model");
+  assert.equal(result.images.length, 1);
+  assert.equal(result.images[0].url, "https://example.com/image.png");
+  assert.equal(result.images[0].b64_json, "AAA");
+  assert.equal(result.images[0].revised_prompt, "cat");
+});
+
+test("normalizeImageGenerationPayload adds data url when only b64_json exists", async () => {
+  const baseDir = await fs.mkdtemp(path.join(os.tmpdir(), "waypoi-img-norm-"));
+  const result = await normalizeImageGenerationPayload(
+    makePaths(baseDir),
+    {
+      data: [{ b64_json: "BBB" }],
+    },
+    "smart"
+  );
+  assert.equal(result.images.length, 1);
+  assert.equal(result.images[0].b64_json, "BBB");
+  assert.equal(result.images[0].url, "data:image/png;base64,BBB");
+});
+
+test("normalizeImageGenerationPayload extracts b64 from data URL", async () => {
+  const baseDir = await fs.mkdtemp(path.join(os.tmpdir(), "waypoi-img-norm-"));
+  const result = await normalizeImageGenerationPayload(
+    makePaths(baseDir),
+    {
+      data: [{ url: "data:image/png;base64,CCC" }],
+    },
+    "smart"
+  );
+  assert.equal(result.images.length, 1);
+  assert.equal(result.images[0].b64_json, "CCC");
+  assert.equal(result.images[0].url, "data:image/png;base64,CCC");
+});
+
+test("normalizeChatImagePayload converts chat multimodal image content", () => {
+  const normalized = normalizeChatImagePayload({
+    created: 1730000000,
+    choices: [
+      {
+        message: {
+          content: [
+            { type: "text", text: "edited result" },
+            { type: "image_url", image_url: { url: "data:image/png;base64,DDD" } },
+          ],
+        },
+      },
+    ],
+  }) as {
+    created: number;
+    data: Array<{ url?: string; revised_prompt?: string }>;
+  };
+  assert.equal(normalized.created, 1730000000);
+  assert.equal(normalized.data.length, 1);
+  assert.equal(normalized.data[0].url, "data:image/png;base64,DDD");
+  assert.equal(normalized.data[0].revised_prompt, "edited result");
+});
+
+test("normalizeChatImagePayload throws when chat payload has no image output", () => {
+  assert.throws(
+    () =>
+      normalizeChatImagePayload({
+        choices: [{ message: { content: [{ type: "text", text: "no image" }] } }],
+      }),
+    /did not return any image output/
+  );
+});

package/tests/imageUnderstanding.service.test.ts

@@ -0,0 +1,123 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import os from "os";
+import path from "path";
+import { promises as fs } from "fs";
+import sharp from "sharp";
+import {
+  buildImageGeometrySystemMessage,
+  imageDataUrlFromPath,
+  imageDataUrlWithGeometryFromPath,
+  parseImageUnderstandingText,
+} from "../src/services/imageUnderstanding";
+
+test("imageDataUrlFromPath reads bytes and builds data URL", async () => {
+  const baseDir = await fs.mkdtemp(path.join(os.tmpdir(), "waypoi-img-understand-"));
+  const filePath = path.join(baseDir, "sample.png");
+  await sharp({
+    create: {
+      width: 4,
+      height: 4,
+      channels: 3,
+      background: { r: 255, g: 0, b: 0 },
+    },
+  })
+    .png()
+    .toFile(filePath);
+
+  const dataUrl = await imageDataUrlFromPath(filePath);
+  assert.match(dataUrl, /^data:image\/png;base64,/);
+});
+
+test("imageDataUrlWithGeometryFromPath preserves identity geometry for small images", async () => {
+  const baseDir = await fs.mkdtemp(path.join(os.tmpdir(), "waypoi-img-understand-"));
+  const filePath = path.join(baseDir, "small.png");
+  await sharp({
+    create: {
+      width: 320,
+      height: 240,
+      channels: 3,
+      background: { r: 0, g: 255, b: 0 },
+    },
+  })
+    .png()
+    .toFile(filePath);
+
+  const resolved = await imageDataUrlWithGeometryFromPath(filePath);
+  assert.match(resolved.imageUrl, /^data:image\/png;base64,/);
+  assert.deepEqual(resolved.imageGeometry, {
+    original_width: 320,
+    original_height: 240,
+    uploaded_width: 320,
+    uploaded_height: 240,
+    scale_x: 1,
+    scale_y: 1,
+    resized: false,
+  });
+});
+
+test("imageDataUrlWithGeometryFromPath tracks resized upload geometry", async () => {
+  const baseDir = await fs.mkdtemp(path.join(os.tmpdir(), "waypoi-img-understand-"));
+  const filePath = path.join(baseDir, "large.png");
+  await sharp({
+    create: {
+      width: 2000,
+      height: 1200,
+      channels: 3,
+      background: { r: 0, g: 0, b: 255 },
+    },
+  })
+    .png()
+    .toFile(filePath);
+
+  const resolved = await imageDataUrlWithGeometryFromPath(filePath);
+  assert.match(resolved.imageUrl, /^data:image\/png;base64,/);
+  assert.equal(resolved.imageGeometry?.original_width, 2000);
+  assert.equal(resolved.imageGeometry?.original_height, 1200);
+  assert.ok((resolved.imageGeometry?.uploaded_width ?? 0) < 2000);
+  assert.ok((resolved.imageGeometry?.uploaded_height ?? 0) < 1200);
+  assert.equal(resolved.imageGeometry?.resized, true);
+  assert.ok((resolved.imageGeometry?.scale_x ?? 1) > 1);
+  assert.ok((resolved.imageGeometry?.scale_y ?? 1) > 1);
+});
+
+test("buildImageGeometrySystemMessage describes original coordinate space", () => {
+  const message = buildImageGeometrySystemMessage({
+    original_width: 2000,
+    original_height: 1200,
+    uploaded_width: 1080,
+    uploaded_height: 648,
+    scale_x: 2000 / 1080,
+    scale_y: 1200 / 648,
+    resized: true,
+  });
+  assert.match(message, /original image pixel space/i);
+  assert.match(message, /Original image size: 2000x1200/);
+  assert.match(message, /Uploaded image size: 1080x648/);
+});
+
+test("parseImageUnderstandingText handles plain text fallback", () => {
+  const result = parseImageUnderstandingText("A red stop sign on a city street.");
+  assert.equal(result.answer, "A red stop sign on a city street.");
+  assert.equal(result.objects.length, 0);
+});
+
+test("parseImageUnderstandingText handles structured json payload", () => {
+  const text = JSON.stringify({
+    analysis: {
+      answer: "Sign with text",
+      ocr_text: "STOP",
+      objects: ["sign", "road"],
+      scene: "urban street",
+      notable_details: ["clear weather"],
+      safety_notes: ["traffic nearby"],
+    },
+  });
+  const result = parseImageUnderstandingText(text);
+  assert.equal(result.answer, "Sign with text");
+  assert.equal(result.ocr_text, "STOP");
+  assert.deepEqual(result.objects, ["sign", "road"]);
+  assert.equal(result.scene, "urban street");
+  assert.deepEqual(result.notable_details, ["clear weather"]);
+  assert.deepEqual(result.safety_notes, ["traffic nearby"]);
+});

package/tests/mcpPolicy.test.ts

@@ -0,0 +1,105 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import path from "path";
+import {
+  resolveBinaryOutputPolicy,
+  validateAtMostOneImageInput,
+  validateSingleImageInput,
+} from "../src/mcp/policy";
+
+test("resolveBinaryOutputPolicy defaults outputDir to baseDir/generated-images", () => {
+  const baseDir = path.join(path.sep, "Users", "example", ".config", "waypoi");
+  const resolved = resolveBinaryOutputPolicy({}, { defaultBaseDir: baseDir });
+  assert.equal(resolved.outputBaseRoot, baseDir);
+  assert.equal(resolved.outputDir, path.join(baseDir, "generated-images"));
+  assert.equal(resolved.includeData, false);
+});
+
+test("resolveBinaryOutputPolicy WAYPOI_MCP_OUTPUT_ROOT overrides baseDir", () => {
+  const baseDir = path.join(path.sep, "Users", "example", ".config", "waypoi");
+  const customRoot = path.join(path.sep, "Users", "example", "projects");
+  const resolved = resolveBinaryOutputPolicy(
+    {},
+    { defaultBaseDir: baseDir, env: { WAYPOI_MCP_OUTPUT_ROOT: customRoot } }
+  );
+  assert.equal(resolved.outputBaseRoot, customRoot);
+  assert.equal(resolved.outputDir, path.join(customRoot, "generated-images"));
+});
+
+test("resolveBinaryOutputPolicy WAYPOI_MCP_OUTPUT_SUBDIR narrows output path", () => {
+  const baseDir = path.join(path.sep, "Users", "example", ".config", "waypoi");
+  const resolved = resolveBinaryOutputPolicy(
+    {},
+    { defaultBaseDir: baseDir, env: { WAYPOI_MCP_OUTPUT_SUBDIR: "work" } }
+  );
+  assert.equal(resolved.outputBaseRoot, baseDir);
+  assert.equal(resolved.outputDir, path.join(baseDir, "work"));
+});
+
+test("resolveBinaryOutputPolicy strict mode requires WAYPOI_MCP_OUTPUT_ROOT", () => {
+  assert.throws(
+    () =>
+      resolveBinaryOutputPolicy(
+        {},
+        { env: { WAYPOI_MCP_STRICT_OUTPUT_ROOT: "true" } }
+      ),
+    /requires WAYPOI_MCP_OUTPUT_ROOT/
+  );
+});
+
+test("resolveBinaryOutputPolicy strict mode rejects non-absolute WAYPOI_MCP_OUTPUT_ROOT", () => {
+  assert.throws(
+    () =>
+      resolveBinaryOutputPolicy(
+        {},
+        {
+          env: {
+            WAYPOI_MCP_STRICT_OUTPUT_ROOT: "true",
+            WAYPOI_MCP_OUTPUT_ROOT: "relative/path",
+          },
+        }
+      ),
+    /must be an absolute path/
+  );
+});
+
+test("resolveBinaryOutputPolicy rejects absolute WAYPOI_MCP_OUTPUT_SUBDIR", () => {
+  assert.throws(
+    () =>
+      resolveBinaryOutputPolicy(
+        {},
+        { env: { WAYPOI_MCP_OUTPUT_SUBDIR: path.sep + "absolute" } }
+      ),
+    /WAYPOI_MCP_OUTPUT_SUBDIR must be relative/
+  );
+});
+
+test("resolveBinaryOutputPolicy defaults includeData to false", () => {
+  const resolved = resolveBinaryOutputPolicy({});
+  assert.equal(resolved.includeData, false);
+});
+
+test("resolveBinaryOutputPolicy respects include_data=true", () => {
+  const resolved = resolveBinaryOutputPolicy({ include_data: true });
+  assert.equal(resolved.includeData, true);
+});
+
+test("validateSingleImageInput enforces xor behavior", () => {
+  assert.throws(() => validateSingleImageInput({}), /Exactly one image source/);
+  assert.throws(
+    () => validateSingleImageInput({ image_path: "/tmp/a.png", image_url: "https://example.com/a.png" }),
+    /Exactly one image source/
+  );
+  assert.doesNotThrow(() => validateSingleImageInput({ image_path: "/tmp/a.png" }));
+  assert.doesNotThrow(() => validateSingleImageInput({ image_url: "https://example.com/a.png" }));
+});
+
+test("validateAtMostOneImageInput allows none or one image source", () => {
+  assert.doesNotThrow(() => validateAtMostOneImageInput({}));
+  assert.doesNotThrow(() => validateAtMostOneImageInput({ image_path: "/tmp/a.png" }));
+  assert.doesNotThrow(() => validateAtMostOneImageInput({ image_url: "https://example.com/a.png" }));
+  assert.throws(
+    () => validateAtMostOneImageInput({ image_path: "/tmp/a.png", image_url: "https://example.com/a.png" }),
+    /Provide either image_path or image_url/
+  );
+});