luckiest-co 1.0.0 → 1.0.3

package/skills/luckiest-trends/scripts/test-v1-vs-v2.sh

@@ -0,0 +1,220 @@
+#!/bin/bash
+set -euo pipefail
+
+# === V1 vs V2 Skill Test Harness ===
+# Runs all 17 test queries through both v1 and v2 SKILL.md
+# using `claude --print` to capture real end-to-end output.
+
+SKILL_DIR="$HOME/.claude/skills/last30days"
+REPO_DIR="${REPO_DIR:-$(cd "$(dirname "$0")/.." && pwd)}"
+CLAUDE="${CLAUDE:-$(command -v claude || echo claude)}"
+
+# Safety: always restore V2 SKILL.md on exit/crash
+cleanup() {
+  if [ -f "$SKILL_DIR/SKILL.md.v2.bak" ]; then
+    echo ""
+    echo "⚠️  Restoring V2 SKILL.md from backup (script interrupted)..."
+    cp "$SKILL_DIR/SKILL.md.v2.bak" "$SKILL_DIR/SKILL.md"
+    rm -f "$SKILL_DIR/SKILL.md.v2.bak"
+    echo "  ✅ V2 restored"
+  fi
+}
+trap cleanup EXIT
+TIMESTAMP=$(date +%Y%m%d-%H%M%S)
+OUT_DIR="$REPO_DIR/docs/test-results/v1-vs-v2-${TIMESTAMP}"
+V1_DIR="$OUT_DIR/v1"
+V2_DIR="$OUT_DIR/v2"
+
+mkdir -p "$V1_DIR" "$V2_DIR"
+
+echo "📁 Output directory: $OUT_DIR"
+echo ""
+
+# All 17 test queries
+QUERIES=(
+  "prompting techniques for chatgpt for legal questions"
+  "best clawdbot use cases"
+  "how to best setup clawdbot"
+  "prompting tips for nano banana pro for ios designs"
+  "top claude code skills"
+  "using ChatGPT to make images of dogs"
+  "research best practices for beautiful remotion animation videos in claude code"
+  "photorealistic people in nano banana pro"
+  "What are the best rap songs lately"
+  "what are people saying about DeepSeek R1"
+  "best practices for cursor rules files for Cursor"
+  "prompt advice for using suno to make killer songs in simple mode"
+  "how do I use Codex with Claude Code on same app to make it better"
+  "kanye west"
+  "howie.ai"
+  "open claw"
+  "nano banana pro prompting"
+)
+
+TYPES=(
+  "PROMPTING+TOOL"
+  "RECOMMENDATIONS"
+  "HOW-TO"
+  "PROMPTING+TOOL"
+  "RECOMMENDATIONS"
+  "GENERAL"
+  "PROMPTING"
+  "PROMPTING"
+  "RECOMMENDATIONS"
+  "NEWS"
+  "PROMPTING"
+  "PROMPTING"
+  "HOW-TO"
+  "NEWS"
+  "GENERAL"
+  "GENERAL"
+  "PROMPTING"
+)
+
+slugify() {
+  echo "$1" | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9]/-/g' | sed 's/--*/-/g' | cut -c1-50
+}
+
+run_version() {
+  local version="$1"
+  local outdir="$2"
+  local total=${#QUERIES[@]}
+
+  echo ""
+  echo "=========================================="
+  echo "  Running $version — $total queries"
+  echo "=========================================="
+  echo ""
+
+  for i in "${!QUERIES[@]}"; do
+    local query="${QUERIES[$i]}"
+    local type="${TYPES[$i]}"
+    local slug
+    slug=$(slugify "$query")
+    local num=$((i + 1))
+    local outfile="$outdir/${num}-${slug}.txt"
+    local errfile="$outdir/${num}-${slug}.stderr.txt"
+
+    echo "[$version] ($num/$total) $query [$type]"
+
+    local start_time
+    start_time=$(date +%s)
+
+    # Run claude --print with the skill invocation
+    # No timeout — claude --print exits on its own; kill manually if stuck
+    if "$CLAUDE" --print \
+      "/last30days $query" \
+      > "$outfile" 2>"$errfile"; then
+      local end_time
+      end_time=$(date +%s)
+      local duration=$((end_time - start_time))
+      local lines
+      lines=$(wc -l < "$outfile")
+      echo "  ✅ Done — ${lines} lines, ${duration}s"
+    else
+      local exit_code=$?
+      echo "  ❌ Failed (exit $exit_code)" | tee -a "$outfile"
+    fi
+
+    # Brief pause between queries to avoid rate limits
+    sleep 3
+  done
+}
+
+# === Phase 1: Test V1 ===
+echo "📦 Backing up current V2 SKILL.md..."
+cp "$SKILL_DIR/SKILL.md" "$SKILL_DIR/SKILL.md.v2.bak"
+
+echo "📥 Installing V1 SKILL.md from upstream..."
+cd "$REPO_DIR"
+git show upstream/main:SKILL.md | sed '/^context: fork$/d; /^agent: Explore$/d; /^disable-model-invocation: true$/d' > "$SKILL_DIR/SKILL.md"
+cp "$SKILL_DIR/SKILL.md" "$OUT_DIR/v1-SKILL.md"
+echo "  ✅ V1 installed (stripped: context:fork, agent:Explore, disable-model-invocation)"
+
+run_version "V1" "$V1_DIR"
+
+# === Phase 2: Test V2 ===
+echo ""
+echo "📥 Restoring V2 SKILL.md..."
+cp "$SKILL_DIR/SKILL.md.v2.bak" "$SKILL_DIR/SKILL.md"
+cp "$SKILL_DIR/SKILL.md" "$OUT_DIR/v2-SKILL.md"
+echo "  ✅ V2 restored"
+
+run_version "V2" "$V2_DIR"
+
+# === Phase 3: Generate summary ===
+echo ""
+echo "=========================================="
+echo "  Generating comparison summary"
+echo "=========================================="
+
+SUMMARY="$OUT_DIR/comparison-summary.md"
+
+cat > "$SUMMARY" << EOF
+# V1 vs V2 Comparison Results
+
+Generated: $(date)
+Output directory: $OUT_DIR
+
+## Output Files
+
+| # | Query | Type | V1 Lines | V2 Lines | V1 Time | V2 Time |
+|---|-------|------|----------|----------|---------|---------|
+EOF
+
+for i in "${!QUERIES[@]}"; do
+  query="${QUERIES[$i]}"
+  type="${TYPES[$i]}"
+  slug=$(slugify "$query")
+  num=$((i + 1))
+
+  v1file="$V1_DIR/${num}-${slug}.txt"
+  v2file="$V2_DIR/${num}-${slug}.txt"
+
+  v1lines=$(wc -l < "$v1file" 2>/dev/null || echo "ERR")
+  v2lines=$(wc -l < "$v2file" 2>/dev/null || echo "ERR")
+
+  echo "| $num | \`$query\` | $type | $v1lines | $v2lines | — | — |" >> "$SUMMARY"
+done
+
+cat >> "$SUMMARY" << 'EOF'
+
+## Quick Check: Key Features
+
+For each query, check these v2 improvements:
+
+- [ ] Query parsing display (`🔍 **{TOPIC}** · {QUERY_TYPE}`)
+- [ ] Sparse citations (not every sentence)
+- [ ] Bold topic headers in summary
+- [ ] Emoji stats tree (`├─ 🟠 Reddit:`)
+- [ ] Quality checklist applied to prompts
+- [ ] Self-check (research grounding, not generic)
+
+## Scoring Guide
+
+Use the full scoring rubric from:
+`docs/plans/2026-02-06-test-v1-vs-v2-comparison-plan.md`
+
+## Next Step
+
+Have Claude read all 34 output files and generate scored comparison:
+```
+Read all files in docs/test-results/v1-vs-v2-*/v1/ and v2/
+Score each on the 7 dimensions from the test plan
+Write the final analysis to docs/test-results/v1-vs-v2-*/analysis.md
+```
+EOF
+
+# Cleanup backup
+rm -f "$SKILL_DIR/SKILL.md.v2.bak"
+
+echo ""
+echo "✅ All done!"
+echo ""
+echo "📁 Results:  $OUT_DIR"
+echo "📊 Summary:  $SUMMARY"
+echo "📄 V1 files: $V1_DIR/"
+echo "📄 V2 files: $V2_DIR/"
+echo ""
+echo "To review:"
+echo "  open $OUT_DIR"

package/skills/luckiest-trends/scripts/test_device_auth.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+"""Test ScrapeCreators GitHub device auth flow from the CLI.
+
+Usage:
+    python3 scripts/test_device_auth.py
+
+Flow:
+    1. Starts device code request
+    2. Shows user code + opens GitHub auth URL in browser
+    3. Polls for token until you complete auth
+    4. Fetches your profile and prints your API key
+"""
+
+import json
+import sys
+import time
+import webbrowser
+from urllib.request import Request, urlopen
+from urllib.error import HTTPError, URLError
+
+BASE = "https://api.scrapecreators.com/v1/github/device"
+
+
+def _post(url, data=None):
+    body = json.dumps(data).encode() if data else None
+    req = Request(url, data=body, method="POST")
+    req.add_header("Content-Type", "application/json")
+    with urlopen(req, timeout=15) as resp:
+        return json.loads(resp.read())
+
+
+def _get(url, token):
+    req = Request(url)
+    req.add_header("Authorization", f"Bearer {token}")
+    with urlopen(req, timeout=15) as resp:
+        return json.loads(resp.read())
+
+
+def main():
+    # Step 1: Start device flow
+    print("Starting ScrapeCreators GitHub device auth...\n")
+    try:
+        code_resp = _post(f"{BASE}/code")
+    except (HTTPError, URLError) as e:
+        print(f"Failed to start device flow: {e}")
+        sys.exit(1)
+
+    device_code = code_resp.get("device_code")
+    user_code = code_resp.get("user_code")
+    verification_uri = code_resp.get("verification_uri")
+    interval = code_resp.get("interval", 5)
+    expires_in = code_resp.get("expires_in", 900)
+
+    if not device_code or not user_code:
+        print(f"Unexpected response: {json.dumps(code_resp, indent=2)}")
+        sys.exit(1)
+
+    print(f"Your code:  {user_code}")
+    print(f"Open:       {verification_uri}")
+    print(f"Expires in: {expires_in}s\n")
+
+    # Open browser
+    if verification_uri:
+        webbrowser.open(verification_uri)
+        print("Opened browser. Enter the code above, then authorize.\n")
+
+    # Step 2: Poll for token
+    print("Waiting for authorization", end="", flush=True)
+    deadline = time.time() + expires_in
+    access_token = None
+
+    while time.time() < deadline:
+        time.sleep(interval)
+        print(".", end="", flush=True)
+        try:
+            token_resp = _post(f"{BASE}/token", {"device_code": device_code})
+        except HTTPError as e:
+            # Some APIs return 4xx while pending
+            if e.code in (400, 403, 428):
+                continue
+            print(f"\nPoll error: {e}")
+            sys.exit(1)
+        except URLError:
+            continue
+
+        if token_resp.get("access_token"):
+            access_token = token_resp["access_token"]
+            break
+
+        # Check for explicit error states
+        error = token_resp.get("error")
+        if error == "authorization_pending" or error == "slow_down":
+            if error == "slow_down":
+                interval = min(interval + 2, 30)
+            continue
+        if error in ("expired_token", "access_denied"):
+            print(f"\n\nAuth failed: {error}")
+            sys.exit(1)
+
+    if not access_token:
+        print("\n\nTimed out waiting for authorization.")
+        sys.exit(1)
+
+    print(f"\n\nAuthorized! Access token: {access_token[:12]}...\n")
+
+    # Step 3: Fetch profile
+    print("Fetching profile...")
+    try:
+        profile = _get(f"{BASE}/profile", access_token)
+    except (HTTPError, URLError) as e:
+        print(f"Failed to fetch profile: {e}")
+        print(f"(access_token was: {access_token})")
+        sys.exit(1)
+
+    print(f"\nProfile response:\n{json.dumps(profile, indent=2)}\n")
+
+    api_key = profile.get("api_key")
+    if api_key:
+        print("=" * 50)
+        print(f"Your ScrapeCreators API key: {api_key}")
+        print("=" * 50)
+        print(f"\nTo use it: echo 'SCRAPECREATORS_API_KEY={api_key}' >> ~/.config/last30days/.env")
+    else:
+        print("No api_key in profile response. Full response printed above.")
+
+
+if __name__ == "__main__":
+    main()

package/skills/luckiest-trends/scripts/verify_v3.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+"""Run the v3 verification bundle for last30days."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import statistics
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+REPO_ROOT = Path(__file__).resolve().parents[3]
+PYTHON = sys.executable
+ENGINE = SKILL_ROOT / "scripts" / "last30days.py"
+EVALUATOR = SKILL_ROOT / "scripts" / "evaluate_search_quality.py"
+
+SMOKE_TOPIC = "openclaw skills"
+SMOKE_CASES = [
+    ("gemini", ["--quick", "--search=grounding,hackernews"]),
+    ("openai", ["--quick", "--search=reddit,hackernews"]),
+    ("xai", ["--quick", "--search=reddit,hackernews"]),
+    ("auto", ["--quick", "--search=reddit,grounding,hackernews"]),
+]
+
+LATENCY_TOPICS = [
+    "openclaw skills",
+    "codex vs claude code",
+    "anthropic odds",
+]
+LATENCY_PROFILES = [
+    ("quick", ["--quick", "--search=grounding,hackernews"]),
+    ("default", ["--search=grounding,hackernews"]),
+    ("deep", ["--deep", "--search=grounding,hackernews"]),
+]
+
+
+def run_command(cmd: list[str], *, env: dict[str, str] | None = None, timeout: int = 600) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        cmd,
+        cwd=REPO_ROOT,
+        env=env,
+        text=True,
+        capture_output=True,
+        timeout=timeout,
+        check=True,
+    )
+
+
+def verify_unit() -> dict[str, str]:
+    run_command([PYTHON, "-m", "unittest", "discover", "-s", "tests", "-p", "test_*.py"], timeout=600)
+    run_command(
+        [
+            PYTHON,
+            "-m",
+            "py_compile",
+            *subprocess.run(
+                [
+                    "rg",
+                    "--files",
+                    "skills/last30days/scripts",
+                    "tests",
+                    "-g",
+                    "*.py",
+                    "-g",
+                    "!skills/last30days/scripts/lib/vendor/**",
+                ],
+                cwd=REPO_ROOT,
+                text=True,
+                capture_output=True,
+                check=True,
+            ).stdout.split(),
+        ],
+        timeout=600,
+    )
+    return {"status": "ok"}
+
+
+def verify_diagnose() -> dict[str, object]:
+    result = run_command([PYTHON, str(ENGINE), "--diagnose"], timeout=120)
+    return json.loads(result.stdout)
+
+
+def verify_smoke() -> list[dict[str, object]]:
+    rows: list[dict[str, object]] = []
+    for provider, extra in SMOKE_CASES:
+        env = os.environ.copy()
+        env["LAST30DAYS_REASONING_PROVIDER"] = provider
+        start = time.time()
+        result = run_command(
+            [PYTHON, str(ENGINE), SMOKE_TOPIC, "--emit=json", *extra],
+            env=env,
+            timeout=240,
+        )
+        duration = round(time.time() - start, 2)
+        report = json.loads(result.stdout)
+        rows.append(
+            {
+                "provider": provider,
+                "duration_seconds": duration,
+                "reasoning_provider": (report.get("provider_runtime") or {}).get("reasoning_provider"),
+                "cluster_count": len(report.get("clusters") or []),
+                "candidate_count": len(report.get("ranked_candidates") or []),
+                "error_sources": sorted((report.get("errors_by_source") or {}).keys()),
+            }
+        )
+    return rows
+
+
+def verify_latency() -> dict[str, dict[str, object]]:
+    results: dict[str, dict[str, object]] = {}
+    for profile, extra in LATENCY_PROFILES:
+        timings = []
+        for topic in LATENCY_TOPICS:
+            start = time.time()
+            run_command(
+                [PYTHON, str(ENGINE), topic, "--emit=json", *extra],
+                timeout=300,
+            )
+            timings.append(time.time() - start)
+        results[profile] = {
+            "times": [round(value, 2) for value in timings],
+            "median_seconds": round(statistics.median(timings), 2),
+            "max_seconds": round(max(timings), 2),
+        }
+    return results
+
+
+def verify_eval(
+    *,
+    baseline: str,
+    candidate: str,
+    output_dir: str,
+    quick: bool,
+    limit: int,
+    timeout: int,
+) -> dict[str, object]:
+    cmd = [
+        PYTHON,
+        str(EVALUATOR),
+        f"--baseline={baseline}",
+        f"--candidate={candidate}",
+        f"--output-dir={output_dir}",
+        f"--limit={limit}",
+        f"--timeout={timeout}",
+    ]
+    if quick:
+        cmd.append("--quick")
+    run_command(cmd, timeout=max(timeout * 8, 600))
+    output = Path(output_dir)
+    metrics = json.loads((output / "metrics.json").read_text())
+    summary = (output / "summary.md").read_text()
+    return {"metrics": metrics, "summary": summary}
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="Run the v3 verification bundle")
+    parser.add_argument("--skip-eval", action="store_true", help="Skip the judged evaluator")
+    parser.add_argument("--skip-latency", action="store_true", help="Skip live latency sampling")
+    parser.add_argument("--baseline", default="HEAD~1")
+    parser.add_argument("--candidate", default="WORKTREE")
+    parser.add_argument("--output-dir", default="/tmp/last30days-v3-verify")
+    parser.add_argument("--quick-eval", action="store_true", help="Use evaluator quick mode")
+    parser.add_argument("--eval-limit", type=int, default=20)
+    parser.add_argument("--eval-timeout", type=int, default=240)
+    return parser
+
+
+def main() -> int:
+    args = build_parser().parse_args()
+    summary: dict[str, object] = {}
+    summary["unit"] = verify_unit()
+    summary["diagnose"] = verify_diagnose()
+    summary["smoke"] = verify_smoke()
+    if not args.skip_latency:
+        summary["latency"] = verify_latency()
+    if not args.skip_eval:
+        summary["eval"] = verify_eval(
+            baseline=args.baseline,
+            candidate=args.candidate,
+            output_dir=args.output_dir,
+            quick=args.quick_eval,
+            limit=args.eval_limit,
+            timeout=args.eval_timeout,
+        )
+    print(json.dumps(summary, indent=2, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())