like-sci-figures 0.0.0-stage → 1.0.0

package/scripts/palette_pref.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+"""Task-scoped colour-palette preference store for like-sci-figures.
+
+Why this exists
+---------------
+This skill ships 10 curated palettes. The workflow requires the *user* to pick
+one the first time the skill is used in a task, and to keep using that same
+palette for the rest of the task. An LLM agent may lose conversation context
+(compaction, context switching, multi-turn gaps), so the choice is persisted
+to disk next to the working directory — one record per task / project.
+
+State file
+----------
+    <cwd>/.workbuddy/like-sci-figures/palette.json      (override: --state)
+
+    {
+      "palette": "wx06_amber_navy",   # slug, or the literal string "auto"
+      "chosen_at": "2026-10-16 18:20:00",
+      "cwd": "C:\\path\\to\\project"
+    }
+
+Values
+------
+    <slug>       a real palette, e.g. wx06_amber_navy / p6 / 6 / hex list
+    auto         the user explicitly declined to pick one -> do NOT pass
+                 --palette, let the journal style supply its own colours
+
+Exit codes (read them — do not just check stdout)
+-------------------------------------------------
+    get   0 = a choice is recorded (stdout = palette value)
+          2 = no choice yet for this task  -> the agent must ask the user
+    set   0 = saved, 1 = missing arg, 3 = unknown palette name
+    clear 0 = removed (or nothing to clear)
+"""
+import argparse
+import json
+import os
+import sys
+import time
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, SCRIPT_DIR)
+
+# Where the record lives, relative to the working directory.
+STATE_REL = os.path.join(".workbuddy", "like-sci-figures", "palette.json")
+# Sentinel meaning "user opted out of choosing; use the style's own colours".
+AUTO = "auto"
+# What the agent should append to every gen_figure.py call once a choice exists.
+FLAG = "--palette"
+
+
+def state_path(override=None):
+    """Absolute path of the state file for the current task."""
+    return os.path.abspath(override or os.path.join(os.getcwd(), STATE_REL))
+
+
+def _read(path):
+    try:
+        with open(path, "r", encoding="utf-8") as fh:
+            rec = json.load(fh)
+        if isinstance(rec, dict):
+            return rec
+    except Exception:
+        pass
+    return None
+
+
+def _resolve(name):
+    """Validate a palette name and return its canonical slug, or None."""
+    if str(name).strip().lower() == AUTO:
+        return AUTO
+    try:
+        from palettes import get_palette, palette_info
+    except Exception:
+        return str(name).strip()
+    info = palette_info(name)
+    if info:
+        return info["slug"]
+    # Not a known slug/alias — allow an explicit hex list through.
+    try:
+        get_palette(name)
+        return str(name).strip()
+    except Exception:
+        return None
+
+
+def cmd_get(args):
+    path = state_path(args.state)
+    rec = _read(path)
+    value = (rec or {}).get("palette")
+    if not value:
+        print("(no palette chosen yet for this task)", file=sys.stderr)
+        print("(ask the user to choose, then run: palette_pref.py set --palette <slug>)",
+              file=sys.stderr)
+        return 2
+    print(value)
+    return 0
+
+
+def cmd_set(args):
+    raw = (args.palette or "").strip()
+    if not raw:
+        print("ERROR: --palette is required (a slug like wx06_amber_navy, an alias "
+              "like p6, a hex list, or 'auto' to opt out)", file=sys.stderr)
+        return 1
+    slug = _resolve(raw)
+    if slug is None:
+        print(f"ERROR: unknown palette '{raw}'.", file=sys.stderr)
+        print("       Available: wx01_blue_red ... wx10_vivid_contrast "
+              "(aliases p1-p10 / 1-10 / wx1-wx10), or 'auto'.", file=sys.stderr)
+        return 3
+    path = state_path(args.state)
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    rec = {
+        "palette": slug,
+        "chosen_at": time.strftime("%Y-%m-%d %H:%M:%S"),
+        "cwd": os.getcwd(),
+    }
+    with open(path, "w", encoding="utf-8") as fh:
+        json.dump(rec, fh, ensure_ascii=False, indent=2)
+        fh.write("\n")
+    if slug == AUTO:
+        print("Palette preference saved: auto (user opted out -> omit --palette)")
+    else:
+        print(f"Palette preference saved: {slug}")
+    print(f"State file: {path}")
+    print(f"All later figure calls in this task must append: {FLAG} {slug}")
+    return 0
+
+
+def cmd_clear(args):
+    path = state_path(args.state)
+    if os.path.exists(path):
+        try:
+            os.remove(path)
+        except Exception as exc:
+            print(f"ERROR: could not remove {path}: {exc}", file=sys.stderr)
+            return 1
+        print(f"Removed {path}")
+        return 0
+    print("(nothing to clear)")
+    return 0
+
+
+def cmd_path(args):
+    print(state_path(args.state))
+    return 0
+
+
+def main():
+    ap = argparse.ArgumentParser(
+        prog="palette_pref.py",
+        description="Remember which colour palette the user chose for the current task.",
+    )
+    ap.add_argument("--state", default=None,
+                    help="Explicit state file path (default: "
+                         ".workbuddy/like-sci-figures/palette.json under cwd)")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+
+    p_get = sub.add_parser("get", help="print the recorded palette (exit 2 if none)")
+    p_get.set_defaults(func=cmd_get)
+
+    p_set = sub.add_parser("set", help="record the user's palette choice")
+    p_set.add_argument("--palette", "-p", required=True,
+                       help="slug / alias / hex list, or 'auto' to opt out")
+    p_set.set_defaults(func=cmd_set)
+
+    p_clear = sub.add_parser("clear", help="forget the recorded choice")
+    p_clear.set_defaults(func=cmd_clear)
+
+    p_path = sub.add_parser("path", help="print where the state file will be written")
+    p_path.set_defaults(func=cmd_path)
+
+    args = ap.parse_args()
+    return args.func(args) or 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/palette_preview.py

@@ -0,0 +1,334 @@
+#!/usr/bin/env python3
+"""Generate individual preview images for each palette.
+
+Why this exists
+---------------
+When the skill prompts the user to pick a palette, they need to *see* each
+palette in action — not just a colour-swatch list. The existing palette-picker
+poster crams all 34 palettes into one tall image, which is hard to scan.
+
+This script renders one standalone preview PNG per palette, each containing:
+  1. Green header with palette name + LIKE watermark
+  2. Kind badge + domain tags
+  3. Colour swatches strip (all colours side-by-side)
+  4. Five representative chart thumbnails (bar, line, scatter, pie, heatmap)
+
+The 34 individual previews make it easy to scroll through and pick the right
+one at a glance.
+
+Usage
+-----
+    palette_preview.py                         # generate all 34 previews
+    palette_preview.py --style nature          # different journal style
+    palette_preview.py --force                 # overwrite existing
+    palette_preview.py --palettes wx01,wx06    # only specific palettes
+    palette_preview.py --dry-run               # print plan, render nothing
+    palette_preview.py --manifest-only          # regenerate manifest only
+"""
+import argparse
+import json
+import os
+import sys
+import tempfile
+import time
+from concurrent.futures import ThreadPoolExecutor
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, SCRIPT_DIR)
+
+from registry import example_path, ZH_NAME
+from render_utils import render_chart, load_fonts
+from palettes import list_palettes, palette_info
+
+SKILL_DIR = os.path.dirname(SCRIPT_DIR)
+PREVIEW_DIR = os.path.join(SKILL_DIR, "previews")
+
+# Five representative chart types for the preview
+CHARTS = ["bar", "line", "scatter", "pie", "heatmap"]
+
+# ── geometry ───────────────────────────────────────────────────────────────
+W = 800              # canvas width (px)
+HEADER_H = 64
+INFO_H = 44
+SWATCH_H = 36
+PAD = 16
+GAP = 8
+CELL_W = (W - 2 * PAD - 2 * GAP) // 3   # 3 columns → 252 px
+CELL_H = 196
+LABEL_H = 22
+FOOTER_H = 22
+ROWS = 2
+TOTAL_H = (HEADER_H + INFO_H + SWATCH_H + GAP
+           + ROWS * (CELL_H + LABEL_H) + (ROWS - 1) * GAP
+           + PAD + FOOTER_H)
+
+KIND_ZH = {"qualitative": "定性", "sequential": "顺序", "diverging": "发散"}
+KIND_RGB = {"qualitative": (0, 102, 204),
+            "sequential": (46, 125, 50),
+            "diverging": (183, 28, 28)}
+
+
+def _render_chart_thumbs(palette_slug, style, tmpdir, charts=CHARTS):
+    """Render representative chart thumbnails for one palette."""
+    thumbs = {}
+    def _do(chart):
+        out = os.path.join(tmpdir, "%s_%s.png" % (palette_slug, chart))
+        data = example_path(chart)
+        if not data:
+            return chart, None
+        png, err, _ = render_chart(
+            chart, data, out, style=style, palette=palette_slug,
+            width=3.2, height=2.4, dpi=120,
+            extra_args=["--no-legend"])
+        return chart, png
+
+    with ThreadPoolExecutor(max_workers=len(charts)) as pool:
+        for chart, png in pool.map(_do, charts):
+            if png:
+                thumbs[chart] = png
+    return thumbs
+
+
+def _compose_preview(thumbs, palette_slug, style, tmpdir):
+    """Compose the final preview image for one palette."""
+    from PIL import Image, ImageDraw, ImageFont
+
+    info = palette_info(palette_slug)
+    if not info:
+        return None
+
+    colors = list(info.get("colors") or [])
+    zh = info.get("zh") or palette_slug
+    kind = info.get("kind") or ""
+    domain_list = info.get("domain") or []
+
+    width = W
+    height = TOTAL_H
+    canvas = Image.new("RGB", (width, height), "white")
+    d = ImageDraw.Draw(canvas)
+    fonts, font_used = load_fonts((22, 18, 14, 12, 10))
+    f22 = fonts.get(22) or ImageFont.load_default()
+    f18 = fonts.get(18) or ImageFont.load_default()
+    f14 = fonts.get(14) or ImageFont.load_default()
+    f12 = fonts.get(12) or ImageFont.load_default()
+
+    # ── header ───────────────────────────────────────────────────────────
+    d.rectangle([0, 0, width, HEADER_H], fill="#0B6E4F")
+    d.text((PAD + 2, 10), "LIKE Sci Figures — 配色预览",
+           fill="white", font=f22)
+    d.text((PAD + 2, 40), "%s  ·  风格: %s" % (zh, style),
+           fill="#D7E1EB", font=f14)
+
+    # LIKE watermark (right-aligned)
+    tag = "LIKE"
+    bbox = d.textbbox((0, 0), tag, font=f18)
+    tag_w = bbox[2] - bbox[0]
+    d.text((width - PAD - tag_w - 2, 14), tag,
+           fill="#D7E1EB", font=f18)
+
+    # ── info strip ───────────────────────────────────────────────────────
+    y = HEADER_H
+    d.rectangle([0, y, width, y + INFO_H], fill="#F5F7FA")
+
+    # kind badge
+    lx = PAD + 4
+    badge_w = 58
+    d.rounded_rectangle(
+        [lx, y + 10, lx + badge_w, y + 10 + 24],
+        radius=4, fill=KIND_RGB.get(kind, (90, 90, 90)))
+    d.text((lx + 8, y + 14), KIND_ZH.get(kind, kind),
+           fill="white", font=f14)
+
+    # colour count
+    d.text((lx + badge_w + 10, y + 14),
+           "%d 色" % len(colors), fill="#555555", font=f14)
+
+    # domain tags
+    if domain_list:
+        domain_text = "适用:" + "/".join(domain_list[:3])
+        d.text((lx + badge_w + 60, y + 14), domain_text[:40],
+               fill="#777777", font=f14)
+
+    # ── colour swatches ─────────────────────────────────────────────────
+    y += INFO_H
+    d.rectangle([0, y, width, y + SWATCH_H], fill="#FAFBFC")
+
+    swatch_x = PAD + 4
+    max_colors = 20
+    swatch_w = min(28, (width - 2 * PAD - 12) // max_colors)
+    swatch_h = 22
+    swatch_y = y + (SWATCH_H - swatch_h) // 2
+    shown = min(len(colors), max_colors)
+    for i, hexc in enumerate(colors[:shown]):
+        cx = swatch_x + i * swatch_w
+        d.rectangle([cx, swatch_y, cx + swatch_w, swatch_y + swatch_h],
+                    fill=hexc, outline="#CCCCCC", width=1)
+    if len(colors) > shown:
+        d.text((swatch_x + shown * swatch_w + 6, swatch_y + 4),
+               "+%d" % (len(colors) - shown), fill="#999999", font=f12)
+
+    # ── chart grid ───────────────────────────────────────────────────────
+    y += SWATCH_H + GAP
+    for idx, chart_type in enumerate(CHARTS):
+        col = idx % 3
+        row = idx // 3
+        x = PAD + col * (CELL_W + GAP)
+        cy = y + row * (CELL_H + LABEL_H + GAP)
+
+        # cell border
+        d.rectangle([x, cy, x + CELL_W, cy + CELL_H],
+                    fill="white", outline="#DDDDDD")
+
+        # paste thumbnail
+        png = thumbs.get(chart_type)
+        if png and os.path.exists(png):
+            im = Image.open(png).convert("RGB")
+            if im.width != CELL_W or im.height != CELL_H:
+                im = im.resize((CELL_W, CELL_H), Image.LANCZOS)
+            canvas.paste(im, (x, cy))
+        else:
+            d.text((x + 10, cy + CELL_H // 2 - 10), "渲染失败",
+                   fill="#999999", font=f14)
+
+        # label
+        label = "%s  (%s)" % (ZH_NAME.get(chart_type, chart_type),
+                              chart_type)
+        d.text((x + 4, cy + CELL_H + 4), label, fill="#111111", font=f14)
+
+    # ── footer ───────────────────────────────────────────────────────────
+    fy = height - FOOTER_H
+    bbox = d.textbbox((0, 0), tag, font=f12)
+    d.text((width - PAD - (bbox[2] - bbox[0]) - 2, fy + 4),
+           tag, fill="#999999", font=f12)
+
+    return canvas
+
+
+def generate(style="nature", workers=4, force=False, dry_run=False,
+             manifest_only=False, palette_filter=None):
+    """Generate preview PNGs for all (or selected) palettes."""
+    all_slugs = [s for s in list_palettes() if palette_info(s)]
+
+    if palette_filter:
+        all_slugs = [s for s in all_slugs if s in palette_filter]
+
+    if dry_run:
+        print("would render %d previews -> %s" % (len(all_slugs), PREVIEW_DIR))
+        for slug in all_slugs:
+            print("   %-30s -> previews/%s.png" % (slug, slug))
+        return 0
+
+    if manifest_only:
+        # Just regenerate manifest from existing files
+        os.makedirs(PREVIEW_DIR, exist_ok=True)
+        manifest = _write_manifest(all_slugs, style)
+        print("Manifest regenerated: %s" % manifest)
+        return 0
+
+    os.makedirs(PREVIEW_DIR, exist_ok=True)
+    results = {}
+    errors = []
+    t0 = time.time()
+
+    for slug in all_slugs:
+        out_path = os.path.join(PREVIEW_DIR, "%s.png" % slug)
+        if os.path.exists(out_path) and not force:
+            print("   %-30s (exists, skipped)" % slug)
+            results[slug] = out_path
+            continue
+
+        print("  Rendering: %s ..." % slug)
+        tmpdir = tempfile.mkdtemp(prefix="sf_prev_%s_" % slug)
+        try:
+            thumbs = _render_chart_thumbs(slug, style, tmpdir)
+            canvas = _compose_preview(thumbs, slug, style, tmpdir)
+            if canvas:
+                canvas.save(out_path, dpi=(160, 160))
+                results[slug] = out_path
+            else:
+                errors.append("%s: compose returned None" % slug)
+        except Exception as exc:
+            errors.append("%s: %s" % (slug, str(exc)))
+
+        # cleanup
+        import shutil
+        shutil.rmtree(tmpdir, ignore_errors=True)
+
+    elapsed = time.time() - t0
+
+    # Write manifest
+    manifest = _write_manifest(all_slugs, style)
+
+    print("\nPreviews: %d ok, %d failed (%.1fs) -> %s"
+          % (len(results), len(errors), elapsed, PREVIEW_DIR))
+    if errors:
+        for e in errors:
+            print("   FAIL %s" % e, file=sys.stderr)
+    print("Manifest: %s" % manifest)
+    return 0 if not errors else 1
+
+
+def _write_manifest(all_slugs, style):
+    """Write or update the preview manifest."""
+    from palettes import palette_info as _pi
+    manifest = {
+        "generated_at": time.strftime("%Y-%m-%d %H:%M:%S"),
+        "style": style,
+        "charts": CHARTS,
+        "previews": [],
+    }
+    for slug in all_slugs:
+        info = _pi(slug)
+        path = os.path.join(PREVIEW_DIR, "%s.png" % slug)
+        entry = {
+            "palette": slug,
+            "zh": info.get("zh", "") if info else "",
+            "kind": info.get("kind", "") if info else "",
+            "domain": info.get("domain", []) if info else [],
+            "file": "%s.png" % slug,
+            "status": "ok" if os.path.exists(path) else "missing",
+        }
+        if os.path.exists(path):
+            entry["bytes"] = os.path.getsize(path)
+        manifest["previews"].append(entry)
+
+    manifest_path = os.path.join(PREVIEW_DIR, "manifest.json")
+    with open(manifest_path, "w", encoding="utf-8") as fh:
+        json.dump(manifest, fh, ensure_ascii=False, indent=2)
+        fh.write("\n")
+    return manifest_path
+
+
+def main():
+    ap = argparse.ArgumentParser(
+        prog="palette_preview.py",
+        description="Generate individual preview PNGs for each palette, "
+                    "showing representative charts + colour swatches.")
+    ap.add_argument("--style", default="nature",
+                    help="Journal style for chart thumbnails (default: %(default)s)")
+    ap.add_argument("--workers", type=int, default=4,
+                    help="Parallel render workers (default: %(default)s)")
+    ap.add_argument("--force", action="store_true",
+                    help="Overwrite existing preview images")
+    ap.add_argument("--dry-run", action="store_true",
+                    help="Print plan without rendering")
+    ap.add_argument("--manifest-only", action="store_true",
+                    help="Only regenerate manifest, skip rendering")
+    ap.add_argument("--palettes", default=None,
+                    help="Comma-separated palette slugs to preview (default: all)")
+    args = ap.parse_args()
+
+    palette_filter = None
+    if args.palettes:
+        palette_filter = set(c.strip() for c in args.palettes.split(",") if c.strip())
+
+    return generate(
+        style=args.style, workers=args.workers,
+        force=args.force, dry_run=args.dry_run,
+        manifest_only=args.manifest_only,
+        palette_filter=palette_filter,
+    ) or 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())