@hayasaka7/haya-pet 0.1.0

package/native/win-window-helper/Program.cs

@@ -0,0 +1,312 @@
+// Haya Pet — Windows window helper.
+//
+// Implements the line-delimited JSON helper protocol documented in
+// ../README.md. Reads one JSON request per line on stdin and writes one JSON
+// response per line on stdout. Diagnostics (if any) go to stderr only.
+//
+// Supported ops:
+//   { "id": "...", "op": "capabilities" }
+//   { "id": "...", "op": "locate", "pid": <int>, "terminalPid": <int?> }
+
+using System.Runtime.InteropServices;
+using System.Runtime.Versioning;
+using System.Text;
+using System.Text.Json;
+
+[assembly: SupportedOSPlatform("windows")]
+
+var jsonOptions = new JsonSerializerOptions
+{
+    PropertyNamingPolicy = JsonNamingPolicy.CamelCase
+};
+
+// Per-monitor DPI awareness so GetWindowRect returns physical pixels the
+// runtime can convert via its display manager. Best-effort; ignore failure.
+try { Native.SetProcessDpiAwarenessContext(Native.DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2); }
+catch { /* older Windows: ignore */ }
+
+string? line;
+while ((line = Console.ReadLine()) != null)
+{
+    if (string.IsNullOrWhiteSpace(line))
+    {
+        continue;
+    }
+
+    object response;
+    try
+    {
+        response = Handle(line);
+    }
+    catch (Exception ex)
+    {
+        response = new { id = (string?)null, ok = false, error = "invalid_request", detail = ex.Message };
+    }
+
+    Console.WriteLine(JsonSerializer.Serialize(response, jsonOptions));
+    Console.Out.Flush();
+}
+
+object Handle(string requestLine)
+{
+    using var doc = JsonDocument.Parse(requestLine);
+    var root = doc.RootElement;
+
+    string? id = root.TryGetProperty("id", out var idEl) ? idEl.GetString() : null;
+    string op = root.TryGetProperty("op", out var opEl) ? opEl.GetString() ?? "" : "";
+
+    switch (op)
+    {
+        case "capabilities":
+            return new
+            {
+                id,
+                ok = true,
+                capabilities = new { locate = true, follow = false, permission = "granted" }
+            };
+
+        case "locate":
+            if (!root.TryGetProperty("pid", out var pidEl) || !pidEl.TryGetInt32(out int pid))
+            {
+                return new { id, ok = false, error = "invalid_request" };
+            }
+
+            int? terminalPid = root.TryGetProperty("terminalPid", out var tEl) && tEl.TryGetInt32(out int t) ? t : null;
+            var window = WindowLocator.Locate(pid, terminalPid);
+            return window is null
+                ? new { id, ok = false, error = "not_found" }
+                : new { id, ok = true, window };
+
+        default:
+            return new { id, ok = false, error = "invalid_request" };
+    }
+}
+
+/// <summary>Resolves the terminal window for an AI client process tree.</summary>
+static class WindowLocator
+{
+    // Process names that own a real terminal window, ranked first when matched.
+    private static readonly HashSet<string> KnownTerminals = new(StringComparer.OrdinalIgnoreCase)
+    {
+        "WindowsTerminal.exe", "powershell.exe", "pwsh.exe", "cmd.exe",
+        "Code.exe", "wezterm-gui.exe", "alacritty.exe", "conemu64.exe", "conemu.exe"
+    };
+
+    public static object? Locate(int pid, int? terminalPid)
+    {
+        var processNames = ProcessTree.SnapshotNames();
+        var parents = ProcessTree.SnapshotParents();
+
+        // Candidate pids: the client, an explicit terminal hint, and all ancestors.
+        var candidates = new HashSet<int>();
+        AddAncestors(pid, parents, candidates);
+        if (terminalPid is int hint)
+        {
+            AddAncestors(hint, parents, candidates);
+        }
+
+        (IntPtr hWnd, int pidOwner, Native.RECT rect, string title)? best = null;
+        int bestScore = int.MinValue;
+
+        Native.EnumWindows((hWnd, _) =>
+        {
+            if (!Native.IsWindowVisible(hWnd))
+            {
+                return true;
+            }
+
+            Native.GetWindowThreadProcessId(hWnd, out uint wpid);
+            if (!candidates.Contains((int)wpid))
+            {
+                return true;
+            }
+
+            if (!Native.GetWindowRect(hWnd, out var rect))
+            {
+                return true;
+            }
+
+            int width = rect.Right - rect.Left;
+            int height = rect.Bottom - rect.Top;
+            if (width <= 0 || height <= 0)
+            {
+                return true;
+            }
+
+            string title = GetTitle(hWnd);
+            if (title.Length == 0)
+            {
+                return true;
+            }
+
+            int score = Score((int)wpid, width, height, processNames);
+            if (score > bestScore)
+            {
+                bestScore = score;
+                best = (hWnd, (int)wpid, rect, title);
+            }
+
+            return true;
+        }, IntPtr.Zero);
+
+        if (best is null)
+        {
+            return null;
+        }
+
+        var b = best.Value;
+        bool knownTerminal = processNames.TryGetValue(b.pidOwner, out var name) && KnownTerminals.Contains(name);
+
+        return new
+        {
+            x = b.rect.Left,
+            y = b.rect.Top,
+            width = b.rect.Right - b.rect.Left,
+            height = b.rect.Bottom - b.rect.Top,
+            displayId = "primary",
+            title = b.title,
+            confidence = knownTerminal ? 0.8 : 0.5
+        };
+    }
+
+    private static int Score(int pid, int width, int height, IReadOnlyDictionary<int, string> names)
+    {
+        // Prefer known terminal processes, then larger windows.
+        int terminalBonus = names.TryGetValue(pid, out var name) && KnownTerminals.Contains(name) ? 1_000_000_000 : 0;
+        return terminalBonus + Math.Min(width * height, 900_000_000);
+    }
+
+    private static void AddAncestors(int pid, IReadOnlyDictionary<int, int> parents, HashSet<int> into)
+    {
+        int current = pid;
+        int guard = 0;
+        while (current > 0 && into.Add(current) && guard++ < 64)
+        {
+            if (!parents.TryGetValue(current, out int parent) || parent == current)
+            {
+                break;
+            }
+            current = parent;
+        }
+    }
+
+    private static string GetTitle(IntPtr hWnd)
+    {
+        int length = Native.GetWindowTextLengthW(hWnd);
+        if (length <= 0)
+        {
+            return "";
+        }
+
+        var sb = new StringBuilder(length + 1);
+        Native.GetWindowTextW(hWnd, sb, sb.Capacity);
+        return sb.ToString();
+    }
+}
+
+/// <summary>Reads the live process table once per request via Toolhelp.</summary>
+static class ProcessTree
+{
+    public static Dictionary<int, int> SnapshotParents() => Snapshot().parents;
+
+    public static Dictionary<int, string> SnapshotNames() => Snapshot().names;
+
+    private static (Dictionary<int, int> parents, Dictionary<int, string> names) Snapshot()
+    {
+        var parents = new Dictionary<int, int>();
+        var names = new Dictionary<int, string>();
+
+        IntPtr snapshot = Native.CreateToolhelp32Snapshot(Native.TH32CS_SNAPPROCESS, 0);
+        if (snapshot == Native.INVALID_HANDLE_VALUE)
+        {
+            return (parents, names);
+        }
+
+        try
+        {
+            var entry = new Native.PROCESSENTRY32W { dwSize = (uint)Marshal.SizeOf<Native.PROCESSENTRY32W>() };
+            if (Native.Process32FirstW(snapshot, ref entry))
+            {
+                do
+                {
+                    parents[(int)entry.th32ProcessID] = (int)entry.th32ParentProcessID;
+                    names[(int)entry.th32ProcessID] = entry.szExeFile ?? "";
+                }
+                while (Native.Process32NextW(snapshot, ref entry));
+            }
+        }
+        finally
+        {
+            Native.CloseHandle(snapshot);
+        }
+
+        return (parents, names);
+    }
+}
+
+static class Native
+{
+    public const uint TH32CS_SNAPPROCESS = 0x00000002;
+    public static readonly IntPtr INVALID_HANDLE_VALUE = new(-1);
+    public static readonly IntPtr DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2 = new(-4);
+
+    public delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam);
+
+    [StructLayout(LayoutKind.Sequential)]
+    public struct RECT
+    {
+        public int Left;
+        public int Top;
+        public int Right;
+        public int Bottom;
+    }
+
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+    public struct PROCESSENTRY32W
+    {
+        public uint dwSize;
+        public uint cntUsage;
+        public uint th32ProcessID;
+        public IntPtr th32DefaultHeapID;
+        public uint th32ModuleID;
+        public uint cntThreads;
+        public uint th32ParentProcessID;
+        public int pcPriClassBase;
+        public uint dwFlags;
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
+        public string szExeFile;
+    }
+
+    [DllImport("user32.dll")]
+    public static extern bool EnumWindows(EnumWindowsProc lpEnumFunc, IntPtr lParam);
+
+    [DllImport("user32.dll")]
+    public static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint lpdwProcessId);
+
+    [DllImport("user32.dll")]
+    public static extern bool IsWindowVisible(IntPtr hWnd);
+
+    [DllImport("user32.dll")]
+    public static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect);
+
+    [DllImport("user32.dll", CharSet = CharSet.Unicode)]
+    public static extern int GetWindowTextW(IntPtr hWnd, StringBuilder lpString, int nMaxCount);
+
+    [DllImport("user32.dll", CharSet = CharSet.Unicode)]
+    public static extern int GetWindowTextLengthW(IntPtr hWnd);
+
+    [DllImport("user32.dll")]
+    public static extern bool SetProcessDpiAwarenessContext(IntPtr value);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    public static extern IntPtr CreateToolhelp32Snapshot(uint dwFlags, uint th32ProcessID);
+
+    [DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
+    public static extern bool Process32FirstW(IntPtr hSnapshot, ref PROCESSENTRY32W lppe);
+
+    [DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
+    public static extern bool Process32NextW(IntPtr hSnapshot, ref PROCESSENTRY32W lppe);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    public static extern bool CloseHandle(IntPtr hObject);
+}

package/native/win-window-helper/README.md

@@ -0,0 +1,53 @@
+# Windows Window Helper
+
+Strategy id: `win32-window-helper` (best-effort).
+
+Implements the shared helper protocol in [`../README.md`](../README.md).
+
+## Responsibility
+
+- Walk from the AI client PID up the parent process tree to the hosting terminal
+  process (`WindowsTerminal.exe`, `powershell.exe`, `pwsh.exe`, `cmd.exe`, `Code.exe`).
+- Enumerate top-level windows with `EnumWindows`, match the owning PID with
+  `GetWindowThreadProcessId`, and read bounds with `GetWindowRect`.
+- Return window bounds for bubble attachment.
+
+## Implementation notes
+
+- Suggested language: C# (.NET) or C++ with the Win32 API.
+- Use per-monitor DPI awareness (`SetProcessDpiAwarenessContext`) so reported
+  bounds are physical pixels the runtime can convert.
+- Windows Terminal tab/pane precision is not reliable; return the window rect and
+  let the runtime attach to a corner. Report `confidence` accordingly.
+- VS Code integrated terminal pane precision requires a VS Code extension; the
+  helper should return the editor window rect with lower `confidence`.
+
+## Protocol mapping
+
+- `op: "capabilities"` → `{ "locate": true, "follow": false, "permission": "granted" }`.
+- `op: "locate"` → `window` rect on success, or `{ "ok": false, "error": "not_found" }`.
+
+## Status: implemented
+
+This helper is implemented in C# (.NET, `Program.cs`) and builds with the .NET
+SDK. It walks the process tree with Toolhelp (`CreateToolhelp32Snapshot`),
+enumerates top-level windows (`EnumWindows` + `GetWindowThreadProcessId` +
+`GetWindowRect`), prefers known terminal processes, and is per-monitor DPI aware.
+
+### Build
+
+```bash
+cd native/win-window-helper
+dotnet build -c Release
+# -> bin/Release/net10.0-windows/haya-pet-win-window-helper.exe
+```
+
+### Try it
+
+```bash
+echo {"id":"a","op":"capabilities"} | bin/Release/net10.0-windows/haya-pet-win-window-helper.exe
+```
+
+The `apps/companion/src/main/terminal-helper-client.js` client spawns this exe
+and speaks the protocol; the companion converts the returned window bounds to the
+pet's display/DPI space via `display-manager.js`.

package/native/win-window-helper/win-window-helper.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net10.0-windows</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <AssemblyName>haya-pet-win-window-helper</AssemblyName>
+    <InvariantGlobalization>true</InvariantGlobalization>
+  </PropertyGroup>
+
+</Project>

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@hayasaka7/haya-pet",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Generic AI CLI pet runtime foundation.",
+  "license": "MIT",
+  "author": "Ai Hayasaka",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/HAYASAKA7/HAYA-PET.git"
+  },
+  "homepage": "https://github.com/HAYASAKA7/HAYA-PET#readme",
+  "bugs": {
+    "url": "https://github.com/HAYASAKA7/HAYA-PET/issues"
+  },
+  "bin": {
+    "haya-pet": "apps/cli/src/haya-pet.js"
+  },
+  "scripts": {
+    "test": "node test/run-tests.mjs"
+  },
+  "workspaces": [
+    "apps/*",
+    "packages/*"
+  ],
+  "dependencies": {
+    "electron": "42.3.3"
+  },
+  "optionalDependencies": {
+    "node-pty": "^1.1.0"
+  },
+  "engines": {
+    "node": ">=16.20.0"
+  }
+}

package/packages/adapters/src/adapter-info.js

@@ -0,0 +1,61 @@
+const ADAPTERS = Object.freeze({
+  codex: Object.freeze({
+    id: "codex",
+    displayName: "Codex",
+    detection: "manual",
+    supportLevel: 2,
+    defaultCommand: "codex",
+    knownProcessNames: Object.freeze(["codex"]),
+    stateHeuristics: Object.freeze(["pty_output"])
+  }),
+  "claude-code": Object.freeze({
+    id: "claude-code",
+    displayName: "Claude Code",
+    detection: "manual",
+    supportLevel: 2,
+    defaultCommand: "claude",
+    knownProcessNames: Object.freeze(["claude"]),
+    stateHeuristics: Object.freeze(["pty_output", "official_plugin"])
+  }),
+  antigravity: Object.freeze({
+    id: "antigravity",
+    displayName: "Antigravity",
+    detection: "manual",
+    supportLevel: 1,
+    defaultCommand: "antigravity",
+    knownProcessNames: Object.freeze(["antigravity"]),
+    stateHeuristics: Object.freeze(["wrapper"])
+  }),
+  generic: Object.freeze({
+    id: "generic",
+    displayName: "Generic",
+    detection: "manual",
+    supportLevel: 1,
+    defaultCommand: undefined,
+    knownProcessNames: Object.freeze([]),
+    stateHeuristics: Object.freeze(["wrapper"])
+  })
+});
+
+export const KNOWN_CLIENT_IDS = Object.freeze(["codex", "claude-code", "antigravity", "generic"]);
+
+export function listAdapters() {
+  return KNOWN_CLIENT_IDS.map((id) => ADAPTERS[id]);
+}
+
+export function getAdapterInfo(clientId) {
+  return ADAPTERS[clientId];
+}
+
+export function resolveAdapterInfo(clientId) {
+  const known = ADAPTERS[clientId];
+  if (known) {
+    return known;
+  }
+
+  return {
+    ...ADAPTERS.generic,
+    id: clientId,
+    displayName: clientId
+  };
+}

package/packages/adapters/src/capabilities.js

@@ -0,0 +1,39 @@
+// Adapter capability declarations (product plan section 23). The talk window
+// must hide or disable any control an adapter cannot safely support.
+
+const WRAPPER_ONLY = Object.freeze({
+  canReply: "unsupported",
+  canApprove: "unsupported",
+  canPause: false,
+  canResume: false,
+  canStop: true,
+  canFocusTerminal: true,
+  canOpenTranscript: false,
+  canShowDiffs: false,
+  canShowFiles: false,
+  canShowTests: false
+});
+
+const PTY_OBSERVER = Object.freeze({
+  canReply: "best_effort",
+  canApprove: "best_effort",
+  canPause: false,
+  canResume: false,
+  canStop: true,
+  canFocusTerminal: true,
+  canOpenTranscript: false,
+  canShowDiffs: false,
+  canShowFiles: false,
+  canShowTests: false
+});
+
+const ADAPTER_CAPABILITIES = Object.freeze({
+  generic: WRAPPER_ONLY,
+  antigravity: WRAPPER_ONLY,
+  codex: PTY_OBSERVER,
+  "claude-code": PTY_OBSERVER
+});
+
+export function getAdapterCapabilities(clientId) {
+  return ADAPTER_CAPABILITIES[clientId] ?? WRAPPER_ONLY;
+}

package/packages/adapters/src/heuristics.js

@@ -0,0 +1,114 @@
+import { isAiClientState } from "../../protocol/src/messages.js";
+
+// Generic regex rules from the product plan (section 35). Patterns are matched
+// case-insensitively against a single line of client output.
+export const DEFAULT_GENERIC_RULES = Object.freeze({
+  waiting_approval: ["approve", "permission", "continue\\?", "allow"],
+  waiting_user: ["\\? for", "press enter", "type your", "your input"],
+  running_tool: ["running", "executing", "\\$ "],
+  failed: ["error", "failed", "exception", "traceback"],
+  reviewing: ["review", "diff", "summary"]
+});
+
+const CLIENT_RULES = Object.freeze({
+  codex: Object.freeze({
+    ...DEFAULT_GENERIC_RULES,
+    editing_files: ["applying patch", "editing", "writing file", "apply_patch"],
+    waiting_approval: ["approve", "permission", "allow command", "run command\\?"]
+  }),
+  "claude-code": Object.freeze({
+    ...DEFAULT_GENERIC_RULES,
+    editing_files: ["edit ", "writing to", "applying edit"],
+    running_tool: ["running", "executing", "bash", "\\$ "],
+    waiting_approval: ["permission", "do you want to proceed", "allow"],
+    waiting_user: ["press enter", "your input", "human:"]
+  }),
+  antigravity: Object.freeze({
+    ...DEFAULT_GENERIC_RULES,
+    thinking: ["generating", "thinking"]
+  })
+});
+
+// Most-urgent-first precedence so a line matching several categories resolves
+// to the state the user most needs to see (mirrors the session priority model).
+const MATCH_PRECEDENCE = Object.freeze([
+  "waiting_approval",
+  "waiting_user",
+  "failed",
+  "editing_files",
+  "running_tool",
+  "reviewing",
+  "compacting",
+  "thinking",
+  "success",
+  "idle"
+]);
+
+export function getClientRules(clientId) {
+  return CLIENT_RULES[clientId] ?? DEFAULT_GENERIC_RULES;
+}
+
+export function matchAiState(text, rules = DEFAULT_GENERIC_RULES) {
+  if (typeof text !== "string" || text === "") {
+    return undefined;
+  }
+
+  const compiled = compileRules(rules);
+
+  for (const state of MATCH_PRECEDENCE) {
+    const regexes = compiled[state];
+    if (!regexes) {
+      continue;
+    }
+
+    if (regexes.some((regex) => regex.test(text))) {
+      return state;
+    }
+  }
+
+  return undefined;
+}
+
+export function compileRules(rules) {
+  const compiled = {};
+
+  if (!isPlainObject(rules)) {
+    return compiled;
+  }
+
+  for (const [state, patterns] of Object.entries(rules)) {
+    if (!isAiClientState(state) || !Array.isArray(patterns)) {
+      continue;
+    }
+
+    const regexes = [];
+    for (const pattern of patterns) {
+      const regex = safeCompile(pattern);
+      if (regex) {
+        regexes.push(regex);
+      }
+    }
+
+    if (regexes.length > 0) {
+      compiled[state] = regexes;
+    }
+  }
+
+  return compiled;
+}
+
+function safeCompile(pattern) {
+  if (typeof pattern !== "string") {
+    return undefined;
+  }
+
+  try {
+    return new RegExp(pattern, "i");
+  } catch {
+    return undefined;
+  }
+}
+
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}