@qqbrowser/openclaw-qbot 0.0.106 → 0.0.108

package/skills/model-usage/scripts/model_usage.py

@@ -1,320 +0,0 @@
-#!/usr/bin/env python3
-"""
-Summarize CodexBar local cost usage by model.
-
-Defaults to current model (most recent daily entry), or list all models.
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import os
-import subprocess
-import sys
-from dataclasses import dataclass
-from datetime import date, datetime, timedelta
-from typing import Any, Dict, Iterable, List, Optional, Tuple
-
-
-def positive_int(value: str) -> int:
-    try:
-        parsed = int(value)
-    except ValueError as exc:
-        raise argparse.ArgumentTypeError("must be an integer") from exc
-    if parsed < 1:
-        raise argparse.ArgumentTypeError("must be >= 1")
-    return parsed
-
-
-def eprint(msg: str) -> None:
-    print(msg, file=sys.stderr)
-
-
-def run_codexbar_cost(provider: str) -> List[Dict[str, Any]]:
-    cmd = ["codexbar", "cost", "--format", "json", "--provider", provider]
-    try:
-        output = subprocess.check_output(cmd, text=True)
-    except FileNotFoundError:
-        raise RuntimeError("codexbar not found on PATH. Install CodexBar CLI first.")
-    except subprocess.CalledProcessError as exc:
-        raise RuntimeError(f"codexbar cost failed (exit {exc.returncode}).")
-    try:
-        payload = json.loads(output)
-    except json.JSONDecodeError as exc:
-        raise RuntimeError(f"Failed to parse codexbar JSON output: {exc}")
-    if not isinstance(payload, list):
-        raise RuntimeError("Expected codexbar cost JSON array.")
-    return payload
-
-
-def load_payload(input_path: Optional[str], provider: str) -> Dict[str, Any]:
-    if input_path:
-        if input_path == "-":
-            raw = sys.stdin.read()
-        else:
-            with open(input_path, "r", encoding="utf-8") as handle:
-                raw = handle.read()
-        data = json.loads(raw)
-    else:
-        data = run_codexbar_cost(provider)
-
-    if isinstance(data, dict):
-        return data
-
-    if isinstance(data, list):
-        for entry in data:
-            if isinstance(entry, dict) and entry.get("provider") == provider:
-                return entry
-        raise RuntimeError(f"Provider '{provider}' not found in codexbar payload.")
-
-    raise RuntimeError("Unsupported JSON input format.")
-
-
-@dataclass
-class ModelCost:
-    model: str
-    cost: float
-
-
-def parse_daily_entries(payload: Dict[str, Any]) -> List[Dict[str, Any]]:
-    daily = payload.get("daily")
-    if not daily:
-        return []
-    if not isinstance(daily, list):
-        return []
-    return [entry for entry in daily if isinstance(entry, dict)]
-
-
-def parse_date(value: str) -> Optional[date]:
-    try:
-        return datetime.strptime(value, "%Y-%m-%d").date()
-    except Exception:
-        return None
-
-
-def filter_by_days(entries: List[Dict[str, Any]], days: Optional[int]) -> List[Dict[str, Any]]:
-    if not days:
-        return entries
-    cutoff = date.today() - timedelta(days=days - 1)
-    filtered: List[Dict[str, Any]] = []
-    for entry in entries:
-        day = entry.get("date")
-        if not isinstance(day, str):
-            continue
-        parsed = parse_date(day)
-        if parsed and parsed >= cutoff:
-            filtered.append(entry)
-    return filtered
-
-
-def aggregate_costs(entries: Iterable[Dict[str, Any]]) -> Dict[str, float]:
-    totals: Dict[str, float] = {}
-    for entry in entries:
-        breakdowns = entry.get("modelBreakdowns")
-        if not breakdowns:
-            continue
-        if not isinstance(breakdowns, list):
-            continue
-        for item in breakdowns:
-            if not isinstance(item, dict):
-                continue
-            model = item.get("modelName")
-            cost = item.get("cost")
-            if not isinstance(model, str):
-                continue
-            if not isinstance(cost, (int, float)):
-                continue
-            totals[model] = totals.get(model, 0.0) + float(cost)
-    return totals
-
-
-def pick_current_model(entries: List[Dict[str, Any]]) -> Tuple[Optional[str], Optional[str]]:
-    if not entries:
-        return None, None
-    sorted_entries = sorted(
-        entries,
-        key=lambda entry: entry.get("date") or "",
-    )
-    for entry in reversed(sorted_entries):
-        breakdowns = entry.get("modelBreakdowns")
-        if isinstance(breakdowns, list) and breakdowns:
-            scored: List[ModelCost] = []
-            for item in breakdowns:
-                if not isinstance(item, dict):
-                    continue
-                model = item.get("modelName")
-                cost = item.get("cost")
-                if isinstance(model, str) and isinstance(cost, (int, float)):
-                    scored.append(ModelCost(model=model, cost=float(cost)))
-            if scored:
-                scored.sort(key=lambda item: item.cost, reverse=True)
-                return scored[0].model, entry.get("date") if isinstance(entry.get("date"), str) else None
-        models_used = entry.get("modelsUsed")
-        if isinstance(models_used, list) and models_used:
-            last = models_used[-1]
-            if isinstance(last, str):
-                return last, entry.get("date") if isinstance(entry.get("date"), str) else None
-    return None, None
-
-
-def usd(value: Optional[float]) -> str:
-    if value is None:
-        return "—"
-    return f"${value:,.2f}"
-
-
-def latest_day_cost(entries: List[Dict[str, Any]], model: str) -> Tuple[Optional[str], Optional[float]]:
-    if not entries:
-        return None, None
-    sorted_entries = sorted(
-        entries,
-        key=lambda entry: entry.get("date") or "",
-    )
-    for entry in reversed(sorted_entries):
-        breakdowns = entry.get("modelBreakdowns")
-        if not isinstance(breakdowns, list):
-            continue
-        for item in breakdowns:
-            if not isinstance(item, dict):
-                continue
-            if item.get("modelName") == model:
-                cost = item.get("cost") if isinstance(item.get("cost"), (int, float)) else None
-                day = entry.get("date") if isinstance(entry.get("date"), str) else None
-                return day, float(cost) if cost is not None else None
-    return None, None
-
-
-def render_text_current(
-    provider: str,
-    model: str,
-    latest_date: Optional[str],
-    total_cost: Optional[float],
-    latest_cost: Optional[float],
-    latest_cost_date: Optional[str],
-    entry_count: int,
-) -> str:
-    lines = [f"Provider: {provider}", f"Current model: {model}"]
-    if latest_date:
-        lines.append(f"Latest model date: {latest_date}")
-    lines.append(f"Total cost (rows): {usd(total_cost)}")
-    if latest_cost_date:
-        lines.append(f"Latest day cost: {usd(latest_cost)} ({latest_cost_date})")
-    lines.append(f"Daily rows: {entry_count}")
-    return "\n".join(lines)
-
-
-def render_text_all(provider: str, totals: Dict[str, float]) -> str:
-    lines = [f"Provider: {provider}", "Models:"]
-    for model, cost in sorted(totals.items(), key=lambda item: item[1], reverse=True):
-        lines.append(f"- {model}: {usd(cost)}")
-    return "\n".join(lines)
-
-
-def build_json_current(
-    provider: str,
-    model: str,
-    latest_date: Optional[str],
-    total_cost: Optional[float],
-    latest_cost: Optional[float],
-    latest_cost_date: Optional[str],
-    entry_count: int,
-) -> Dict[str, Any]:
-    return {
-        "provider": provider,
-        "mode": "current",
-        "model": model,
-        "latestModelDate": latest_date,
-        "totalCostUSD": total_cost,
-        "latestDayCostUSD": latest_cost,
-        "latestDayCostDate": latest_cost_date,
-        "dailyRowCount": entry_count,
-    }
-
-
-def build_json_all(provider: str, totals: Dict[str, float]) -> Dict[str, Any]:
-    return {
-        "provider": provider,
-        "mode": "all",
-        "models": [
-            {"model": model, "totalCostUSD": cost}
-            for model, cost in sorted(totals.items(), key=lambda item: item[1], reverse=True)
-        ],
-    }
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description="Summarize CodexBar model usage from local cost logs.")
-    parser.add_argument("--provider", choices=["codex", "claude"], default="codex")
-    parser.add_argument("--mode", choices=["current", "all"], default="current")
-    parser.add_argument("--model", help="Explicit model name to report instead of auto-current.")
-    parser.add_argument("--input", help="Path to codexbar cost JSON (or '-' for stdin).")
-    parser.add_argument("--days", type=positive_int, help="Limit to last N days (based on daily rows).")
-    parser.add_argument("--format", choices=["text", "json"], default="text")
-    parser.add_argument("--pretty", action="store_true", help="Pretty-print JSON output.")
-
-    args = parser.parse_args()
-
-    try:
-        payload = load_payload(args.input, args.provider)
-    except Exception as exc:
-        eprint(str(exc))
-        return 1
-
-    entries = parse_daily_entries(payload)
-    entries = filter_by_days(entries, args.days)
-
-    if args.mode == "current":
-        model = args.model
-        latest_date = None
-        if not model:
-            model, latest_date = pick_current_model(entries)
-        if not model:
-            eprint("No model data found in codexbar cost payload.")
-            return 2
-        totals = aggregate_costs(entries)
-        total_cost = totals.get(model)
-        latest_cost_date, latest_cost = latest_day_cost(entries, model)
-
-        if args.format == "json":
-            payload_out = build_json_current(
-                provider=args.provider,
-                model=model,
-                latest_date=latest_date,
-                total_cost=total_cost,
-                latest_cost=latest_cost,
-                latest_cost_date=latest_cost_date,
-                entry_count=len(entries),
-            )
-            indent = 2 if args.pretty else None
-            print(json.dumps(payload_out, indent=indent, sort_keys=args.pretty))
-        else:
-            print(
-                render_text_current(
-                    provider=args.provider,
-                    model=model,
-                    latest_date=latest_date,
-                    total_cost=total_cost,
-                    latest_cost=latest_cost,
-                    latest_cost_date=latest_cost_date,
-                    entry_count=len(entries),
-                )
-            )
-        return 0
-
-    totals = aggregate_costs(entries)
-    if not totals:
-        eprint("No model breakdowns found in codexbar cost payload.")
-        return 2
-
-    if args.format == "json":
-        payload_out = build_json_all(provider=args.provider, totals=totals)
-        indent = 2 if args.pretty else None
-        print(json.dumps(payload_out, indent=indent, sort_keys=args.pretty))
-    else:
-        print(render_text_all(provider=args.provider, totals=totals))
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/skills/model-usage/scripts/test_model_usage.py

@@ -1,40 +0,0 @@
-#!/usr/bin/env python3
-"""
-Tests for model_usage helpers.
-"""
-
-import argparse
-from datetime import date, timedelta
-from unittest import TestCase, main
-
-from model_usage import filter_by_days, positive_int
-
-
-class TestModelUsage(TestCase):
-    def test_positive_int_accepts_valid_numbers(self):
-        self.assertEqual(positive_int("1"), 1)
-        self.assertEqual(positive_int("7"), 7)
-
-    def test_positive_int_rejects_zero_and_negative(self):
-        with self.assertRaises(argparse.ArgumentTypeError):
-            positive_int("0")
-        with self.assertRaises(argparse.ArgumentTypeError):
-            positive_int("-3")
-
-    def test_filter_by_days_keeps_recent_entries(self):
-        today = date.today()
-        entries = [
-            {"date": (today - timedelta(days=5)).strftime("%Y-%m-%d"), "modelBreakdowns": []},
-            {"date": (today - timedelta(days=1)).strftime("%Y-%m-%d"), "modelBreakdowns": []},
-            {"date": today.strftime("%Y-%m-%d"), "modelBreakdowns": []},
-        ]
-
-        filtered = filter_by_days(entries, 2)
-
-        self.assertEqual(len(filtered), 2)
-        self.assertEqual(filtered[0]["date"], (today - timedelta(days=1)).strftime("%Y-%m-%d"))
-        self.assertEqual(filtered[1]["date"], today.strftime("%Y-%m-%d"))
-
-
-if __name__ == "__main__":
-    main()

package/skills/study-habits/SKILL.md

@@ -1,72 +0,0 @@
----
-name: study-habits
-description: Build effective study habits with spaced repetition, active recall, and session tracking
-author: clawd-team
-version: 1.0.0
-triggers:
-  - "study session"
-  - "study habits"
-  - "learn effectively"
-  - "study timer"
-  - "exam prep"
----
-
-# Study Habits
-
-_Learning that sticks—through science, not stubbornness._
-
-## What it does
-
-This skill transforms how you absorb and retain information by combining proven cognitive techniques with persistent session tracking:
-
-- **Study Session Tracking** - Logs when you study, what topic, duration, and effectiveness rating for accountability and pattern recognition
-- **Technique Suggestions** - Recommends study methods based on your learning goal (memorization vs. deep understanding vs. skill practice)
-- **Spaced Repetition Reminders** - Intelligently schedules review sessions to hit the sweet spot where forgetting begins
-- **Progress Dashboard** - Shows your study velocity, topic mastery levels, and retention curves over time
-- **Exam Countdown** - Builds personalized prep schedules that work backward from exam date to ensure full coverage
-
-## Usage
-
-**Start study**
-: "Start a 50-minute study session on photosynthesis" → Creates a session timer, suggests an optimal study technique, and tracks your focus
-
-**Log topic**
-: "I just finished studying Chapter 3, felt confident" → Records the session, captures confidence level, determines next review interval
-
-**Review schedule**
-: "When should I review calculus next?" → Shows which topics need review based on spaced repetition algorithm, prioritizes by forgetting curve
-
-**Check progress**
-: "Show me my study stats" → Displays sessions completed, topics covered, retention trends, time invested per subject
-
-**Exam countdown**
-: "I have an exam in 21 days on biology" → Creates a study plan that distributes chapters across available time, accounts for review cycles, flags high-risk topics
-
-## Study Techniques
-
-**Active Recall**
-: Test yourself without looking at notes. Forces your brain to retrieve information rather than passively reread. Far more effective than review.
-
-**Spaced Repetition**
-: Review material at increasing intervals (1 day, 3 days, 1 week, 2 weeks). This combats the forgetting curve and moves knowledge to long-term memory.
-
-**Pomodoro Technique**
-: Study in 25-minute focused bursts with 5-minute breaks. Prevents burnout and maintains attention during sessions.
-
-**Feynman Technique**
-: Explain a concept aloud as if teaching it to someone with no background. Exposes gaps in understanding immediately.
-
-**Interleaving**
-: Mix different topics or problem types in one session instead of blocking them. Builds flexible knowledge and stronger pattern recognition.
-
-## Tips
-
-1. **Track confidence, not just completion** — Rate how well you understood each topic (1-10) rather than just marking it done. This surfaces weak areas early.
-
-2. **Use active recall over rereading** — Flashcards, practice problems, and explain-it-aloud beat passively reviewing notes by 10x.
-
-3. **Study in shorter sprints, more often** — Three 45-minute sessions spread across a week beat one 2-hour cramming session. Your brain consolidates overnight.
-
-4. **Review the day after, then space out** — First review should be 24 hours later, then 3 days, then a week. The algorithm handles this automatically.
-
-5. **All data stays local on your machine** — Your study history, notes, and progress never leave your device. Full privacy, full control.

package/skills/study-habits/_meta.json

@@ -1,6 +0,0 @@
-{
-  "ownerId": "kn7dsqp497235e9hhzdwd0q9a57zxjw6",
-  "slug": "study-habits",
-  "version": "1.0.0",
-  "publishedAt": 1769326643178
-}

package/skills/xiaohongshu-mcp/SKILL.md

@@ -1,95 +0,0 @@
----
-name: xiaohongshu-mcp
-description: >
-  Automate Xiaohongshu (RedNote) content operations using a Python client for the xiaohongshu-mcp server.
-  Use for: (1) Publishing image, text, and video content, (2) Searching for notes and trends,
-  (3) Analyzing post details and comments, (4) Managing user profiles and content feeds.
-  Triggers: xiaohongshu automation, rednote content, publish to xiaohongshu, xiaohongshu search, social media management.
----
-
-# Xiaohongshu MCP Skill (with Python Client)
-
-Automate content operations on Xiaohongshu (小红书) using a bundled Python script that interacts with the `xpzouying/xiaohongshu-mcp` server (8.4k+ stars).
-
-**Project:** [xpzouying/xiaohongshu-mcp](https://github.com/xpzouying/xiaohongshu-mcp)
-
-## 1. Local Server Setup
-
-This skill requires the `xiaohongshu-mcp` server to be running on your local machine.
-
-### Step 1: Download Binaries
-
-Download the appropriate binaries for your system from the [GitHub Releases](https://github.com/xpzouying/xiaohongshu-mcp/releases) page.
-
-| Platform              | MCP Server                          | Login Tool                            |
-| --------------------- | ----------------------------------- | ------------------------------------- |
-| macOS (Apple Silicon) | `xiaohongshu-mcp-darwin-arm64`      | `xiaohongshu-login-darwin-arm64`      |
-| macOS (Intel)         | `xiaohongshu-mcp-darwin-amd64`      | `xiaohongshu-login-darwin-amd64`      |
-| Windows               | `xiaohongshu-mcp-windows-amd64.exe` | `xiaohongshu-login-windows-amd64.exe` |
-| Linux                 | `xiaohongshu-mcp-linux-amd64`       | `xiaohongshu-login-linux-amd64`       |
-
-Grant execute permission to the downloaded files:
-
-```shell
-chmod +x xiaohongshu-mcp-darwin-arm64 xiaohongshu-login-darwin-arm64
-```
-
-### Step 2: Login (First Time Only)
-
-Run the login tool. It will open a browser window with a QR code. Scan it with your Xiaohongshu mobile app.
-
-```shell
-./xiaohongshu-login-darwin-arm64
-```
-
-> **Important**: Do not log into the same Xiaohongshu account on any other web browser, as this will invalidate the server's session.
-
-### Step 3: Start the MCP Server
-
-Run the MCP server in a separate terminal window. It will run in the background.
-
-```shell
-# Run in headless mode (recommended)
-./xiaohongshu-mcp-darwin-arm64
-
-# Or, run with a visible browser for debugging
-./xiaohongshu-mcp-darwin-arm64 -headless=false
-```
-
-The server will be available at `http://localhost:18060`.
-
-## 2. Using the Skill
-
-This skill includes a Python client (`scripts/xhs_client.py`) to interact with the local server. You can use it directly from the shell.
-
-### Available Commands
-
-| Command                              | Description          | Example                                                              |
-| ------------------------------------ | -------------------- | -------------------------------------------------------------------- |
-| `status`                             | Check login status   | `python scripts/xhs_client.py status`                                |
-| `search <keyword>`                   | Search for notes     | `python scripts/xhs_client.py search "咖啡"`                         |
-| `detail <id> <token>`                | Get note details     | `python scripts/xhs_client.py detail "note_id" "xsec_token"`         |
-| `feeds`                              | Get recommended feed | `python scripts/xhs_client.py feeds`                                 |
-| `publish <title> <content> <images>` | Publish a note       | `python scripts/xhs_client.py publish "Title" "Content" "url1,url2"` |
-
-### Example Workflow: Market Research
-
-1.  **Check Status**: First, ensure the server is running and you are logged in.
-
-    ```shell
-    python ~/clawd/skills/xiaohongshu-mcp/scripts/xhs_client.py status
-    ```
-
-2.  **Search for a Keyword**: Find notes related to your research topic. The output will include the `feed_id` and `xsec_token` needed for the next step.
-
-    ```shell
-    python ~/clawd/skills/xiaohongshu-mcp/scripts/xhs_client.py search "户外电源"
-    ```
-
-3.  **Get Note Details**: Use the `feed_id` and `xsec_token` from the search results to get the full content and comments of a specific note.
-
-    ```shell
-    python ~/clawd/skills/xiaohongshu-mcp/scripts/xhs_client.py detail "64f1a2b3c4d5e6f7a8b9c0d1" "security_token_here"
-    ```
-
-4.  **Analyze**: Review the note's content, comments, and engagement data to gather insights.

package/skills/xiaohongshu-mcp/_meta.json

@@ -1,6 +0,0 @@
-{
-  "ownerId": "kn7f1yz4eej0ksk4yvcskjpnwx80asx4",
-  "slug": "xiaohongshu-mcp",
-  "version": "1.0.0",
-  "publishedAt": 1769938539127
-}