@hayasaka7/haya-pet 0.1.0

package/packages/adapters/src/output-observer.js

@@ -0,0 +1,164 @@
+import { getClientRules, matchAiState } from "./heuristics.js";
+
+// Confidence is intentionally moderate: PTY output is best-effort and lower
+// precedence than official hooks or client state files (plan §25).
+const DEFAULT_CONFIDENCE = 0.6;
+const SUMMARY_MAX_LENGTH = 120;
+// Quiet window after which we assume the CLI stopped working (e.g. waiting for
+// the user) and revert to idle.
+const DEFAULT_IDLE_MS = 2000;
+const DEFAULT_ACTIVE_STATE = "running_tool";
+// How long after a keystroke we treat fresh output as the terminal echoing the
+// user's typing rather than the AI working. Each keystroke re-arms it, so a
+// burst of typing never registers as activity.
+const DEFAULT_INPUT_GRACE_MS = 250;
+
+const defaultSetTimer = (fn, ms) => {
+  const timer = setTimeout(fn, ms);
+  if (typeof timer.unref === "function") {
+    timer.unref();
+  }
+  return timer;
+};
+const defaultClearTimer = (id) => clearTimeout(id);
+
+// Level 2 PTY observer (product plan section 6/24).
+//
+// Default mode is ACTIVITY-BASED, which is robust for rich TUIs (Claude Code,
+// Codex) where output is full of ANSI/redraws and rarely contains tidy keywords:
+//   - any visible output  -> "working" (running_tool)
+//   - no output for idleMs -> idle
+// It deliberately does NOT infer "failed" from output text — a stray "error" in
+// normal content must not flip the pet to failed; real failures come from the
+// process exit code in the wrapper.
+//
+// Opt in to keyword heuristics with `useHeuristics: true` to additionally detect
+// specific states (e.g. waiting_approval) from recognizable lines.
+export function createOutputObserver({
+  clientId,
+  rules,
+  onState,
+  now = Date.now,
+  confidence = DEFAULT_CONFIDENCE,
+  idleMs = DEFAULT_IDLE_MS,
+  idleState = "idle",
+  activeState = DEFAULT_ACTIVE_STATE,
+  useHeuristics = false,
+  inputGraceMs = DEFAULT_INPUT_GRACE_MS,
+  setTimer = defaultSetTimer,
+  clearTimer = defaultClearTimer
+} = {}) {
+  if (typeof onState !== "function") {
+    throw new TypeError("onState must be a function");
+  }
+
+  const resolvedRules = rules ?? getClientRules(clientId);
+  let buffer = "";
+  let currentState;
+  let idleTimer;
+  let lastInputAt;
+
+  // True while fresh output is most likely the terminal echoing the user's
+  // keystrokes (which a PTY mirrors back) rather than AI activity.
+  function isInputEcho() {
+    return inputGraceMs > 0 && lastInputAt !== undefined && now() - lastInputAt <= inputGraceMs;
+  }
+
+  function emit(state, summary) {
+    currentState = state;
+    onState({ state, summary, confidence, source: "pty_output", updatedAt: now() });
+  }
+
+  function cancelIdle() {
+    if (idleTimer !== undefined) {
+      clearTimer(idleTimer);
+      idleTimer = undefined;
+    }
+  }
+
+  function armIdle() {
+    if (!idleMs) {
+      return;
+    }
+    cancelIdle();
+    idleTimer = setTimer(() => {
+      idleTimer = undefined;
+      if (currentState !== idleState) {
+        emit(idleState, "no recent activity");
+      }
+    }, idleMs);
+  }
+
+  return {
+    noteInput() {
+      // Record that the user just typed; subsequent echoed output is not work.
+      lastInputAt = now();
+    },
+
+    push(chunk) {
+      const text = String(chunk);
+      buffer += text;
+
+      // Echoed keystrokes are the user, not the AI — don't classify or count
+      // them as activity, but keep the buffer bounded.
+      const echo = isInputEcho();
+
+      let matched = false;
+      if (useHeuristics && !echo) {
+        let newlineIndex = buffer.indexOf("\n");
+        while (newlineIndex !== -1) {
+          const line = buffer.slice(0, newlineIndex);
+          buffer = buffer.slice(newlineIndex + 1);
+          const state = matchAiState(line, resolvedRules);
+          if (state) {
+            matched = true;
+            if (state !== currentState) {
+              emit(state, summarize(line));
+            }
+          }
+          newlineIndex = buffer.indexOf("\n");
+        }
+      } else {
+        // Activity mode (or echo): we don't classify lines, so drop completed
+        // ones to keep the buffer bounded.
+        const lastNewline = buffer.lastIndexOf("\n");
+        if (lastNewline !== -1) {
+          buffer = buffer.slice(lastNewline + 1);
+        }
+      }
+
+      const hadOutput = /\S/.test(text);
+      if (hadOutput && !echo) {
+        if (!matched && currentState !== activeState) {
+          emit(activeState, "working");
+        }
+        armIdle();
+      }
+
+      return currentState;
+    },
+
+    flush() {
+      buffer = "";
+      return currentState;
+    },
+
+    getState() {
+      return currentState;
+    },
+
+    stop() {
+      cancelIdle();
+    },
+
+    reset() {
+      buffer = "";
+      currentState = undefined;
+      cancelIdle();
+    }
+  };
+}
+
+function summarize(line) {
+  return line.trim().slice(0, SUMMARY_MAX_LENGTH);
+}

package/packages/adapters/src/routing.js

@@ -0,0 +1,86 @@
+import { validateTaskInputRequest } from "../../task-core/src/replies.js";
+import { validateApprovalDecision } from "../../task-core/src/approvals.js";
+
+// Maps an adapter capability level to a concrete injection strategy following
+// the preferred order in product plan section 24. The "focus_terminal" result
+// means the runtime must NOT inject and should fall back to the user typing.
+function strategyFor(level) {
+  if (level === "supported") {
+    return "structured";
+  }
+  if (level === "best_effort") {
+    return "pty";
+  }
+  return "focus_terminal";
+}
+
+export function resolveReplyStrategy(capabilities = {}) {
+  return strategyFor(capabilities.canReply);
+}
+
+export function resolveApprovalStrategy(capabilities = {}) {
+  return strategyFor(capabilities.canApprove);
+}
+
+export async function routeReply({ request, capabilities = {}, injectors = {}, now = Date.now }) {
+  const validation = validateTaskInputRequest(request);
+  if (!validation.ok) {
+    return replyResult(request, { ok: false, error: validation.errors.join("; ") });
+  }
+
+  const strategy = resolveReplyStrategy(capabilities);
+  if (strategy === "focus_terminal") {
+    return replyResult(request, { ok: false, error: "reply_unsupported" });
+  }
+
+  return dispatch(injectors[strategy], request, () => replyResult(request, { ok: true, acceptedAt: now() }), (error) =>
+    replyResult(request, { ok: false, error })
+  );
+}
+
+export async function routeApproval({ decision, capabilities = {}, injectors = {}, now = Date.now }) {
+  const validation = validateApprovalDecision(decision);
+  if (!validation.ok) {
+    return approvalResult(decision, { ok: false, error: validation.errors.join("; ") });
+  }
+
+  const strategy = resolveApprovalStrategy(capabilities);
+  if (strategy === "focus_terminal") {
+    return approvalResult(decision, { ok: false, error: "approval_unsupported" });
+  }
+
+  return dispatch(injectors[strategy], decision, () => approvalResult(decision, { ok: true, decidedAt: now() }), (error) =>
+    approvalResult(decision, { ok: false, error })
+  );
+}
+
+async function dispatch(injector, payload, onOk, onError) {
+  if (typeof injector !== "function") {
+    return onError("no_injector");
+  }
+
+  try {
+    await injector(payload);
+    return onOk();
+  } catch (error) {
+    return onError(error?.message ?? String(error));
+  }
+}
+
+function replyResult(request, fields) {
+  return {
+    type: "task_input_result",
+    sessionId: request?.sessionId,
+    inputId: request?.inputId,
+    ...fields
+  };
+}
+
+function approvalResult(decision, fields) {
+  return {
+    type: "approval_result",
+    sessionId: decision?.sessionId,
+    approvalId: decision?.approvalId,
+    ...fields
+  };
+}

package/packages/adapters/test/adapter-info.test.mjs

@@ -0,0 +1,35 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import {
+  KNOWN_CLIENT_IDS,
+  getAdapterInfo,
+  listAdapters,
+  resolveAdapterInfo
+} from "../src/adapter-info.js";
+
+test("registers the four initial client targets", () => {
+  assert.deepEqual(KNOWN_CLIENT_IDS, ["codex", "claude-code", "antigravity", "generic"]);
+  assert.equal(listAdapters().length, 4);
+});
+
+test("exposes adapter info fields from the plan", () => {
+  const codex = getAdapterInfo("codex");
+  assert.equal(codex.id, "codex");
+  assert.equal(codex.displayName, "Codex");
+  assert.ok([1, 2, 3, 4].includes(codex.supportLevel));
+  assert.ok(Array.isArray(codex.knownProcessNames));
+});
+
+test("returns undefined for unknown clients", () => {
+  assert.equal(getAdapterInfo("nope"), undefined);
+});
+
+test("resolves unknown clients to a generic-based adapter", () => {
+  const resolved = resolveAdapterInfo("my-ai-cli");
+  assert.equal(resolved.id, "my-ai-cli");
+  assert.equal(resolved.displayName, "my-ai-cli");
+  assert.equal(resolved.supportLevel, 1);
+
+  const known = resolveAdapterInfo("claude-code");
+  assert.equal(known.displayName, "Claude Code");
+});

package/packages/adapters/test/capabilities.test.mjs

@@ -0,0 +1,44 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import { getAdapterCapabilities } from "../src/capabilities.js";
+
+test("generic wrapper cannot safely reply or approve", () => {
+  const caps = getAdapterCapabilities("generic");
+  assert.equal(caps.canReply, "unsupported");
+  assert.equal(caps.canApprove, "unsupported");
+  assert.equal(caps.canStop, true);
+});
+
+test("PTY-capable adapters report best-effort reply/approval", () => {
+  const codex = getAdapterCapabilities("codex");
+  assert.equal(codex.canReply, "best_effort");
+  assert.equal(codex.canApprove, "best_effort");
+
+  const claude = getAdapterCapabilities("claude-code");
+  assert.equal(claude.canReply, "best_effort");
+});
+
+test("unknown clients fall back to safe wrapper capabilities", () => {
+  const caps = getAdapterCapabilities("mystery");
+  assert.equal(caps.canReply, "unsupported");
+  assert.equal(caps.canApprove, "unsupported");
+  assert.equal(typeof caps.canFocusTerminal, "boolean");
+});
+
+test("capability objects declare every documented field", () => {
+  const caps = getAdapterCapabilities("codex");
+  for (const field of [
+    "canReply",
+    "canApprove",
+    "canPause",
+    "canResume",
+    "canStop",
+    "canFocusTerminal",
+    "canOpenTranscript",
+    "canShowDiffs",
+    "canShowFiles",
+    "canShowTests"
+  ]) {
+    assert.ok(field in caps, `missing ${field}`);
+  }
+});

package/packages/adapters/test/heuristics.test.mjs

@@ -0,0 +1,42 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import {
+  DEFAULT_GENERIC_RULES,
+  getClientRules,
+  matchAiState
+} from "../src/heuristics.js";
+
+test("matches generic regex rules to normalized states", () => {
+  assert.equal(matchAiState("Do you want to approve this command?"), "waiting_approval");
+  assert.equal(matchAiState("$ npm test"), "running_tool");
+  assert.equal(matchAiState("Error: build failed"), "failed");
+  assert.equal(matchAiState("Reviewing the diff now"), "reviewing");
+});
+
+test("returns undefined when no rule matches", () => {
+  assert.equal(matchAiState("just some neutral text"), undefined);
+});
+
+test("prefers the most urgent state when multiple rules match", () => {
+  // contains both "running" and "permission" -> approval should win
+  assert.equal(matchAiState("running command, needs permission to continue"), "waiting_approval");
+});
+
+test("exposes default generic rules covering the documented categories", () => {
+  assert.ok(DEFAULT_GENERIC_RULES.waiting_approval);
+  assert.ok(DEFAULT_GENERIC_RULES.running_tool);
+  assert.ok(DEFAULT_GENERIC_RULES.failed);
+  assert.ok(DEFAULT_GENERIC_RULES.reviewing);
+});
+
+test("provides client-specific rules with generic fallback", () => {
+  const codexRules = getClientRules("codex");
+  assert.ok(codexRules.editing_files);
+
+  const fallback = getClientRules("unknown-client");
+  assert.deepEqual(fallback, DEFAULT_GENERIC_RULES);
+});
+
+test("ignores invalid patterns instead of throwing", () => {
+  assert.doesNotThrow(() => matchAiState("text", { failed: ["(unclosed"] }));
+});

package/packages/adapters/test/output-observer.test.mjs

@@ -0,0 +1,142 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import { createOutputObserver } from "../src/output-observer.js";
+
+function makeObserver(overrides = {}) {
+  const states = [];
+  const timers = [];
+  const observer = createOutputObserver({
+    clientId: "generic",
+    now: () => 1,
+    onState: (event) => states.push(event),
+    setTimer: (fn) => {
+      timers.push(fn);
+      return timers.length - 1;
+    },
+    clearTimer: (id) => {
+      timers[id] = undefined;
+    },
+    ...overrides
+  });
+  return { observer, states, fireIdle: () => timers.filter(Boolean).at(-1)?.() };
+}
+
+// --- Default: activity-based ---
+
+test("treats any output as working (running_tool)", () => {
+  const { observer, states } = makeObserver();
+  observer.push("anything the AI prints\n");
+  assert.equal(states.at(-1).state, "running_tool");
+  assert.equal(states.at(-1).source, "pty_output");
+});
+
+test("does NOT infer failed from a stray 'error' in output", () => {
+  const { observer, states } = makeObserver();
+  observer.push("No errors found; build succeeded\n");
+  // activity = working, never failed
+  assert.equal(states.at(-1).state, "running_tool");
+  assert.ok(!states.some((event) => event.state === "failed"));
+});
+
+test("does not re-emit working on continued output", () => {
+  const { observer, states } = makeObserver();
+  observer.push("line one\n");
+  observer.push("line two\n");
+  assert.equal(states.filter((event) => event.state === "running_tool").length, 1);
+});
+
+test("ignores whitespace-only chunks", () => {
+  const { observer, states } = makeObserver();
+  observer.push("   \r\n");
+  assert.equal(states.length, 0);
+});
+
+test("reverts to idle after a quiet period and resumes on new output", () => {
+  const { observer, states, fireIdle } = makeObserver();
+  observer.push("working...\n");
+  assert.equal(observer.getState(), "running_tool");
+
+  fireIdle();
+  assert.equal(states.at(-1).state, "idle");
+  assert.equal(observer.getState(), "idle");
+
+  observer.push("more output\n");
+  assert.equal(states.at(-1).state, "running_tool");
+});
+
+test("does not arm an idle timer when idleMs is 0", () => {
+  const timers = [];
+  const observer = createOutputObserver({
+    clientId: "generic",
+    idleMs: 0,
+    onState: () => {},
+    setTimer: (fn) => {
+      timers.push(fn);
+      return timers.length - 1;
+    }
+  });
+  observer.push("running\n");
+  assert.equal(timers.length, 0);
+});
+
+// --- Opt-in keyword heuristics ---
+
+test("with useHeuristics, recognizes specific states from lines", () => {
+  const { observer, states } = makeObserver({ useHeuristics: true });
+  observer.push("Do you want to approve this command?\n");
+  assert.equal(states.at(-1).state, "waiting_approval");
+});
+
+test("with useHeuristics, unmatched output still counts as working", () => {
+  const { observer, states } = makeObserver({ useHeuristics: true });
+  observer.push("some neutral progress text\n");
+  assert.equal(states.at(-1).state, "running_tool");
+});
+
+// --- User-typing echo suppression (working is AI activity, not the user) ---
+
+function makeClockedObserver(overrides = {}) {
+  const states = [];
+  let clock = 1000;
+  const observer = createOutputObserver({
+    clientId: "generic",
+    now: () => clock,
+    onState: (event) => states.push(event),
+    setTimer: () => 0,
+    clearTimer: () => {},
+    ...overrides
+  });
+  return { observer, states, tick: (ms) => { clock += ms; }, now: () => clock };
+}
+
+test("does NOT flip to working when output is an echo of recent keystrokes", () => {
+  const { observer, states } = makeClockedObserver({ inputGraceMs: 250 });
+  observer.noteInput();           // user pressed a key
+  observer.push("h");             // terminal echoes it back immediately
+  assert.equal(states.length, 0); // not AI activity -> no state change
+  assert.equal(observer.getState(), undefined);
+});
+
+test("treats output as working once the input-grace window has passed", () => {
+  const { observer, states, tick } = makeClockedObserver({ inputGraceMs: 250 });
+  observer.noteInput();
+  tick(400);                      // user has stopped typing; the AI now responds
+  observer.push("AI is generating a response...\n");
+  assert.equal(states.at(-1).state, "running_tool");
+});
+
+test("each keystroke re-arms the grace window so continuous typing never looks like work", () => {
+  const { observer, states, tick } = makeClockedObserver({ inputGraceMs: 250 });
+  for (let i = 0; i < 5; i++) {
+    observer.noteInput();
+    tick(100);          // typing faster than the grace window
+    observer.push("x"); // echo
+  }
+  assert.equal(states.filter((e) => e.state === "running_tool").length, 0);
+});
+
+test("output with no preceding input is still working (default behaviour unchanged)", () => {
+  const { observer, states } = makeClockedObserver({ inputGraceMs: 250 });
+  observer.push("autonomous AI output\n");
+  assert.equal(states.at(-1).state, "running_tool");
+});

package/packages/adapters/test/routing.test.mjs

@@ -0,0 +1,93 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import {
+  resolveReplyStrategy,
+  resolveApprovalStrategy,
+  routeReply,
+  routeApproval
+} from "../src/routing.js";
+
+const SUPPORTED = { canReply: "supported", canApprove: "supported" };
+const BEST_EFFORT = { canReply: "best_effort", canApprove: "best_effort" };
+const UNSUPPORTED = { canReply: "unsupported", canApprove: "unsupported" };
+
+const validRequest = { type: "task_input", sessionId: "s", inputId: "in_1", text: "go", createdAt: 1 };
+const validDecision = { type: "approval_decision", sessionId: "s", approvalId: "ap_1", decision: "approve", decidedAt: 1 };
+
+test("resolves injection strategy from capability level", () => {
+  assert.equal(resolveReplyStrategy(SUPPORTED), "structured");
+  assert.equal(resolveReplyStrategy(BEST_EFFORT), "pty");
+  assert.equal(resolveReplyStrategy(UNSUPPORTED), "focus_terminal");
+  assert.equal(resolveApprovalStrategy(BEST_EFFORT), "pty");
+});
+
+test("routes a reply through the structured injector when supported", async () => {
+  const calls = [];
+  const result = await routeReply({
+    request: validRequest,
+    capabilities: SUPPORTED,
+    now: () => 50,
+    injectors: { structured: async (req) => calls.push(req) }
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(result.acceptedAt, 50);
+  assert.equal(calls.length, 1);
+});
+
+test("never injects for unsupported adapters", async () => {
+  const calls = [];
+  const result = await routeReply({
+    request: validRequest,
+    capabilities: UNSUPPORTED,
+    injectors: { structured: async () => calls.push("x"), pty: async () => calls.push("y") }
+  });
+
+  assert.equal(result.ok, false);
+  assert.equal(result.error, "reply_unsupported");
+  assert.equal(calls.length, 0);
+});
+
+test("reports injector failure without throwing", async () => {
+  const result = await routeReply({
+    request: validRequest,
+    capabilities: BEST_EFFORT,
+    injectors: { pty: async () => { throw new Error("pty closed"); } }
+  });
+
+  assert.equal(result.ok, false);
+  assert.match(result.error, /pty closed/);
+});
+
+test("rejects an invalid reply request before routing", async () => {
+  const result = await routeReply({
+    request: { type: "task_input", sessionId: "s", inputId: "in_1", text: "   ", createdAt: 1 },
+    capabilities: SUPPORTED,
+    injectors: { structured: async () => { throw new Error("should not run"); } }
+  });
+
+  assert.equal(result.ok, false);
+  assert.match(result.error, /text/);
+});
+
+test("routes an approval decision and reports the result", async () => {
+  const calls = [];
+  const ok = await routeApproval({
+    decision: validDecision,
+    capabilities: SUPPORTED,
+    now: () => 70,
+    injectors: { structured: async (d) => calls.push(d) }
+  });
+  assert.equal(ok.ok, true);
+  assert.equal(ok.decidedAt, 70);
+  assert.equal(calls.length, 1);
+
+  const blocked = await routeApproval({
+    decision: validDecision,
+    capabilities: UNSUPPORTED,
+    injectors: { structured: async () => calls.push("nope") }
+  });
+  assert.equal(blocked.ok, false);
+  assert.equal(blocked.error, "approval_unsupported");
+  assert.equal(calls.length, 1);
+});

package/packages/app-state/src/state-file.js

@@ -0,0 +1,53 @@
+import { dirname } from "node:path";
+import {
+  createDefaultPositionState,
+  parsePositionState,
+  serializePositionState
+} from "./state.js";
+
+// Thin filesystem wrapper around the pure state helpers. The fs functions are
+// injectable so the load/save behaviour is testable without touching the disk.
+export function createStateFile({ statePath, readFile, writeFile, mkdir } = {}) {
+  if (typeof statePath !== "string" || statePath.trim() === "") {
+    throw new Error("statePath is required");
+  }
+
+  const read = readFile ?? defaultReadFile;
+  const write = writeFile ?? defaultWriteFile;
+  const ensureDir = mkdir ?? defaultMkdir;
+
+  return {
+    statePath,
+
+    async load() {
+      try {
+        const text = await read(statePath, "utf8");
+        return parsePositionState(text);
+      } catch {
+        // Missing or unreadable file falls back to defaults, same as corrupt JSON.
+        return createDefaultPositionState();
+      }
+    },
+
+    async save(state) {
+      await ensureDir(dirname(statePath), { recursive: true });
+      await write(statePath, serializePositionState(state));
+      return state;
+    }
+  };
+}
+
+async function defaultReadFile(path, encoding) {
+  const { readFile } = await import("node:fs/promises");
+  return readFile(path, encoding);
+}
+
+async function defaultWriteFile(path, content) {
+  const { writeFile } = await import("node:fs/promises");
+  return writeFile(path, content);
+}
+
+async function defaultMkdir(path, options) {
+  const { mkdir } = await import("node:fs/promises");
+  return mkdir(path, options);
+}