@leejungkiin/awkit 1.7.0 → 1.7.4

package/skills/hatch-pet/scripts/package_custom_pet.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+"""Package a validated atlas as a local Codex pet."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import shutil
+from pathlib import Path
+
+from PIL import Image
+
+ATLAS_SIZE = (1536, 1872)
+
+
+def default_codex_home() -> Path:
+    return Path(os.environ.get("CODEX_HOME") or "~/.codex").expanduser().resolve()
+
+
+def slugify(value: str) -> str:
+    value = value.strip().lower()
+    value = re.sub(r"[^a-z0-9]+", "-", value)
+    value = re.sub(r"-{2,}", "-", value)
+    return value.strip("-")
+
+
+def validate_spritesheet(path: Path) -> str:
+    with Image.open(path) as image:
+        if image.size != ATLAS_SIZE:
+            raise SystemExit(
+                f"expected {ATLAS_SIZE[0]}x{ATLAS_SIZE[1]}, got {image.width}x{image.height}"
+            )
+        if image.format not in {"PNG", "WEBP"}:
+            raise SystemExit(f"expected PNG or WebP, got {image.format}")
+        return str(image.format)
+
+
+def write_webp_spritesheet(source: Path, target: Path, source_format: str) -> None:
+    if source_format == "WEBP":
+        shutil.copy2(source, target)
+        return
+    with Image.open(source) as image:
+        target.parent.mkdir(parents=True, exist_ok=True)
+        image.convert("RGBA").save(
+            target,
+            format="WEBP",
+            lossless=True,
+            quality=100,
+            method=6,
+        )
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--pet-name", default="")
+    parser.add_argument("--display-name", default="")
+    parser.add_argument("--description", required=True)
+    parser.add_argument("--spritesheet", required=True)
+    parser.add_argument("--codex-home", default=str(default_codex_home()))
+    parser.add_argument(
+        "--output-dir",
+        help="Exact pet package directory. Defaults to ${CODEX_HOME:-$HOME/.codex}/pets/<pet-name>.",
+    )
+    parser.add_argument("--force", action="store_true")
+    args = parser.parse_args()
+
+    raw_pet_name = (args.pet_name or args.display_name).strip()
+    if not raw_pet_name:
+        raise SystemExit("pet name is required")
+    pet_id = slugify(raw_pet_name)
+    if not pet_id:
+        raise SystemExit("pet name must contain at least one letter or digit")
+    display_name = (args.display_name or raw_pet_name).strip()
+
+    source = Path(args.spritesheet).expanduser().resolve()
+    source_format = validate_spritesheet(source)
+    target_dir = (
+        Path(args.output_dir).expanduser().resolve()
+        if args.output_dir
+        else Path(args.codex_home).expanduser().resolve() / "pets" / pet_id
+    )
+    target_dir.mkdir(parents=True, exist_ok=True)
+
+    target_sheet = target_dir / "spritesheet.webp"
+    manifest_path = target_dir / "pet.json"
+    if not args.force and (target_sheet.exists() or manifest_path.exists()):
+        raise SystemExit(f"{target_dir} already contains pet files; pass --force to overwrite")
+
+    write_webp_spritesheet(source, target_sheet, source_format)
+    manifest = {
+        "id": pet_id,
+        "displayName": display_name,
+        "description": args.description,
+        "spritesheetPath": target_sheet.name,
+    }
+    manifest_path.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
+
+    print(
+        json.dumps(
+            {"ok": True, "pet_dir": str(target_dir), "manifest": str(manifest_path)}, indent=2
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()

package/skills/hatch-pet/scripts/pet_job_status.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+"""Show ready and pending $imagegen jobs for a Codex pet run."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+
+def load_manifest(run_dir: Path) -> dict[str, object]:
+    path = run_dir / "imagegen-jobs.json"
+    if not path.exists():
+        raise SystemExit(f"job manifest not found: {path}")
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def jobs(manifest: dict[str, object]) -> list[dict[str, object]]:
+    raw = manifest.get("jobs")
+    if not isinstance(raw, list):
+        raise SystemExit("invalid imagegen-jobs.json: jobs must be a list")
+    return [job for job in raw if isinstance(job, dict)]
+
+
+def completed_ids(manifest: dict[str, object]) -> set[str]:
+    return {
+        str(job["id"])
+        for job in jobs(manifest)
+        if job.get("status") == "complete" and isinstance(job.get("id"), str)
+    }
+
+
+def missing_deps(job: dict[str, object], completed: set[str]) -> list[str]:
+    deps = job.get("depends_on", [])
+    if not isinstance(deps, list):
+        return []
+    return [dep for dep in deps if isinstance(dep, str) and dep not in completed]
+
+
+def job_view(
+    job: dict[str, object], run_dir: Path, completed: set[str]
+) -> dict[str, object]:
+    prompt_file = job.get("prompt_file")
+    output_path = job.get("output_path")
+    inputs = (
+        job.get("input_images") if isinstance(job.get("input_images"), list) else []
+    )
+    input_images = []
+    for item in inputs:
+        path = (
+            run_dir / item["path"]
+            if isinstance(item, dict) and isinstance(item.get("path"), str)
+            else None
+        )
+        input_images.append(
+            {
+                "path": str(path) if path else None,
+                "role": item.get("role") if isinstance(item, dict) else None,
+                "exists": path.is_file() if path else False,
+            }
+        )
+    return {
+        "id": job.get("id"),
+        "kind": job.get("kind"),
+        "status": job.get("status", "pending"),
+        "prompt_file": str(run_dir / prompt_file)
+        if isinstance(prompt_file, str)
+        else None,
+        "input_images": input_images,
+        "output_path": str(run_dir / output_path)
+        if isinstance(output_path, str)
+        else None,
+        "missing_dependencies": missing_deps(job, completed),
+        "repair_attempt": job.get("repair_attempt", 0),
+        "generation_skill": job.get("generation_skill"),
+        "requires_grounded_generation": job.get("requires_grounded_generation", False),
+        "allow_prompt_only_generation": job.get("allow_prompt_only_generation", False),
+        "identity_reference_paths": job.get("identity_reference_paths", []),
+        "mirror_policy": job.get("mirror_policy", {}),
+        "derived_from": job.get("derived_from"),
+        "source_provenance": job.get("source_provenance"),
+        "mirror_decision": job.get("mirror_decision"),
+        "recording_owner": job.get("recording_owner", "parent"),
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--run-dir", required=True)
+    args = parser.parse_args()
+
+    run_dir = Path(args.run_dir).expanduser().resolve()
+    manifest = load_manifest(run_dir)
+    completed = completed_ids(manifest)
+    pending = [
+        job for job in jobs(manifest) if job.get("status", "pending") != "complete"
+    ]
+    ready = [job for job in pending if not missing_deps(job, completed)]
+    blocked = [job for job in pending if missing_deps(job, completed)]
+
+    result = {
+        "ok": True,
+        "run_dir": str(run_dir),
+        "counts": {
+            "total": len(jobs(manifest)),
+            "complete": len(completed),
+            "ready": len(ready),
+            "blocked": len(blocked),
+        },
+        "ready_jobs": [job_view(job, run_dir, completed) for job in ready],
+        "blocked_jobs": [job_view(job, run_dir, completed) for job in blocked],
+    }
+    print(json.dumps(result, indent=2))
+
+
+if __name__ == "__main__":
+    main()