@hayasaka7/haya-pet 0.1.0

package/packages/task-core/src/controls.js

@@ -0,0 +1,61 @@
+// Task control buttons (product plan section 23). The UI must hide or disable
+// any control the selected adapter cannot safely support.
+export const TASK_CONTROL_IDS = Object.freeze([
+  "focus_terminal",
+  "open_full",
+  "reply",
+  "approve",
+  "deny",
+  "continue",
+  "pause",
+  "resume",
+  "stop",
+  "restart",
+  "hide"
+]);
+
+const CONTROL_LABELS = Object.freeze({
+  focus_terminal: "Focus Terminal",
+  open_full: "Open Full Session",
+  reply: "Reply",
+  approve: "Approve",
+  deny: "Deny",
+  continue: "Continue",
+  pause: "Pause",
+  resume: "Resume",
+  stop: "Stop",
+  restart: "Restart",
+  hide: "Hide"
+});
+
+export function resolveTaskControls(capabilities = {}, status) {
+  const hasPendingApproval = status === "waiting_approval";
+  const canReply = capabilities.canReply !== undefined && capabilities.canReply !== "unsupported";
+  const canApprove = capabilities.canApprove !== undefined && capabilities.canApprove !== "unsupported";
+
+  const enabledById = {
+    focus_terminal: Boolean(capabilities.canFocusTerminal),
+    open_full: Boolean(capabilities.canOpenTranscript),
+    reply: canReply,
+    approve: canApprove && hasPendingApproval,
+    deny: canApprove && hasPendingApproval,
+    continue: Boolean(capabilities.canResume),
+    pause: Boolean(capabilities.canPause),
+    resume: Boolean(capabilities.canResume),
+    stop: Boolean(capabilities.canStop),
+    restart: Boolean(capabilities.canStop),
+    hide: true
+  };
+
+  return TASK_CONTROL_IDS.map((id) => ({
+    id,
+    label: CONTROL_LABELS[id],
+    enabled: enabledById[id]
+  }));
+}
+
+export function listEnabledControls(capabilities, status) {
+  return resolveTaskControls(capabilities, status)
+    .filter((control) => control.enabled)
+    .map((control) => control.id);
+}

package/packages/task-core/src/replies.js

@@ -0,0 +1,80 @@
+export function buildTaskInputRequest({ sessionId, inputId, text, createdAt }) {
+  return {
+    type: "task_input",
+    sessionId,
+    inputId,
+    text,
+    createdAt
+  };
+}
+
+export function validateTaskInputRequest(input) {
+  if (!isPlainObject(input)) {
+    return { ok: false, errors: ["task input request must be an object"] };
+  }
+
+  const errors = [];
+
+  if (input.type !== "task_input") {
+    errors.push('type must be "task_input"');
+  }
+
+  requireNonEmptyString(errors, input.sessionId, "sessionId");
+  requireNonEmptyString(errors, input.inputId, "inputId");
+  requireNonEmptyString(errors, input.text, "text");
+
+  if (!Number.isFinite(input.createdAt)) {
+    errors.push("createdAt must be a finite number");
+  }
+
+  return { ok: errors.length === 0, errors };
+}
+
+export function validateTaskInputResult(input) {
+  if (!isPlainObject(input)) {
+    return { ok: false, errors: ["task input result must be an object"] };
+  }
+
+  const errors = [];
+
+  if (input.type !== "task_input_result") {
+    errors.push('type must be "task_input_result"');
+  }
+
+  requireNonEmptyString(errors, input.sessionId, "sessionId");
+  requireNonEmptyString(errors, input.inputId, "inputId");
+
+  if (typeof input.ok !== "boolean") {
+    errors.push("ok must be a boolean");
+  }
+
+  if (input.error !== undefined && typeof input.error !== "string") {
+    errors.push("error must be a string when provided");
+  }
+
+  return { ok: errors.length === 0, errors };
+}
+
+// Translate adapter reply capability into a safe UI mode. The reply button must
+// never blindly type into a terminal when the adapter cannot verify the client
+// is waiting for input (product plan section 21).
+export function resolveReplyMode(capabilities = {}) {
+  switch (capabilities.canReply) {
+    case "supported":
+      return "send";
+    case "best_effort":
+      return "best-effort";
+    default:
+      return "open-terminal";
+  }
+}
+
+function requireNonEmptyString(errors, value, fieldName) {
+  if (typeof value !== "string" || value.trim() === "") {
+    errors.push(`${fieldName} must be a non-empty string`);
+  }
+}
+
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/packages/task-core/src/task-events.js

@@ -0,0 +1,101 @@
+import { isStateSource } from "../../protocol/src/messages.js";
+import { isTaskStatus } from "./task-status.js";
+
+export const TASK_EVENT_TYPES = Object.freeze([
+  "user_message",
+  "assistant_message",
+  "assistant_delta",
+  "status_changed",
+  "tool_started",
+  "tool_output",
+  "tool_finished",
+  "file_changed",
+  "diff_ready",
+  "test_started",
+  "test_finished",
+  "approval_requested",
+  "approval_resolved",
+  "error",
+  "summary",
+  "task_completed"
+]);
+
+const TASK_EVENT_TYPE_SET = new Set(TASK_EVENT_TYPES);
+
+export function isTaskEventType(value) {
+  return TASK_EVENT_TYPE_SET.has(value);
+}
+
+export function normalizeTaskEvent(input) {
+  if (!isPlainObject(input)) {
+    return { ok: false, errors: ["event must be an object"] };
+  }
+
+  const errors = [];
+
+  requireNonEmptyString(errors, input.id, "id");
+  requireNonEmptyString(errors, input.sessionId, "sessionId");
+
+  if (!isTaskEventType(input.type)) {
+    errors.push(`type must be one of: ${TASK_EVENT_TYPES.join(", ")}`);
+  }
+
+  if (!Number.isFinite(input.timestamp)) {
+    errors.push("timestamp must be a finite number");
+  }
+
+  if (input.status !== undefined && !isTaskStatus(input.status)) {
+    errors.push("status must be a valid task status when provided");
+  }
+
+  if (input.source !== undefined && !isStateSource(input.source)) {
+    errors.push("source must be a valid state source when provided");
+  }
+
+  if (input.title !== undefined && typeof input.title !== "string") {
+    errors.push("title must be a string when provided");
+  }
+
+  if (input.text !== undefined && typeof input.text !== "string") {
+    errors.push("text must be a string when provided");
+  }
+
+  if (input.confidence !== undefined) {
+    if (!Number.isFinite(input.confidence) || input.confidence < 0 || input.confidence > 1) {
+      errors.push("confidence must be a number from 0 to 1 when provided");
+    }
+  }
+
+  if (errors.length > 0) {
+    return { ok: false, errors };
+  }
+
+  return { ok: true, errors: [], event: buildEvent(input) };
+}
+
+function buildEvent(input) {
+  const event = {
+    id: input.id,
+    sessionId: input.sessionId,
+    type: input.type,
+    timestamp: input.timestamp
+  };
+
+  for (const field of ["title", "text", "status", "confidence", "source", "payload"]) {
+    if (input[field] !== undefined) {
+      event[field] = input[field];
+    }
+  }
+
+  return event;
+}
+
+function requireNonEmptyString(errors, value, fieldName) {
+  if (typeof value !== "string" || value.trim() === "") {
+    errors.push(`${fieldName} must be a non-empty string`);
+  }
+}
+
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/packages/task-core/src/task-status.js

@@ -0,0 +1,93 @@
+import { mapAiStateToPetAction } from "../../pet-core/src/atlas.js";
+
+export const TASK_STATUSES = Object.freeze([
+  "starting",
+  "thinking",
+  "running",
+  "running_command",
+  "editing_files",
+  "searching",
+  "waiting_user",
+  "waiting_approval",
+  "reviewing",
+  "compacting",
+  "blocked",
+  "failed",
+  "completed",
+  "paused",
+  "stopped",
+  "stale",
+  "exited"
+]);
+
+const TASK_STATUS_SET = new Set(TASK_STATUSES);
+
+const TASK_STATUS_TO_AI_STATE = Object.freeze({
+  starting: "thinking",
+  thinking: "thinking",
+  running: "running_tool",
+  running_command: "running_tool",
+  editing_files: "editing_files",
+  searching: "running_tool",
+  waiting_user: "waiting_user",
+  waiting_approval: "waiting_approval",
+  reviewing: "reviewing",
+  compacting: "compacting",
+  blocked: "waiting_user",
+  failed: "failed",
+  completed: "success",
+  paused: "idle",
+  stopped: "exited",
+  stale: "stale",
+  exited: "exited"
+});
+
+const TASK_STATUS_PILLS = Object.freeze({
+  starting: "Starting",
+  thinking: "Thinking",
+  running: "Running",
+  running_command: "Running command",
+  editing_files: "Editing files",
+  searching: "Searching",
+  waiting_user: "Waiting for you",
+  waiting_approval: "Waiting for approval",
+  reviewing: "Reviewing",
+  compacting: "Compacting context",
+  blocked: "Blocked",
+  failed: "Failed",
+  completed: "Completed",
+  paused: "Paused",
+  stopped: "Stopped",
+  stale: "Stale",
+  exited: "Exited"
+});
+
+export function isTaskStatus(value) {
+  return TASK_STATUS_SET.has(value);
+}
+
+export function mapTaskStatusToAiState(status) {
+  const aiState = TASK_STATUS_TO_AI_STATE[status];
+  if (!aiState) {
+    throw new Error(`Unknown task status: ${status}`);
+  }
+
+  return aiState;
+}
+
+export function mapTaskStatusToPetAction(status) {
+  return mapAiStateToPetAction(mapTaskStatusToAiState(status));
+}
+
+export function buildTaskStatusPill(status) {
+  return TASK_STATUS_PILLS[status] ?? humanize(status);
+}
+
+function humanize(value) {
+  if (typeof value !== "string" || value === "") {
+    return "Unknown";
+  }
+
+  const text = value.replace(/_/g, " ");
+  return text.charAt(0).toUpperCase() + text.slice(1);
+}

package/packages/task-core/src/task-store.js

@@ -0,0 +1,74 @@
+import { normalizeTaskEvent } from "./task-events.js";
+import { mapTaskStatusToAiState, mapTaskStatusToPetAction } from "./task-status.js";
+
+const DEFAULT_MAX_EVENTS = 200;
+
+export function createTaskStore(options = {}) {
+  return new TaskStore(options);
+}
+
+class TaskStore {
+  constructor(options) {
+    this.maxEventsPerSession = options.maxEventsPerSession ?? DEFAULT_MAX_EVENTS;
+    this.events = new Map();
+    this.snapshots = new Map();
+  }
+
+  appendEvent(input) {
+    const result = normalizeTaskEvent(input);
+    if (!result.ok) {
+      throw new Error(result.errors.join("; "));
+    }
+
+    const event = result.event;
+    const list = this.events.get(event.sessionId) ?? [];
+    list.push(event);
+
+    while (list.length > this.maxEventsPerSession) {
+      list.shift();
+    }
+
+    this.events.set(event.sessionId, list);
+
+    if (event.status !== undefined) {
+      this.updateSnapshot(event);
+    }
+
+    return { ...event };
+  }
+
+  getEvents(sessionId, options = {}) {
+    const list = this.events.get(sessionId) ?? [];
+    const events = options.limit ? list.slice(-options.limit) : list.slice();
+    return events.map((event) => ({ ...event }));
+  }
+
+  getLatestEvent(sessionId) {
+    const list = this.events.get(sessionId);
+    if (!list || list.length === 0) {
+      return undefined;
+    }
+
+    return { ...list[list.length - 1] };
+  }
+
+  getStatusSnapshot(sessionId) {
+    const snapshot = this.snapshots.get(sessionId);
+    return snapshot ? { ...snapshot } : undefined;
+  }
+
+  updateSnapshot(event) {
+    const previous = this.snapshots.get(event.sessionId);
+
+    this.snapshots.set(event.sessionId, {
+      sessionId: event.sessionId,
+      status: event.status,
+      aiState: mapTaskStatusToAiState(event.status),
+      petAction: mapTaskStatusToPetAction(event.status),
+      confidence: Number.isFinite(event.confidence) ? event.confidence : previous?.confidence ?? 1,
+      source: event.source ?? previous?.source ?? "manual",
+      updatedAt: event.timestamp,
+      summary: event.text ?? previous?.summary
+    });
+  }
+}

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

@@ -0,0 +1,61 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import {
+  APPROVAL_KINDS,
+  validateApprovalRequest,
+  buildApprovalDecision,
+  validateApprovalDecision
+} from "../src/approvals.js";
+
+test("validates an approval request with the documented fields", () => {
+  const result = validateApprovalRequest({
+    approvalId: "ap_1",
+    sessionId: "s",
+    kind: "command",
+    title: "Run npm test",
+    commandPreview: "npm test",
+    risk: "medium",
+    requestedAt: 100
+  });
+
+  assert.equal(result.ok, true);
+  assert.deepEqual(result.errors, []);
+  assert.ok(APPROVAL_KINDS.includes("file_write"));
+});
+
+test("rejects approval requests with invalid kind or risk", () => {
+  const result = validateApprovalRequest({
+    approvalId: "ap_1",
+    sessionId: "s",
+    kind: "launch_missiles",
+    title: "x",
+    risk: "extreme",
+    requestedAt: 1
+  });
+  assert.equal(result.ok, false);
+  assert.ok(result.errors.some((m) => m.includes("kind")));
+  assert.ok(result.errors.some((m) => m.includes("risk")));
+});
+
+test("builds and validates an approval decision", () => {
+  const decision = buildApprovalDecision({
+    sessionId: "s",
+    approvalId: "ap_1",
+    decision: "approve",
+    decidedAt: 200
+  });
+  assert.equal(decision.type, "approval_decision");
+  assert.equal(validateApprovalDecision(decision).ok, true);
+});
+
+test("rejects decisions that are not approve or deny", () => {
+  const result = validateApprovalDecision({
+    type: "approval_decision",
+    sessionId: "s",
+    approvalId: "ap_1",
+    decision: "maybe",
+    decidedAt: 1
+  });
+  assert.equal(result.ok, false);
+  assert.ok(result.errors.some((m) => m.includes("decision")));
+});

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

@@ -0,0 +1,61 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import { resolveTaskControls, listEnabledControls } from "../src/controls.js";
+
+const WRAPPER_CAPS = {
+  canReply: "unsupported",
+  canApprove: "unsupported",
+  canPause: false,
+  canResume: false,
+  canStop: true,
+  canFocusTerminal: true,
+  canOpenTranscript: false,
+  canShowDiffs: false,
+  canShowFiles: false,
+  canShowTests: false
+};
+
+const PTY_CAPS = {
+  canReply: "best_effort",
+  canApprove: "best_effort",
+  canPause: false,
+  canResume: false,
+  canStop: true,
+  canFocusTerminal: true,
+  canOpenTranscript: false,
+  canShowDiffs: false,
+  canShowFiles: false,
+  canShowTests: false
+};
+
+test("disables reply and approval for wrapper-only adapters", () => {
+  const controls = resolveTaskControls(WRAPPER_CAPS, "waiting_approval");
+  const reply = controls.find((c) => c.id === "reply");
+  const approve = controls.find((c) => c.id === "approve");
+  assert.equal(reply.enabled, false);
+  assert.equal(approve.enabled, false);
+  const focus = controls.find((c) => c.id === "focus_terminal");
+  assert.equal(focus.enabled, true);
+});
+
+test("enables approval only when a pending approval exists", () => {
+  const waiting = resolveTaskControls(PTY_CAPS, "waiting_approval");
+  assert.equal(waiting.find((c) => c.id === "approve").enabled, true);
+
+  const running = resolveTaskControls(PTY_CAPS, "running_command");
+  assert.equal(running.find((c) => c.id === "approve").enabled, false);
+});
+
+test("listEnabledControls returns only enabled control ids", () => {
+  const enabled = listEnabledControls(WRAPPER_CAPS, "running_command");
+  assert.ok(enabled.includes("focus_terminal"));
+  assert.ok(enabled.includes("stop"));
+  assert.ok(enabled.includes("hide"));
+  assert.ok(!enabled.includes("reply"));
+  assert.ok(!enabled.includes("approve"));
+});
+
+test("always allows hide regardless of capabilities", () => {
+  const controls = resolveTaskControls(WRAPPER_CAPS, "idle");
+  assert.equal(controls.find((c) => c.id === "hide").enabled, true);
+});

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

@@ -0,0 +1,51 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import {
+  buildTaskInputRequest,
+  validateTaskInputRequest,
+  validateTaskInputResult,
+  resolveReplyMode
+} from "../src/replies.js";
+
+test("builds and validates a task input request", () => {
+  const request = buildTaskInputRequest({
+    sessionId: "s",
+    inputId: "in_1",
+    text: "continue please",
+    createdAt: 10
+  });
+  assert.equal(request.type, "task_input");
+  assert.equal(validateTaskInputRequest(request).ok, true);
+});
+
+test("rejects empty reply text", () => {
+  const result = validateTaskInputRequest({
+    type: "task_input",
+    sessionId: "s",
+    inputId: "in_1",
+    text: "   ",
+    createdAt: 1
+  });
+  assert.equal(result.ok, false);
+  assert.ok(result.errors.some((m) => m.includes("text")));
+});
+
+test("validates a task input result", () => {
+  assert.equal(
+    validateTaskInputResult({
+      type: "task_input_result",
+      sessionId: "s",
+      inputId: "in_1",
+      ok: true,
+      acceptedAt: 20
+    }).ok,
+    true
+  );
+});
+
+test("resolves the safe reply mode from adapter capability", () => {
+  assert.equal(resolveReplyMode({ canReply: "supported" }), "send");
+  assert.equal(resolveReplyMode({ canReply: "best_effort" }), "best-effort");
+  assert.equal(resolveReplyMode({ canReply: "unsupported" }), "open-terminal");
+  assert.equal(resolveReplyMode({}), "open-terminal");
+});

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

@@ -0,0 +1,67 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import {
+  TASK_EVENT_TYPES,
+  isTaskEventType,
+  normalizeTaskEvent
+} from "../src/task-events.js";
+
+test("defines the documented task event vocabulary", () => {
+  for (const type of [
+    "user_message",
+    "assistant_message",
+    "status_changed",
+    "tool_started",
+    "approval_requested",
+    "task_completed"
+  ]) {
+    assert.ok(TASK_EVENT_TYPES.includes(type), `missing ${type}`);
+  }
+  assert.equal(isTaskEventType("tool_output"), true);
+  assert.equal(isTaskEventType("nope"), false);
+});
+
+test("normalizes a valid task event", () => {
+  const result = normalizeTaskEvent({
+    id: "evt_1",
+    sessionId: "sess_a",
+    type: "status_changed",
+    timestamp: 1000,
+    status: "running_command",
+    source: "pty_output",
+    text: "running tests"
+  });
+
+  assert.equal(result.ok, true);
+  assert.deepEqual(result.errors, []);
+  assert.equal(result.event.type, "status_changed");
+  assert.equal(result.event.status, "running_command");
+});
+
+test("rejects events with missing or invalid fields", () => {
+  const missing = normalizeTaskEvent({ type: "user_message" });
+  assert.equal(missing.ok, false);
+  assert.ok(missing.errors.some((m) => m.includes("id")));
+  assert.ok(missing.errors.some((m) => m.includes("sessionId")));
+
+  const badType = normalizeTaskEvent({
+    id: "e",
+    sessionId: "s",
+    type: "explode",
+    timestamp: 1
+  });
+  assert.equal(badType.ok, false);
+  assert.ok(badType.errors.some((m) => m.includes("type")));
+});
+
+test("rejects an invalid status on an otherwise valid event", () => {
+  const result = normalizeTaskEvent({
+    id: "e",
+    sessionId: "s",
+    type: "status_changed",
+    timestamp: 1,
+    status: "not-a-status"
+  });
+  assert.equal(result.ok, false);
+  assert.ok(result.errors.some((m) => m.includes("status")));
+});