@hayasaka7/haya-pet 0.1.0

package/packages/pet-core/test/animation-state.test.mjs

@@ -0,0 +1,47 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import {
+  clearDragAction,
+  createAnimationState,
+  resolveCurrentAction,
+  setDragAction,
+  setStableAction,
+  triggerOneShot
+} from "../src/animation-state.js";
+
+test("stable action loops until it is changed", () => {
+  let state = createAnimationState("idle");
+
+  assert.equal(resolveCurrentAction(state, 1000), "idle");
+
+  state = setStableAction(state, "review");
+
+  assert.equal(resolveCurrentAction(state, 1200), "review");
+});
+
+test("one-shot action temporarily overrides stable action", () => {
+  const state = triggerOneShot(createAnimationState("review"), "waving", 1000, 500);
+
+  assert.equal(resolveCurrentAction(state, 1499), "waving");
+  assert.equal(resolveCurrentAction(state, 1500), "review");
+  assert.equal(state.previousStableAction, "review");
+});
+
+test("stable action changes become the return target after an active one-shot", () => {
+  let state = triggerOneShot(createAnimationState("idle"), "jumping", 1000, 500);
+  state = setStableAction(state, "running");
+
+  assert.equal(resolveCurrentAction(state, 1250), "jumping");
+  assert.equal(resolveCurrentAction(state, 1500), "running");
+});
+
+test("drag action overrides both stable and one-shot actions", () => {
+  let state = triggerOneShot(createAnimationState("review"), "waving", 1000, 500);
+  state = setDragAction(state, "left");
+
+  assert.equal(resolveCurrentAction(state, 1100), "running-left");
+
+  state = clearDragAction(state);
+
+  assert.equal(resolveCurrentAction(state, 1100), "waving");
+});

package/packages/pet-core/test/animator.test.mjs

@@ -0,0 +1,31 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import { getFrameAt, getActionDurationMs } from "../src/animator.js";
+
+const manifest = { frameDurationMs: 100, actionFrameDurations: { idle: 200 } };
+
+test("computes the active frame index from elapsed time", () => {
+  assert.equal(getFrameAt("running", 0, manifest), 0);
+  assert.equal(getFrameAt("running", 250, manifest), 2);
+});
+
+test("loops frames within the action frame count", () => {
+  // running has 6 frames at 100ms -> 600ms wraps back to 0
+  assert.equal(getFrameAt("running", 600, manifest), 0);
+});
+
+test("honours per-action frame duration overrides", () => {
+  // idle override is 200ms; 500ms -> frame 2
+  assert.equal(getFrameAt("idle", 500, manifest), 2);
+});
+
+test("computes the full duration of an action loop", () => {
+  // waving has 4 frames at 100ms
+  assert.equal(getActionDurationMs("waving", manifest), 400);
+  // idle has 6 frames at 200ms override
+  assert.equal(getActionDurationMs("idle", manifest), 1200);
+});
+
+test("rejects unknown actions", () => {
+  assert.throws(() => getFrameAt("dancing", 0, manifest), /Unknown pet action/);
+});

package/packages/pet-core/test/atlas.test.mjs

@@ -0,0 +1,81 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import {
+  ACTION_ROWS,
+  ATLAS_HEIGHT,
+  ATLAS_WIDTH,
+  CELL_HEIGHT,
+  CELL_WIDTH,
+  FRAME_COUNTS,
+  getFrameCount,
+  getFrameRect,
+  mapAiStateToPetAction
+} from "../src/atlas.js";
+
+test("defines Codex-compatible atlas geometry and action rows", () => {
+  assert.equal(CELL_WIDTH, 192);
+  assert.equal(CELL_HEIGHT, 208);
+  assert.equal(ATLAS_WIDTH, 1536);
+  assert.equal(ATLAS_HEIGHT, 1872);
+
+  assert.deepEqual(ACTION_ROWS, {
+    idle: 0,
+    "running-right": 1,
+    "running-left": 2,
+    waving: 3,
+    jumping: 4,
+    failed: 5,
+    waiting: 6,
+    running: 7,
+    review: 8
+  });
+
+  assert.deepEqual(FRAME_COUNTS, {
+    idle: 6,
+    "running-right": 8,
+    "running-left": 8,
+    waving: 4,
+    jumping: 5,
+    failed: 8,
+    waiting: 6,
+    running: 6,
+    review: 6
+  });
+});
+
+test("returns frame rectangles for valid pet actions", () => {
+  assert.deepEqual(getFrameRect("running-right", 3), {
+    x: 576,
+    y: 208,
+    width: 192,
+    height: 208
+  });
+
+  assert.deepEqual(getFrameRect("review", 5), {
+    x: 960,
+    y: 1664,
+    width: 192,
+    height: 208
+  });
+});
+
+test("rejects unknown actions and out-of-range frame indexes", () => {
+  assert.throws(() => getFrameCount("dancing"), /Unknown pet action/);
+  assert.throws(() => getFrameRect("idle", 6), /Frame index 6 is out of range/);
+  assert.throws(() => getFrameRect("waving", -1), /Frame index -1 is out of range/);
+});
+
+test("maps normalized AI states to pet actions", () => {
+  assert.equal(mapAiStateToPetAction("idle"), "idle");
+  assert.equal(mapAiStateToPetAction("thinking"), "review");
+  assert.equal(mapAiStateToPetAction("running_tool"), "running");
+  assert.equal(mapAiStateToPetAction("editing_files"), "running");
+  assert.equal(mapAiStateToPetAction("waiting_user"), "waiting");
+  assert.equal(mapAiStateToPetAction("waiting_approval"), "waiting");
+  assert.equal(mapAiStateToPetAction("reviewing"), "review");
+  assert.equal(mapAiStateToPetAction("compacting"), "review");
+  assert.equal(mapAiStateToPetAction("failed"), "failed");
+  assert.equal(mapAiStateToPetAction("success"), "jumping");
+  assert.equal(mapAiStateToPetAction("stale"), "waiting");
+  assert.equal(mapAiStateToPetAction("exited"), "jumping");
+});

package/packages/pet-core/test/discovery.test.mjs

@@ -0,0 +1,93 @@
+import assert from "node:assert/strict";
+import { join } from "node:path";
+import { test } from "../../../test/harness.mjs";
+import { discoverPets, loadPetFromDir } from "../src/discovery.js";
+
+function manifest(id, name) {
+  return JSON.stringify({ id, name, spritesheet: "spritesheet.webp" });
+}
+
+// Builds an injectable fake fs from explicit dir listings and file contents.
+function fakeFs({ dirs = {}, files = {} } = {}) {
+  return {
+    async readdir(dir) {
+      if (!(dir in dirs)) {
+        const error = new Error("no dir");
+        error.code = "ENOENT";
+        throw error;
+      }
+      return dirs[dir];
+    },
+    async readFile(path) {
+      if (!(path in files)) {
+        const error = new Error("no file");
+        error.code = "ENOENT";
+        throw error;
+      }
+      return files[path];
+    },
+    async stat(path) {
+      if (!(path in files)) {
+        const error = new Error("no file");
+        error.code = "ENOENT";
+        throw error;
+      }
+      return {};
+    }
+  };
+}
+
+test("discovers pets with a manifest and spritesheet", async () => {
+  const root = join("petsdir");
+  const catDir = join(root, "cat");
+  const fs = fakeFs({
+    dirs: { [root]: ["cat"] },
+    files: {
+      [join(catDir, "pet.json")]: manifest("cat", "Cat"),
+      [join(catDir, "spritesheet.webp")]: "binary"
+    }
+  });
+
+  const pets = await discoverPets([root], fs);
+  assert.equal(pets.length, 1);
+  assert.equal(pets[0].manifest.id, "cat");
+  assert.equal(pets[0].manifest.name, "Cat");
+});
+
+test("skips folders missing a spritesheet", async () => {
+  const root = join("petsdir");
+  const fs = fakeFs({
+    dirs: { [root]: ["nopix"] },
+    files: { [join(root, "nopix", "pet.json")]: manifest("nopix", "NoPix") }
+  });
+
+  assert.deepEqual(await discoverPets([root], fs), []);
+});
+
+test("dedupes by id across search paths (first wins)", async () => {
+  const a = join("a");
+  const b = join("b");
+  const fs = fakeFs({
+    dirs: { [a]: ["cat"], [b]: ["cat"] },
+    files: {
+      [join(a, "cat", "pet.json")]: manifest("cat", "Cat A"),
+      [join(a, "cat", "spritesheet.webp")]: "x",
+      [join(b, "cat", "pet.json")]: manifest("cat", "Cat B"),
+      [join(b, "cat", "spritesheet.webp")]: "x"
+    }
+  });
+
+  const pets = await discoverPets([a, b], fs);
+  assert.equal(pets.length, 1);
+  assert.equal(pets[0].manifest.name, "Cat A");
+});
+
+test("returns undefined for an invalid manifest", async () => {
+  const dir = join("p");
+  const fs = fakeFs({ files: { [join(dir, "pet.json")]: "{ not json" } });
+  assert.equal(await loadPetFromDir(dir, fs), undefined);
+});
+
+test("tolerates missing search directories", async () => {
+  assert.deepEqual(await discoverPets([join("does-not-exist")], fakeFs()), []);
+});

package/packages/pet-core/test/manifest.test.mjs

@@ -0,0 +1,93 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import {
+  DEFAULT_FRAME_DURATION_MS,
+  getFrameDurationMs,
+  parsePetManifest
+} from "../src/manifest.js";
+
+test("parses a minimal pet manifest with defaults", () => {
+  const result = parsePetManifest({
+    id: "example-pet",
+    name: "Example Pet",
+    spritesheet: "spritesheet.webp"
+  });
+
+  assert.equal(result.ok, true);
+  assert.deepEqual(result.errors, []);
+  assert.equal(result.manifest.id, "example-pet");
+  assert.equal(result.manifest.name, "Example Pet");
+  assert.equal(result.manifest.spritesheet, "spritesheet.webp");
+  assert.equal(result.manifest.cellWidth, 192);
+  assert.equal(result.manifest.cellHeight, 208);
+  assert.equal(result.manifest.frameDurationMs, DEFAULT_FRAME_DURATION_MS);
+});
+
+test("accepts Codex-style displayName and spritesheetPath aliases", () => {
+  const result = parsePetManifest({
+    id: "toru-pixel",
+    displayName: "Toru Pixel",
+    description: "A pixel pet",
+    spritesheetPath: "spritesheet.webp"
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(result.manifest.id, "toru-pixel");
+  assert.equal(result.manifest.name, "Toru Pixel");
+  assert.equal(result.manifest.spritesheet, "spritesheet.webp");
+});
+
+test("prefers canonical fields over aliases when both are present", () => {
+  const result = parsePetManifest({
+    id: "p",
+    name: "Canonical",
+    displayName: "Alias",
+    spritesheet: "real.webp",
+    spritesheetPath: "alias.webp"
+  });
+
+  assert.equal(result.manifest.name, "Canonical");
+  assert.equal(result.manifest.spritesheet, "real.webp");
+});
+
+test("rejects manifests missing required fields", () => {
+  const result = parsePetManifest({ name: "No Id" });
+
+  assert.equal(result.ok, false);
+  assert.equal(result.manifest, undefined);
+  assert.ok(result.errors.some((message) => message.includes("id")));
+  assert.ok(result.errors.some((message) => message.includes("spritesheet")));
+});
+
+test("rejects cell dimensions that do not match the Codex atlas", () => {
+  const result = parsePetManifest({
+    id: "p",
+    name: "P",
+    spritesheet: "s.webp",
+    cellWidth: 200,
+    cellHeight: 208
+  });
+
+  assert.equal(result.ok, false);
+  assert.ok(result.errors.some((message) => message.includes("cellWidth")));
+});
+
+test("normalizes per-action frame duration overrides", () => {
+  const result = parsePetManifest({
+    id: "p",
+    name: "P",
+    spritesheet: "s.webp",
+    frameDurationMs: 100,
+    actionFrameDurations: { idle: 250 }
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(getFrameDurationMs(result.manifest, "idle"), 250);
+  assert.equal(getFrameDurationMs(result.manifest, "running"), 100);
+});
+
+test("rejects non-object manifests", () => {
+  const result = parsePetManifest("not-json");
+  assert.equal(result.ok, false);
+  assert.ok(result.errors.some((message) => message.includes("object")));
+});

package/packages/pet-core/test/validation.test.mjs

@@ -0,0 +1,69 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import {
+  validateAtlasDimensions,
+  validatePetActions,
+  validatePet
+} from "../src/validation.js";
+
+const FULL_ACTION_FRAMES = {
+  idle: 6,
+  "running-right": 8,
+  "running-left": 8,
+  waving: 4,
+  jumping: 5,
+  failed: 8,
+  waiting: 6,
+  running: 6,
+  review: 6
+};
+
+test("accepts the Codex-compatible 1536x1872 atlas", () => {
+  const result = validateAtlasDimensions({ width: 1536, height: 1872 });
+  assert.equal(result.ok, true);
+  assert.deepEqual(result.errors, []);
+});
+
+test("rejects atlases that are not 1536x1872", () => {
+  const result = validateAtlasDimensions({ width: 1024, height: 1872 });
+  assert.equal(result.ok, false);
+  assert.ok(result.errors.some((message) => message.includes("1536")));
+});
+
+test("requires every action row to have non-empty used cells", () => {
+  const ok = validatePetActions(FULL_ACTION_FRAMES);
+  assert.equal(ok.ok, true);
+
+  const missing = { ...FULL_ACTION_FRAMES };
+  delete missing.review;
+  const missingResult = validatePetActions(missing);
+  assert.equal(missingResult.ok, false);
+  assert.ok(missingResult.errors.some((message) => message.includes("review")));
+
+  const emptyRow = { ...FULL_ACTION_FRAMES, waving: 0 };
+  const emptyResult = validatePetActions(emptyRow);
+  assert.equal(emptyResult.ok, false);
+  assert.ok(emptyResult.errors.some((message) => message.includes("waving")));
+});
+
+test("combines manifest, dimension, and action checks", () => {
+  const result = validatePet({
+    manifest: { id: "p", name: "P", spritesheet: "s.webp" },
+    dimensions: { width: 1536, height: 1872 },
+    actionFrameCounts: FULL_ACTION_FRAMES
+  });
+
+  assert.equal(result.ok, true);
+  assert.deepEqual(result.errors, []);
+});
+
+test("surfaces all failures from a broken pet", () => {
+  const result = validatePet({
+    manifest: { name: "P" },
+    dimensions: { width: 100, height: 100 },
+    actionFrameCounts: { idle: 6 }
+  });
+
+  assert.equal(result.ok, false);
+  assert.ok(result.errors.length >= 3);
+});

package/packages/platform-core/src/capabilities.js

@@ -0,0 +1,49 @@
+import { normalizePlatform } from "./platform.js";
+
+export function getPlatformCapabilities(options = {}) {
+  const platform = normalizePlatform(options.platform);
+  const env = options.env ?? process.env;
+
+  if (platform === "windows") {
+    return {
+      platform,
+      ipcTransport: "named-pipe",
+      transparentOverlay: "required",
+      terminalAttachment: "best-effort",
+      displayManagement: "required",
+      fallbackMode: "none"
+    };
+  }
+
+  if (platform === "macos") {
+    return {
+      platform,
+      ipcTransport: "unix-socket",
+      transparentOverlay: "required",
+      terminalAttachment: "best-effort",
+      displayManagement: "required",
+      fallbackMode: "none"
+    };
+  }
+
+  if (platform === "linux") {
+    const isWayland = Boolean(env.WAYLAND_DISPLAY);
+    return {
+      platform,
+      ipcTransport: "unix-socket",
+      transparentOverlay: isWayland ? "best-effort" : "required",
+      terminalAttachment: isWayland ? "fallback" : "best-effort",
+      displayManagement: "required",
+      fallbackMode: isWayland ? "wayland-cluster" : "none"
+    };
+  }
+
+  return {
+    platform,
+    ipcTransport: "unsupported",
+    transparentOverlay: "fallback",
+    terminalAttachment: "fallback",
+    displayManagement: "fallback",
+    fallbackMode: "normal-window"
+  };
+}

package/packages/platform-core/src/paths.js

@@ -0,0 +1,75 @@
+import { normalizePlatform } from "./platform.js";
+
+export function getDefaultPaths(options = {}) {
+  const platform = normalizePlatform(options.platform);
+  const env = options.env ?? process.env;
+  const homeDir = options.homeDir ?? env.HOME ?? env.USERPROFILE;
+
+  if (!homeDir) {
+    throw new Error("homeDir is required when no HOME or USERPROFILE environment variable is available");
+  }
+
+  if (platform === "windows") {
+    return getWindowsPaths(env, homeDir);
+  }
+
+  if (platform === "macos" || platform === "linux") {
+    return getUnixPaths(homeDir);
+  }
+
+  return getUnsupportedPaths(homeDir);
+}
+
+function getWindowsPaths(env, homeDir) {
+  const localAppData = env.LOCALAPPDATA ?? joinWindows(homeDir, "AppData", "Local");
+  const appData = env.APPDATA ?? joinWindows(homeDir, "AppData", "Roaming");
+
+  return {
+    platform: "windows",
+    ipcEndpoint: "\\\\.\\pipe\\haya-petd",
+    statePath: joinWindows(localAppData, "haya-pet", "state.json"),
+    configPath: joinWindows(appData, "haya-pet", "config.json"),
+    logDir: joinWindows(localAppData, "haya-pet", "logs"),
+    petSearchPaths: [
+      joinWindows(homeDir, ".codex", "pets"),
+      joinWindows(localAppData, "haya-pet", "pets")
+    ]
+  };
+}
+
+function getUnixPaths(homeDir) {
+  return {
+    platform: "unix",
+    ipcEndpoint: joinUnix(homeDir, ".haya-pet", "haya-petd.sock"),
+    statePath: joinUnix(homeDir, ".haya-pet", "state.json"),
+    configPath: joinUnix(homeDir, ".haya-pet", "config.json"),
+    logDir: joinUnix(homeDir, ".haya-pet", "logs"),
+    petSearchPaths: [
+      joinUnix(homeDir, ".codex", "pets"),
+      joinUnix(homeDir, ".haya-pet", "pets")
+    ]
+  };
+}
+
+function getUnsupportedPaths(homeDir) {
+  return {
+    platform: "unsupported",
+    ipcEndpoint: joinUnix(homeDir, ".haya-pet", "haya-petd.sock"),
+    statePath: joinUnix(homeDir, ".haya-pet", "state.json"),
+    configPath: joinUnix(homeDir, ".haya-pet", "config.json"),
+    logDir: joinUnix(homeDir, ".haya-pet", "logs"),
+    petSearchPaths: [
+      joinUnix(homeDir, ".codex", "pets"),
+      joinUnix(homeDir, ".haya-pet", "pets")
+    ]
+  };
+}
+
+function joinWindows(...parts) {
+  return parts.filter(Boolean).join("\\").replace(/\\+/g, "\\");
+}
+
+function joinUnix(...parts) {
+  const [first, ...rest] = parts.filter(Boolean);
+  return [first.replace(/\/+$/g, ""), ...rest.map((part) => part.replace(/^\/+|\/+$/g, ""))].join("/");
+}

package/packages/platform-core/src/platform.js

@@ -0,0 +1,15 @@
+export function normalizePlatform(platform = process.platform) {
+  if (platform === "win32" || platform === "windows") {
+    return "windows";
+  }
+
+  if (platform === "darwin" || platform === "macos") {
+    return "macos";
+  }
+
+  if (platform === "linux") {
+    return "linux";
+  }
+
+  return "unsupported";
+}

package/packages/platform-core/test/platform.test.mjs

@@ -0,0 +1,84 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import { getPlatformCapabilities } from "../src/capabilities.js";
+import { getDefaultPaths } from "../src/paths.js";
+import { normalizePlatform } from "../src/platform.js";
+
+test("normalizes supported and unsupported platforms", () => {
+  assert.equal(normalizePlatform("win32"), "windows");
+  assert.equal(normalizePlatform("darwin"), "macos");
+  assert.equal(normalizePlatform("linux"), "linux");
+  assert.equal(normalizePlatform("freebsd"), "unsupported");
+});
+
+test("returns Windows local app paths and named pipe endpoint", () => {
+  const paths = getDefaultPaths({
+    platform: "windows",
+    env: {
+      LOCALAPPDATA: "C:\\Users\\A\\AppData\\Local",
+      APPDATA: "C:\\Users\\A\\AppData\\Roaming",
+      USERPROFILE: "C:\\Users\\A"
+    },
+    homeDir: "C:\\Users\\A"
+  });
+
+  assert.equal(paths.ipcEndpoint, "\\\\.\\pipe\\haya-petd");
+  assert.equal(paths.statePath, "C:\\Users\\A\\AppData\\Local\\haya-pet\\state.json");
+  assert.equal(paths.configPath, "C:\\Users\\A\\AppData\\Roaming\\haya-pet\\config.json");
+  assert.deepEqual(paths.petSearchPaths, [
+    "C:\\Users\\A\\.codex\\pets",
+    "C:\\Users\\A\\AppData\\Local\\haya-pet\\pets"
+  ]);
+});
+
+test("returns macOS local app paths and Unix socket endpoint", () => {
+  const paths = getDefaultPaths({
+    platform: "macos",
+    env: {},
+    homeDir: "/Users/a"
+  });
+
+  assert.equal(paths.ipcEndpoint, "/Users/a/.haya-pet/haya-petd.sock");
+  assert.equal(paths.statePath, "/Users/a/.haya-pet/state.json");
+  assert.equal(paths.configPath, "/Users/a/.haya-pet/config.json");
+  assert.deepEqual(paths.petSearchPaths, [
+    "/Users/a/.codex/pets",
+    "/Users/a/.haya-pet/pets"
+  ]);
+});
+
+test("returns Linux local app paths and Unix socket endpoint", () => {
+  const paths = getDefaultPaths({
+    platform: "linux",
+    env: {},
+    homeDir: "/home/a"
+  });
+
+  assert.equal(paths.ipcEndpoint, "/home/a/.haya-pet/haya-petd.sock");
+  assert.equal(paths.statePath, "/home/a/.haya-pet/state.json");
+  assert.equal(paths.configPath, "/home/a/.haya-pet/config.json");
+  assert.deepEqual(paths.petSearchPaths, [
+    "/home/a/.codex/pets",
+    "/home/a/.haya-pet/pets"
+  ]);
+});
+
+test("reports platform capabilities and Wayland fallbacks", () => {
+  assert.deepEqual(getPlatformCapabilities({ platform: "windows", env: {} }), {
+    platform: "windows",
+    ipcTransport: "named-pipe",
+    transparentOverlay: "required",
+    terminalAttachment: "best-effort",
+    displayManagement: "required",
+    fallbackMode: "none"
+  });
+
+  assert.equal(
+    getPlatformCapabilities({ platform: "linux", env: { WAYLAND_DISPLAY: "wayland-0" } }).terminalAttachment,
+    "fallback"
+  );
+  assert.equal(
+    getPlatformCapabilities({ platform: "linux", env: { WAYLAND_DISPLAY: "wayland-0" } }).transparentOverlay,
+    "best-effort"
+  );
+});