luckiest-co 1.0.39 → 1.0.41

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

@@ -1,220 +0,0 @@
-#!/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/trends/scripts/test_device_auth.py

@@ -1,128 +0,0 @@
-#!/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/trends/scripts/verify_v3.py

@@ -1,195 +0,0 @@
-#!/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())