qlogicagent 2.11.2 → 2.11.3

package/dist/vendor/hatch-pet/scripts/render_animation_previews.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+"""Render lightweight animated QA previews from extracted Codex pet frames."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from PIL import Image
+
+ROW_DURATIONS = {
+    "idle": [280, 110, 110, 140, 140, 320],
+    "running-right": [120, 120, 120, 120, 120, 120, 120, 220],
+    "running-left": [120, 120, 120, 120, 120, 120, 120, 220],
+    "waving": [140, 140, 140, 280],
+    "jumping": [140, 140, 140, 140, 280],
+    "failed": [140, 140, 140, 140, 140, 140, 140, 240],
+    "waiting": [150, 150, 150, 150, 150, 260],
+    "running": [120, 120, 120, 120, 120, 220],
+    "review": [150, 150, 150, 150, 150, 280],
+}
+IMAGE_SUFFIXES = {".png", ".webp", ".jpg", ".jpeg"}
+
+
+def frame_files(state_dir: Path) -> list[Path]:
+    if not state_dir.is_dir():
+        return []
+    return sorted(path for path in state_dir.iterdir() if path.suffix.lower() in IMAGE_SUFFIXES)
+
+
+def load_frames(frames_root: Path, state: str, expected_count: int) -> list[Image.Image]:
+    files = frame_files(frames_root / state)
+    if len(files) != expected_count:
+        raise SystemExit(
+            f"{state} preview needs {expected_count} frames, found {len(files)} under {frames_root / state}"
+        )
+    frames = []
+    for path in files:
+        with Image.open(path) as opened:
+            frames.append(opened.convert("RGBA"))
+    return frames
+
+
+def save_preview(frames: list[Image.Image], durations: list[int], output: Path) -> None:
+    output.parent.mkdir(parents=True, exist_ok=True)
+    frames[0].save(
+        output,
+        save_all=True,
+        append_images=frames[1:],
+        duration=durations,
+        loop=0,
+        disposal=2,
+        optimize=False,
+    )
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--frames-root", required=True)
+    parser.add_argument("--output-dir", required=True)
+    args = parser.parse_args()
+
+    frames_root = Path(args.frames_root).expanduser().resolve()
+    output_dir = Path(args.output_dir).expanduser().resolve()
+    previews = []
+    for state, durations in ROW_DURATIONS.items():
+        frames = load_frames(frames_root, state, len(durations))
+        output = output_dir / f"{state}.gif"
+        save_preview(frames, durations, output)
+        previews.append({"state": state, "path": str(output), "frames": len(frames)})
+
+    result = {"ok": True, "output_dir": str(output_dir), "previews": previews}
+    print(json.dumps(result, indent=2))
+
+
+if __name__ == "__main__":
+    main()

package/dist/vendor/hatch-pet/scripts/validate_atlas.py

@@ -0,0 +1,157 @@
+#!/usr/bin/env python3
+"""Validate a Codex pet spritesheet atlas."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from collections import defaultdict
+from pathlib import Path
+
+from PIL import Image
+
+COLUMNS = 8
+ROWS = 9
+CELL_WIDTH = 192
+CELL_HEIGHT = 208
+ATLAS_WIDTH = COLUMNS * CELL_WIDTH
+ATLAS_HEIGHT = ROWS * CELL_HEIGHT
+ROW_BY_INDEX = {
+    0: ("idle", 6),
+    1: ("running-right", 8),
+    2: ("running-left", 8),
+    3: ("waving", 4),
+    4: ("jumping", 5),
+    5: ("failed", 8),
+    6: ("waiting", 6),
+    7: ("running", 6),
+    8: ("review", 6),
+}
+
+
+def alpha_nonzero_count(image: Image.Image) -> int:
+    alpha = image.getchannel("A")
+    return sum(alpha.histogram()[1:])
+
+
+def transparent_rgb_residue_count(image: Image.Image) -> int:
+    rgba = image.convert("RGBA")
+    data = rgba.tobytes()
+    count = 0
+    for index in range(0, len(data), 4):
+        red, green, blue, alpha = data[index : index + 4]
+        if alpha == 0 and (red or green or blue):
+            count += 1
+    return count
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("atlas")
+    parser.add_argument("--json-out")
+    parser.add_argument("--min-used-pixels", type=int, default=50)
+    parser.add_argument("--near-opaque-threshold", type=float, default=0.95)
+    parser.add_argument("--allow-opaque", action="store_true")
+    parser.add_argument("--allow-near-opaque-used-cells", action="store_true")
+    args = parser.parse_args()
+
+    atlas_path = Path(args.atlas).expanduser().resolve()
+    errors: list[str] = []
+    warnings: list[str] = []
+    near_opaque_used_cells: dict[str, list[int]] = defaultdict(list)
+    cells: list[dict[str, object]] = []
+
+    try:
+        with Image.open(atlas_path) as opened:
+            source_mode = opened.mode
+            source_format = opened.format
+            image = opened.convert("RGBA")
+    except Exception as exc:  # noqa: BLE001
+        result = {"ok": False, "errors": [f"could not open atlas: {exc}"], "warnings": []}
+        print(json.dumps(result, indent=2))
+        raise SystemExit(1)
+
+    if image.size != (ATLAS_WIDTH, ATLAS_HEIGHT):
+        errors.append(f"expected {ATLAS_WIDTH}x{ATLAS_HEIGHT}, got {image.width}x{image.height}")
+
+    if source_format not in {"PNG", "WEBP"}:
+        errors.append(f"expected PNG or WebP, got {source_format}")
+
+    if "A" not in source_mode and not args.allow_opaque:
+        errors.append("atlas does not have an alpha channel")
+
+    for row_index in range(ROWS):
+        state, frame_count = ROW_BY_INDEX[row_index]
+        for column_index in range(COLUMNS):
+            left = column_index * CELL_WIDTH
+            top = row_index * CELL_HEIGHT
+            cell = image.crop((left, top, left + CELL_WIDTH, top + CELL_HEIGHT))
+            nontransparent = alpha_nonzero_count(cell)
+            used = column_index < frame_count
+            cell_info = {
+                "state": state,
+                "row": row_index,
+                "column": column_index,
+                "used": used,
+                "nontransparent_pixels": nontransparent,
+            }
+            cells.append(cell_info)
+            if used and nontransparent < args.min_used_pixels:
+                errors.append(
+                    f"{state} row {row_index} column {column_index} is empty or too sparse ({nontransparent} pixels)"
+                )
+            if used and nontransparent > CELL_WIDTH * CELL_HEIGHT * args.near_opaque_threshold:
+                near_opaque_used_cells[f"{state} row {row_index}"].append(column_index)
+            if not used and nontransparent != 0:
+                errors.append(
+                    f"{state} row {row_index} unused column {column_index} is not transparent ({nontransparent} pixels)"
+                )
+
+    for row_label, columns in near_opaque_used_cells.items():
+        message = (
+            f"{row_label} has {len(columns)} nearly opaque used cells; "
+            "this usually means the sprite has a non-transparent background"
+        )
+        if args.allow_near_opaque_used_cells:
+            warnings.append(message)
+        else:
+            errors.append(message)
+
+    alpha_count = alpha_nonzero_count(image)
+    if alpha_count == ATLAS_WIDTH * ATLAS_HEIGHT:
+        message = "atlas is fully opaque; custom pets require a transparent sprite background"
+        if args.allow_opaque:
+            warnings.append(message)
+        else:
+            errors.append(message)
+
+    transparent_rgb_residue = transparent_rgb_residue_count(image)
+    if transparent_rgb_residue:
+        errors.append(
+            f"atlas has {transparent_rgb_residue} fully transparent pixels with non-zero RGB residue"
+        )
+
+    result = {
+        "ok": not errors,
+        "file": str(atlas_path),
+        "format": source_format,
+        "mode": source_mode,
+        "width": image.width,
+        "height": image.height,
+        "transparent_rgb_residue_pixels": transparent_rgb_residue,
+        "errors": errors,
+        "warnings": warnings,
+        "cells": cells,
+    }
+
+    if args.json_out:
+        Path(args.json_out).expanduser().resolve().write_text(
+            json.dumps(result, indent=2) + "\n", encoding="utf-8"
+        )
+
+    print(json.dumps({k: v for k, v in result.items() if k != "cells"}, indent=2))
+    raise SystemExit(0 if result["ok"] else 1)
+
+
+if __name__ == "__main__":
+    main()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qlogicagent",
-  "version": "2.11.2",
+  "version": "2.11.3",
   "description": "XiaozhiClaw Agent CLI — subprocess architecture (JSON-RPC over stdio)",
   "type": "module",
   "main": "dist/index.js",
@@ -68,11 +68,12 @@
     "build:tsc": "tsc --noCheck",
     "start": "node dist/cli.js",
     "test": "vitest run",
-    "check": "tsc --noEmit && pnpm test && pnpm run check:architecture-boundaries && pnpm run check:provider-core-boundary && pnpm run check:workspace-hygiene && pnpm run check:package-artifact",
+    "check": "tsc --noEmit && pnpm test && pnpm run check:architecture-boundaries && pnpm run check:provider-core-boundary && pnpm run check:pet-core-boundary && pnpm run check:workspace-hygiene && pnpm run check:package-artifact",
     "test:watch": "vitest",
     "lint": "oxlint .",
     "check:architecture-boundaries": "node scripts/check-architecture-boundaries.mjs",
     "check:provider-core-boundary": "node scripts/check-provider-core-boundary.mjs",
+    "check:pet-core-boundary": "node scripts/check-pet-core-boundary.mjs",
     "check:workspace-hygiene": "node scripts/check-workspace-hygiene.mjs",
     "check:workspace-hygiene:strict": "node scripts/check-workspace-hygiene.mjs --strict",
     "check:package-artifact": "npm run build && node scripts/check-package-artifact.mjs",
@@ -86,7 +87,8 @@
   },
   "dependencies": {
     "@napi-rs/canvas": "0.1.100",
-    "@xiaozhiclaw/provider-core": "0.1.2",
+    "@xiaozhiclaw/pet-core": "0.1.0",
+    "@xiaozhiclaw/provider-core": "0.1.4",
     "better-sqlite3": "^12.10.0",
     "dotenv": "^17.3.1",
     "nanoid": "^5.1.5",

package/dist/types/runtime/pet/pet-reaction-service.d.ts

@@ -1,33 +0,0 @@
-/**
- * PetReactionService — probabilistic reaction generation after turns.
- *
- * P0: Local template pools (no LLM).
- * P1+: LLM-generated personalized reactions via small model.
- */
-import type { PetSoul } from "./pet-types.js";
-export type ReactionPool = "greeting" | "completion" | "error" | "curiosity" | "bored" | "memory" | "tool_success";
-export type ReactionStyle = "normal" | "thinking" | "excited" | "sleepy";
-/**
- * Determine whether a reaction should fire, and if so, return it.
- * P0: uses local template pools.
- */
-export declare function maybeGenerateReaction(eventMethod: string): {
-    text: string;
-    style: ReactionStyle;
-} | null;
-export interface LLMReactionContext {
-    turnSummary: string;
-    soul: PetSoul;
-}
-/**
- * Generate a personalized reaction via small LLM call.
- * Returns null on failure or timeout (graceful degradation to template pool).
- * Max 50 tokens, under 2s.
- *
- * @param ctx Context for the reaction
- * @param llmGenerate External function to call LLM (injected to avoid coupling)
- */
-export declare function generateLLMReaction(ctx: LLMReactionContext, llmGenerate: (prompt: string, maxTokens: number) => Promise<string | null>): Promise<{
-    text: string;
-    style: ReactionStyle;
-} | null>;