@intent-systems/nexus 2026.1.5-3

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

@@ -0,0 +1,310 @@
+#!/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 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=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/nano-banana-pro/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: nano-banana-pro
+description: Generate or edit images via Gemini 3 Pro Image (Nano Banana Pro).
+homepage: https://ai.google.dev/
+metadata: {"nexus":{"emoji":"🍌","requires":{"bins":["uv"],"env":["GEMINI_API_KEY"]},"primaryEnv":"GEMINI_API_KEY","install":[{"id":"uv-brew","kind":"brew","formula":"uv","bins":["uv"],"label":"Install uv (brew)"}]}}
+---
+
+# Nano Banana Pro (Gemini 3 Pro Image)
+
+Use the bundled script to generate or edit images.
+
+Generate
+```bash
+uv run {baseDir}/scripts/generate_image.py --prompt "your image description" --filename "output.png" --resolution 1K
+```
+
+Edit
+```bash
+uv run {baseDir}/scripts/generate_image.py --prompt "edit instructions" --filename "output.png" --input-image "/path/in.png" --resolution 2K
+```
+
+API key
+- `GEMINI_API_KEY` env var
+- Or set `skills."nano-banana-pro".apiKey` / `skills."nano-banana-pro".env.GEMINI_API_KEY` in `~/nexus/state/nexus.json`
+
+Notes
+- Resolutions: `1K` (default), `2K`, `4K`.
+- Use timestamps in filenames: `yyyy-mm-dd-hh-mm-ss-name.png`.
+- The script prints a `MEDIA:` line for Nexus to auto-attach on supported chat providers.
+- Do not read the image back; report the saved path only.

package/skills/nano-banana-pro/scripts/generate_image.py

@@ -0,0 +1,169 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "google-genai>=1.0.0",
+#     "pillow>=10.0.0",
+# ]
+# ///
+"""
+Generate images using Google's Nano Banana Pro (Gemini 3 Pro Image) API.
+
+Usage:
+    uv run generate_image.py --prompt "your image description" --filename "output.png" [--resolution 1K|2K|4K] [--api-key KEY]
+"""
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+
+def get_api_key(provided_key: str | None) -> str | None:
+    """Get API key from argument first, then environment."""
+    if provided_key:
+        return provided_key
+    return os.environ.get("GEMINI_API_KEY")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate images using Nano Banana Pro (Gemini 3 Pro Image)"
+    )
+    parser.add_argument(
+        "--prompt", "-p",
+        required=True,
+        help="Image description/prompt"
+    )
+    parser.add_argument(
+        "--filename", "-f",
+        required=True,
+        help="Output filename (e.g., sunset-mountains.png)"
+    )
+    parser.add_argument(
+        "--input-image", "-i",
+        help="Optional input image path for editing/modification"
+    )
+    parser.add_argument(
+        "--resolution", "-r",
+        choices=["1K", "2K", "4K"],
+        default="1K",
+        help="Output resolution: 1K (default), 2K, or 4K"
+    )
+    parser.add_argument(
+        "--api-key", "-k",
+        help="Gemini API key (overrides GEMINI_API_KEY env var)"
+    )
+
+    args = parser.parse_args()
+
+    # Get API key
+    api_key = get_api_key(args.api_key)
+    if not api_key:
+        print("Error: No API key provided.", file=sys.stderr)
+        print("Please either:", file=sys.stderr)
+        print("  1. Provide --api-key argument", file=sys.stderr)
+        print("  2. Set GEMINI_API_KEY environment variable", file=sys.stderr)
+        sys.exit(1)
+
+    # Import here after checking API key to avoid slow import on error
+    from google import genai
+    from google.genai import types
+    from PIL import Image as PILImage
+
+    # Initialise client
+    client = genai.Client(api_key=api_key)
+
+    # Set up output path
+    output_path = Path(args.filename)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Load input image if provided
+    input_image = None
+    output_resolution = args.resolution
+    if args.input_image:
+        try:
+            input_image = PILImage.open(args.input_image)
+            print(f"Loaded input image: {args.input_image}")
+
+            # Auto-detect resolution if not explicitly set by user
+            if args.resolution == "1K":  # Default value
+                # Map input image size to resolution
+                width, height = input_image.size
+                max_dim = max(width, height)
+                if max_dim >= 3000:
+                    output_resolution = "4K"
+                elif max_dim >= 1500:
+                    output_resolution = "2K"
+                else:
+                    output_resolution = "1K"
+                print(f"Auto-detected resolution: {output_resolution} (from input {width}x{height})")
+        except Exception as e:
+            print(f"Error loading input image: {e}", file=sys.stderr)
+            sys.exit(1)
+
+    # Build contents (image first if editing, prompt only if generating)
+    if input_image:
+        contents = [input_image, args.prompt]
+        print(f"Editing image with resolution {output_resolution}...")
+    else:
+        contents = args.prompt
+        print(f"Generating image with resolution {output_resolution}...")
+
+    try:
+        response = client.models.generate_content(
+            model="gemini-3-pro-image-preview",
+            contents=contents,
+            config=types.GenerateContentConfig(
+                response_modalities=["TEXT", "IMAGE"],
+                image_config=types.ImageConfig(
+                    image_size=output_resolution
+                )
+            )
+        )
+
+        # Process response and convert to PNG
+        image_saved = False
+        for part in response.parts:
+            if part.text is not None:
+                print(f"Model response: {part.text}")
+            elif part.inline_data is not None:
+                # Convert inline data to PIL Image and save as PNG
+                from io import BytesIO
+
+                # inline_data.data is already bytes, not base64
+                image_data = part.inline_data.data
+                if isinstance(image_data, str):
+                    # If it's a string, it might be base64
+                    import base64
+                    image_data = base64.b64decode(image_data)
+
+                image = PILImage.open(BytesIO(image_data))
+
+                # Ensure RGB mode for PNG (convert RGBA to RGB with white background if needed)
+                if image.mode == 'RGBA':
+                    rgb_image = PILImage.new('RGB', image.size, (255, 255, 255))
+                    rgb_image.paste(image, mask=image.split()[3])
+                    rgb_image.save(str(output_path), 'PNG')
+                elif image.mode == 'RGB':
+                    image.save(str(output_path), 'PNG')
+                else:
+                    image.convert('RGB').save(str(output_path), 'PNG')
+                image_saved = True
+
+        if image_saved:
+            full_path = output_path.resolve()
+            print(f"\nImage saved: {full_path}")
+            # Nexus parses MEDIA tokens and will attach the file on supported providers.
+            print(f"MEDIA: {full_path}")
+        else:
+            print("Error: No image was generated in the response.", file=sys.stderr)
+            sys.exit(1)
+
+    except Exception as e:
+        print(f"Error generating image: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/skills/nano-pdf/SKILL.md

@@ -0,0 +1,20 @@
+---
+name: nano-pdf
+description: Edit PDFs with natural-language instructions using the nano-pdf CLI.
+homepage: https://pypi.org/project/nano-pdf/
+metadata: {"nexus":{"emoji":"📄","requires":{"bins":["nano-pdf"]},"install":[{"id":"uv","kind":"uv","package":"nano-pdf","bins":["nano-pdf"],"label":"Install nano-pdf (uv)"}]}}
+---
+
+# nano-pdf
+
+Use `nano-pdf` to apply edits to a specific page in a PDF using a natural-language instruction.
+
+## Quick start
+
+```bash
+nano-pdf edit deck.pdf 1 "Change the title to 'Q3 Results' and fix the typo in the subtitle"
+```
+
+Notes:
+- Page numbers are 0-based or 1-based depending on the tool’s version/config; if the result looks off by one, retry with the other.
+- Always sanity-check the output PDF before sending it out.

package/skills/nexus-cloud/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: nexus-cloud
+description: "Install and operate the Nexus Cloud CLI for encrypted workspace sync: build the Rust CLI, init/login, enable the background daemon, sync the personal workspace, mount shared workspaces, and explain how shared workspaces are created and shared."
+---
+
+# Nexus Cloud CLI
+
+Keep the security model straight: keys stay local, the server never sees plaintext.
+
+## Docs
+
+- `docs/setup.md`
+- `docs/security.md`
+- `docs/troubleshooting.md`
+
+## Install and setup (personal workspace)
+
+1. Go to the repo: `~/nexus/home/projects/nexus-cloud`
+2. Build the CLI: `./scripts/build-rust-cli.sh`
+3. Point to the binary:
+   - `CLI=./rust/target/release/cli`
+4. Initialize the workspace:
+   - `$CLI init --workspace ~/nexus/home`
+5. Login (browser auth + local key provisioning):
+   - `$CLI login`
+6. Enable always-on sync:
+   - macOS: `$CLI daemon install`
+   - other OS: run `$CLI daemon` in a long-lived shell
+
+## Explain the lifecycle to humans
+
+- "My Workspace" == personal workspace; always-on once the daemon is installed.
+- "Shared Workspaces" == shared workspaces; each is mounted to a local folder.
+- Use `$CLI guide` to show the lifecycle summary.
+
+## Shared workspaces (current CLI flow)
+
+- List spaces: `$CLI collab spaces list`
+- Mount: `$CLI spaces mount <space_id> --path <path>`
+- Sync: `$CLI spaces push <space_id>` / `$CLI spaces pull <space_id>`
+
+## Create a shared workspace (current model)
+
+- Ensure members are accepted connections (managed on the website today).
+- Create: `$CLI collab spaces create --name "Project" --members "alice@example.com,bob@example.com"`
+- Mount after creation: `$CLI spaces mount <space_id>`
+
+## Share link invites (allowlist model)
+
+- Create a link restricted to specific emails:
+  - `$CLI collab spaces invite-links create <space_id> --emails "alice@example.com,bob@example.com"`
+- Share the URL printed by the CLI.
+- Invitees accept in the browser and then run `$CLI login` to fetch space keys.

package/skills/nexus-cloud/docs/security.md

@@ -0,0 +1,24 @@
+# Nexus Cloud Security
+
+## Zero-knowledge model
+
+All encryption happens locally. The server only stores encrypted blobs.
+
+## Master password
+
+- Required to decrypt data.
+- Store in 1Password immediately.
+- If lost, data is unrecoverable.
+
+## .nexusignore
+
+Exclude sensitive paths:
+
+```
+sessions/
+.env
+*credentials*
+*secret*
+*.key
+*.pem
+```

package/skills/nexus-cloud/docs/setup.md

@@ -0,0 +1,51 @@
+# Nexus Cloud Setup
+
+This is the encrypted workspace sync CLI.
+
+## Install wrangler
+
+```bash
+npm install -g wrangler
+wrangler --version
+```
+
+## Authenticate with Cloudflare
+
+```bash
+wrangler login
+wrangler whoami
+```
+
+## Create R2 bucket
+
+```bash
+wrangler r2 bucket create nexus-blobs
+```
+
+## Deploy the worker
+
+```bash
+cd ~/nexus/home/projects/nexus-cloud
+wrangler deploy
+```
+
+## Initialize locally
+
+```bash
+nexus-cloud init
+```
+
+Provide:
+- Worker URL
+- Master password (store in 1Password)
+
+## First sync
+
+```bash
+nexus-cloud push -m "Initial sync"
+nexus-cloud status
+```
+
+## Notes
+
+- Create a `.nexusignore` to exclude sensitive files.

package/skills/nexus-cloud/docs/troubleshooting.md

@@ -0,0 +1,28 @@
+# Nexus Cloud Troubleshooting
+
+## Not authenticated with Cloudflare
+
+```bash
+wrangler login
+wrangler whoami
+```
+
+## R2 bucket not found
+
+```bash
+wrangler r2 bucket create nexus-blobs
+```
+
+## Master password lost
+
+Data cannot be recovered without the original master password.
+Initialize again and create a new workspace.
+
+## Worker timeout on large sync
+
+Split pushes:
+
+```bash
+nexus-cloud push --path skills/ -m "Sync skills"
+nexus-cloud push --path projects/ -m "Sync projects"
+```