@hayasaka7/haya-pet 0.1.0

package/packages/task-core/test/task-status.test.mjs

@@ -0,0 +1,49 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import {
+  TASK_STATUSES,
+  isTaskStatus,
+  mapTaskStatusToAiState,
+  mapTaskStatusToPetAction,
+  buildTaskStatusPill
+} from "../src/task-status.js";
+
+test("defines the documented task status vocabulary", () => {
+  for (const status of [
+    "starting",
+    "running_command",
+    "editing_files",
+    "waiting_approval",
+    "completed",
+    "paused",
+    "stopped"
+  ]) {
+    assert.ok(TASK_STATUSES.includes(status), `missing ${status}`);
+  }
+  assert.equal(isTaskStatus("running_command"), true);
+  assert.equal(isTaskStatus("nope"), false);
+});
+
+test("maps detailed task status down to normalized AI state", () => {
+  assert.equal(mapTaskStatusToAiState("running_command"), "running_tool");
+  assert.equal(mapTaskStatusToAiState("waiting_approval"), "waiting_approval");
+  assert.equal(mapTaskStatusToAiState("reviewing"), "reviewing");
+  assert.equal(mapTaskStatusToAiState("completed"), "success");
+  assert.equal(mapTaskStatusToAiState("paused"), "idle");
+});
+
+test("maps task status to pet action through the AI state", () => {
+  assert.equal(mapTaskStatusToPetAction("running_command"), "running");
+  assert.equal(mapTaskStatusToPetAction("waiting_approval"), "waiting");
+  assert.equal(mapTaskStatusToPetAction("completed"), "jumping");
+});
+
+test("renders stable status pills", () => {
+  assert.equal(buildTaskStatusPill("running_command"), "Running command");
+  assert.equal(buildTaskStatusPill("waiting_user"), "Waiting for you");
+  assert.equal(buildTaskStatusPill("compacting"), "Compacting context");
+});
+
+test("throws on unknown task status mapping", () => {
+  assert.throws(() => mapTaskStatusToAiState("bogus"), /Unknown task status/);
+});

package/packages/task-core/test/task-store.test.mjs

@@ -0,0 +1,65 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import { createTaskStore } from "../src/task-store.js";
+
+test("appends events and returns recent history per session", () => {
+  const store = createTaskStore();
+
+  store.appendEvent({ id: "e1", sessionId: "s", type: "user_message", timestamp: 1, text: "hi" });
+  store.appendEvent({ id: "e2", sessionId: "s", type: "assistant_message", timestamp: 2, text: "yo" });
+
+  const events = store.getEvents("s");
+  assert.equal(events.length, 2);
+  assert.equal(store.getLatestEvent("s").id, "e2");
+});
+
+test("rejects invalid events", () => {
+  const store = createTaskStore();
+  assert.throws(() => store.appendEvent({ type: "user_message" }), /sessionId/);
+});
+
+test("derives a status snapshot from status-bearing events", () => {
+  const store = createTaskStore();
+  store.appendEvent({
+    id: "e1",
+    sessionId: "s",
+    type: "status_changed",
+    timestamp: 10,
+    status: "running_command",
+    confidence: 0.8,
+    source: "pty_output",
+    text: "running tests"
+  });
+
+  const snapshot = store.getStatusSnapshot("s");
+  assert.equal(snapshot.sessionId, "s");
+  assert.equal(snapshot.status, "running_command");
+  assert.equal(snapshot.aiState, "running_tool");
+  assert.equal(snapshot.petAction, "running");
+  assert.equal(snapshot.confidence, 0.8);
+  assert.equal(snapshot.source, "pty_output");
+  assert.equal(snapshot.updatedAt, 10);
+});
+
+test("caps stored history to the configured maximum", () => {
+  const store = createTaskStore({ maxEventsPerSession: 2 });
+  for (let i = 0; i < 5; i += 1) {
+    store.appendEvent({ id: `e${i}`, sessionId: "s", type: "tool_output", timestamp: i });
+  }
+  const events = store.getEvents("s");
+  assert.equal(events.length, 2);
+  assert.deepEqual(events.map((e) => e.id), ["e3", "e4"]);
+});
+
+test("limits returned events when a limit is requested", () => {
+  const store = createTaskStore();
+  for (let i = 0; i < 5; i += 1) {
+    store.appendEvent({ id: `e${i}`, sessionId: "s", type: "tool_output", timestamp: i });
+  }
+  assert.equal(store.getEvents("s", { limit: 2 }).length, 2);
+});
+
+test("returns an undefined snapshot for unknown sessions", () => {
+  const store = createTaskStore();
+  assert.equal(store.getStatusSnapshot("missing"), undefined);
+});

package/test/harness.mjs

@@ -0,0 +1,22 @@
+const tests = [];
+
+export function test(name, fn) {
+  tests.push({ name, fn });
+}
+
+export async function runRegisteredTests() {
+  let failed = 0;
+
+  for (const entry of tests) {
+    try {
+      await entry.fn();
+      console.log(`ok - ${entry.name}`);
+    } catch (error) {
+      failed += 1;
+      console.error(`not ok - ${entry.name}`);
+      console.error(error && error.stack ? error.stack : error);
+    }
+  }
+
+  return { total: tests.length, failed };
+}

package/test/run-tests.mjs

@@ -0,0 +1,47 @@
+import { readdir } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { runRegisteredTests } from "./harness.mjs";
+
+async function findTestFiles(dir) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const files = [];
+
+  for (const entry of entries) {
+    const absolute = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await findTestFiles(absolute));
+    } else if (entry.name.endsWith(".test.mjs")) {
+      files.push(absolute);
+    }
+  }
+
+  return files;
+}
+
+const root = fileURLToPath(new URL("..", import.meta.url));
+const testRoots = ["packages", "apps"];
+const testFiles = [];
+
+for (const testRoot of testRoots) {
+  try {
+    testFiles.push(...await findTestFiles(join(root, testRoot)));
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+}
+
+for (const file of testFiles) {
+  const displayPath = relative(root, file).split(sep).join("/");
+  console.log(`# ${displayPath}`);
+  await import(pathToFileURL(file));
+}
+
+const result = await runRegisteredTests();
+console.log(`# ${result.total - result.failed}/${result.total} tests passed`);
+
+if (result.failed > 0) {
+  process.exitCode = 1;
+}