@smilintux/skcapstone 0.9.0 → 0.12.5

package/scripts/proxy-monitor.sh

@@ -0,0 +1,89 @@
+#!/bin/bash
+# proxy-monitor.sh — Quick health check for nvidia-proxy tuning
+# Usage: ./proxy-monitor.sh [minutes]  (default: last 30 minutes)
+MINS=${1:-30}
+if [[ "$OSTYPE" == "darwin"* ]]; then
+    SINCE=$(date -v-${MINS}M '+%Y-%m-%d %H:%M:%S')
+else
+    SINCE=$(date -d "$MINS minutes ago" '+%Y-%m-%d %H:%M:%S')
+fi
+
+echo "=== NVIDIA Proxy Monitor (last ${MINS}m) ==="
+echo ""
+
+# Request count & model breakdown
+echo "--- Requests by Model ---"
+journalctl --user -u nvidia-proxy --no-pager --since "$SINCE" 2>/dev/null \
+  | grep -oP 'model=\K[^ ]+' | sort | uniq -c | sort -rn
+echo ""
+
+# Body size stats
+echo "--- Body Sizes (bytes) ---"
+SIZES=$(journalctl --user -u nvidia-proxy --no-pager --since "$SINCE" 2>/dev/null \
+  | grep -oP 'bodyLen=\K[0-9]+' | sort -n)
+if [ -n "$SIZES" ]; then
+  COUNT=$(echo "$SIZES" | wc -l)
+  MIN=$(echo "$SIZES" | head -1)
+  MAX=$(echo "$SIZES" | tail -1)
+  AVG=$(echo "$SIZES" | awk '{s+=$1} END {printf "%.0f", s/NR}')
+  echo "  count=$COUNT  min=${MIN}  avg=${AVG}  max=${MAX}  limit=120000"
+  if [ "$MAX" -gt 100000 ]; then
+    echo "  ⚠️  Max approaching limit — consider bumping MAX_BODY_BYTES"
+  elif [ "$MAX" -lt 40000 ]; then
+    echo "  ✅ Plenty of headroom — no conversation trimming needed"
+  else
+    echo "  👀 Moderate usage — monitor for growth"
+  fi
+else
+  echo "  (no requests)"
+fi
+echo ""
+
+# Trimming events
+echo "--- Trimming Events ---"
+CONV_TRIM=$(journalctl --user -u nvidia-proxy --no-pager --since "$SINCE" 2>/dev/null \
+  | grep -c "trimmed history")
+AGGRESSIVE=$(journalctl --user -u nvidia-proxy --no-pager --since "$SINCE" 2>/dev/null \
+  | grep -c "AGGRESSIVE")
+SYS_TRIM=$(journalctl --user -u nvidia-proxy --no-pager --since "$SINCE" 2>/dev/null \
+  | grep -c "trimmed system prompt")
+TOOL_LIMIT=$(journalctl --user -u nvidia-proxy --no-pager --since "$SINCE" 2>/dev/null \
+  | grep -c "TOOL LIMIT")
+echo "  conversation trims: $CONV_TRIM"
+echo "  aggressive trims:   $AGGRESSIVE"
+echo "  system prompt trims: $SYS_TRIM"
+echo "  tool limit hits:    $TOOL_LIMIT"
+if [ "$AGGRESSIVE" -gt 0 ]; then
+  echo "  ⚠️  Aggressive trims happening — bump MAX_BODY_BYTES or keepEnd"
+elif [ "$CONV_TRIM" -gt 0 ]; then
+  echo "  👀 Some conversation trimming — watch if it increases"
+else
+  echo "  ✅ No conversation trimming — settings have headroom"
+fi
+echo ""
+
+# Error/retry stats
+echo "--- Errors & Retries ---"
+RETRIES=$(journalctl --user -u nvidia-proxy --no-pager --since "$SINCE" 2>/dev/null \
+  | grep -c "attempt=[2-4]")
+ERRORS=$(journalctl --user -u nvidia-proxy --no-pager --since "$SINCE" 2>/dev/null \
+  | grep -cE "4[0-9]{2}|5[0-9]{2}|error|Error")
+OK=$(journalctl --user -u nvidia-proxy --no-pager --since "$SINCE" 2>/dev/null \
+  | grep -c "200 OK")
+echo "  200 OK:  $OK"
+echo "  retries: $RETRIES"
+echo "  errors:  $ERRORS"
+echo ""
+
+# Response times (rough — from consecutive timestamps)
+echo "--- Keyword Activations ---"
+journalctl --user -u nvidia-proxy --no-pager --since "$SINCE" 2>/dev/null \
+  | grep -oP 'keyword-activated tools: \[\K[^\]]+' \
+  | tr ',' '\n' | sort | uniq -c | sort -rn | head -10
+echo ""
+
+# Current settings
+echo "--- Current Proxy Settings ---"
+grep -E "MAX_BODY_BYTES|MAX_SYSTEM_BYTES|allTools.length >|counter >= |keepEnd.*Math" \
+  /home/cbrd21/clawd/skcapstone-repos/skcapstone/scripts/nvidia-proxy.mjs 2>/dev/null \
+  | sed 's/^[[:space:]]*/  /'

package/scripts/refresh-anthropic-token.sh

@@ -0,0 +1,172 @@
+#!/usr/bin/env bash
+# Proactive Anthropic OAuth token refresh + sync to OpenClaw gateway.
+#
+# Two-phase approach (prb-021b489e):
+#   Phase 1: If token is expiring (<2h) or expired, refresh it:
+#     a) Try `claude auth status` (lightweight, no interactive session)
+#     b) If that fails, spin up ephemeral Claude Code in tmux → triggers internal refresh → kill it
+#   Phase 2: Sync the (possibly refreshed) token to OpenClaw config + restart gateway if changed.
+#
+# Run via systemd timer every 4 hours.
+set -euo pipefail
+
+_sed_i() { if [[ "$OSTYPE" == "darwin"* ]]; then sed -i '' "$@"; else sed -i "$@"; fi; }
+
+CREDS="$HOME/.claude/.credentials.json"
+OPENCLAW_JSON="$HOME/.openclaw/openclaw.json"
+OPENCLAW_ENV="$HOME/.openclaw/.env"
+OVERRIDE_CONF="$HOME/.config/systemd/user/openclaw-gateway.service.d/override.conf"
+LOG_TAG="anthropic-token-refresh"
+TMUX_SESSION="token-refresh-ephemeral"
+
+log() { echo "[$(date -u +%Y-%m-%dT%H:%M:%SZ)] [$LOG_TAG] $*"; }
+
+if [ ! -f "$CREDS" ]; then
+    log "ERROR: Claude credentials not found at $CREDS"
+    exit 1
+fi
+
+get_remaining_ms() {
+    python3 -c "
+import json, time
+creds = json.load(open('$CREDS'))
+exp = creds.get('claudeAiOauth',{}).get('expiresAt', 0)
+print(int(exp - time.time() * 1000))
+" 2>/dev/null || echo "0"
+}
+
+get_remaining_h() {
+    python3 -c "
+import json, time
+creds = json.load(open('$CREDS'))
+exp = creds.get('claudeAiOauth',{}).get('expiresAt', 0)
+print(f'{(exp/1000 - time.time())/3600:.1f}')
+" 2>/dev/null || echo "0"
+}
+
+token_needs_refresh() {
+    local remaining_ms
+    remaining_ms=$(get_remaining_ms)
+    # Refresh if less than 4 hours remaining (was 2h — too tight with 3h timer)
+    [ "$remaining_ms" -le 14400000 ]
+}
+
+token_is_healthy() {
+    local remaining_ms
+    remaining_ms=$(get_remaining_ms)
+    [ "$remaining_ms" -gt 14400000 ]
+}
+
+# ─── Phase 1: Refresh token if needed ───────────────────────────────
+
+if token_needs_refresh; then
+    log "Token needs refresh ($(get_remaining_h)h remaining)"
+
+    # Step 1a: Try lightweight refresh
+    log "Attempting lightweight refresh via 'claude auth status'..."
+    claude auth status > /dev/null 2>&1 || true
+    sleep 2
+
+    if token_is_healthy; then
+        log "Lightweight refresh succeeded! ($(get_remaining_h)h remaining)"
+    else
+        # Step 1b: Ephemeral Claude Code session in tmux
+        log "Lightweight refresh didn't cut it — spinning up ephemeral Claude Code session..."
+        tmux kill-session -t "$TMUX_SESSION" 2>/dev/null || true
+
+        tmux new-session -d -s "$TMUX_SESSION" \
+            "claude -p 'respond with just OK' --output-format stream-json 2>/dev/null; exit"
+
+        refreshed=false
+        for i in $(seq 1 12); do
+            sleep 5
+            if token_is_healthy; then
+                log "Ephemeral session refreshed the token! ($(get_remaining_h)h remaining)"
+                refreshed=true
+                break
+            fi
+        done
+
+        tmux kill-session -t "$TMUX_SESSION" 2>/dev/null || true
+
+        if [ "$refreshed" = "false" ]; then
+            log "ERROR: All refresh attempts failed ($(get_remaining_h)h remaining)"
+            log "Manual intervention may be needed: claude auth login"
+            # Continue to sync phase anyway — sync whatever token we have
+        fi
+    fi
+else
+    log "Token is healthy ($(get_remaining_h)h remaining), no refresh needed"
+fi
+
+# ─── Phase 2: Sync token to OpenClaw ────────────────────────────────
+
+ACCESS_TOKEN=$(python3 -c "import json; print(json.load(open('$CREDS'))['claudeAiOauth']['accessToken'])")
+REMAINING=$(get_remaining_h)
+
+# Check what's currently in the systemd override
+OLD_TOKEN=""
+if [ -f "$OVERRIDE_CONF" ]; then
+    OLD_TOKEN=$(grep "ANTHROPIC_API_KEY=" "$OVERRIDE_CONF" 2>/dev/null | sed 's/.*ANTHROPIC_API_KEY=//' || true)
+fi
+
+if [ "$OLD_TOKEN" = "$ACCESS_TOKEN" ]; then
+    log "Token already synced (expires in ${REMAINING}h)"
+    exit 0
+fi
+
+log "Token changed, syncing to OpenClaw..."
+
+# 1. Update openclaw.json
+if [ -f "$OPENCLAW_JSON" ]; then
+    python3 -c "
+import json
+with open('$OPENCLAW_JSON') as f:
+    cfg = json.load(f)
+if 'providers' in cfg.get('models', {}):
+    if 'anthropic' in cfg['models']['providers']:
+        cfg['models']['providers']['anthropic']['apiKey'] = '$ACCESS_TOKEN'
+        with open('$OPENCLAW_JSON', 'w') as f:
+            json.dump(cfg, f, indent=2)
+            f.write('\n')
+        print('[sync] Updated openclaw.json')
+    else:
+        print('[sync] No anthropic provider in openclaw.json')
+else:
+    print('[sync] No providers section in openclaw.json')
+"
+fi
+
+# 2. Update .env
+if grep -q "^ANTHROPIC_API_KEY=" "$OPENCLAW_ENV" 2>/dev/null; then
+    _sed_i "s|^ANTHROPIC_API_KEY=.*|ANTHROPIC_API_KEY=$ACCESS_TOKEN|" "$OPENCLAW_ENV"
+else
+    echo "ANTHROPIC_API_KEY=$ACCESS_TOKEN" >> "$OPENCLAW_ENV"
+fi
+log "Updated .env"
+
+# 3. Update systemd override
+NVIDIA_KEY=$(grep "NVIDIA_API_KEY=" "$OVERRIDE_CONF" 2>/dev/null | sed 's/.*NVIDIA_API_KEY=//' || true)
+cat > "$OVERRIDE_CONF" << EOF
+[Unit]
+StartLimitIntervalSec=60
+StartLimitBurst=10
+
+[Service]
+RestartSec=10
+Environment=NVIDIA_API_KEY=${NVIDIA_KEY}
+Environment=ANTHROPIC_API_KEY=${ACCESS_TOKEN}
+EOF
+log "Updated systemd override"
+
+# 4. Reload systemd (for env vars) but DO NOT restart the gateway.
+#    OpenClaw uses chokidar to watch openclaw.json — updating the file above
+#    triggers a hot reload automatically.  Restarting the gateway kills all
+#    active sessions (the root cause of the 0-turn session cascade on 2026-04-07).
+systemctl --user daemon-reload
+
+# Touch the config to ensure chokidar picks up the change (write already did,
+# but belt-and-suspenders in case the mtime didn't change fast enough).
+touch "$OPENCLAW_JSON"
+
+log "Token synced via hot reload (expires in ${REMAINING}h) — gateway NOT restarted, active sessions preserved"

package/scripts/release.sh

@@ -0,0 +1,98 @@
+#!/usr/bin/env bash
+# Usage: ./scripts/release.sh [patch|minor|major|X.Y.Z]
+#
+# Bumps version in pyproject.toml AND package.json, commits, tags, and pushes.
+# Pushing the tag triggers the publish workflow (PyPI + npm).
+#
+# IMPORTANT: pyproject.toml version MUST match the tag — the workflow enforces this.
+#
+# Examples:
+#   ./scripts/release.sh patch        # 0.6.2 → 0.6.3
+#   ./scripts/release.sh minor        # 0.6.2 → 0.7.0
+#   ./scripts/release.sh 1.0.0        # set explicit version
+
+set -euo pipefail
+
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+BUMP="${1:-patch}"
+
+# ── use existing bump_version.py for the actual bump ─────────────────────────
+
+BUMP_SCRIPT="$REPO_ROOT/scripts/bump_version.py"
+
+if [[ ! -f "$BUMP_SCRIPT" ]]; then
+    echo "ERROR: $BUMP_SCRIPT not found" >&2
+    exit 1
+fi
+
+# Dry-run first to show what will happen
+echo "Preview:"
+python3 "$BUMP_SCRIPT" "$BUMP" --pkg "$REPO_ROOT" --dry-run
+echo ""
+
+# Confirm
+read -rp "Proceed? [y/N] " confirm
+if [[ "$confirm" != "y" && "$confirm" != "Y" ]]; then
+    echo "Aborted."
+    exit 0
+fi
+
+# Get new version (run bump to get the number, without committing yet)
+NEW_VERSION=$(python3 -c "
+import re, sys
+sys.path.insert(0, '$REPO_ROOT/scripts')
+# Parse manually — same logic as bump_version.py
+text = open('$REPO_ROOT/pyproject.toml').read()
+m = re.search(r'^version\s*=\s*\"([^\"]+)\"', text, re.MULTILINE)
+current = m.group(1)
+part = '$BUMP'
+major, minor, patch = map(int, current.split('.'))
+if part == 'major':
+    print(f'{major+1}.0.0')
+elif part == 'minor':
+    print(f'{major}.{minor+1}.0')
+elif part == 'patch':
+    print(f'{major}.{minor}.{patch+1}')
+else:
+    parts = part.split('.')
+    if len(parts) != 3 or not all(p.isdigit() for p in parts):
+        raise ValueError(f'Invalid version: {part!r}')
+    print(part)
+")
+
+# Bump pyproject.toml and commit via bump_version.py
+python3 "$BUMP_SCRIPT" "$BUMP" --pkg "$REPO_ROOT"
+
+# Sync package.json to same version (workflow also does this, but keep file in sync)
+PACKAGE_JSON="$REPO_ROOT/package.json"
+python3 -c "
+import json
+with open('$PACKAGE_JSON') as f:
+    pkg = json.load(f)
+pkg['version'] = '$NEW_VERSION'
+with open('$PACKAGE_JSON', 'w') as f:
+    json.dump(pkg, f, indent=2)
+    f.write('\n')
+print(f'  Updated package.json to $NEW_VERSION')
+"
+
+cd "$REPO_ROOT"
+git add package.json
+git commit --amend --no-edit
+echo "  Amended commit to include package.json"
+
+TAG="v$NEW_VERSION"
+git tag -a "$TAG" -m "Release $TAG"
+echo "  Tagged: $TAG"
+
+echo ""
+echo "Pushing commit and tag to origin..."
+git push
+git push --tags
+
+echo ""
+echo "Done. GitHub Actions will now:"
+echo "  1. Run tests"
+echo "  2. Verify pyproject.toml version matches tag ($TAG)"
+echo "  3. Publish skcapstone $NEW_VERSION to PyPI"
+echo "  4. Publish @smilintux/skcapstone $NEW_VERSION to npm"

package/scripts/session-to-memory.py

@@ -0,0 +1,219 @@
+#!/usr/bin/env python3
+"""
+session-to-memory.py — Extract an OpenClaw session jsonl and save a digest to skmemory.
+
+Usage:
+  python3 session-to-memory.py <session.jsonl> [--agent lumina] [--dry-run]
+
+Called by archive-sessions.sh before archiving each session file.
+Also useful to run manually against any archived session.
+"""
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+import tempfile
+from datetime import datetime, timezone
+from pathlib import Path
+
+SKIP_PREFIXES = (
+    "[SKMemory",
+    "[System",
+    "[skmemory",
+    "--- SKMEMORY",
+    "--- SKWHISPER",
+)
+
+MAX_CONTENT_CHARS = 12000  # ~3k tokens — enough for a solid digest without blowing budget
+CLAUDE_MODEL = "claude-haiku-4-5"  # fast + cheap for digest work
+
+
+def extract_turns(path: Path) -> list[tuple[str, str]]:
+    """Parse a session jsonl and return real (role, text) turns, skipping injections."""
+    turns = []
+    with open(path, encoding="utf-8", errors="replace") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                obj = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+
+            if obj.get("type") != "message":
+                continue
+
+            # Handle both top-level message fields and nested .message
+            m = obj.get("message", obj)
+            role = m.get("role", "?")
+            content = m.get("content", "")
+
+            if isinstance(content, list):
+                text = " ".join(
+                    c.get("text", "")
+                    for c in content
+                    if isinstance(c, dict) and c.get("type") == "text"
+                )
+            else:
+                text = str(content)
+
+            text = text.strip()
+            if not text or len(text) < 5:
+                continue
+            if any(text.startswith(p) for p in SKIP_PREFIXES):
+                continue
+
+            turns.append((role, text))
+
+    return turns
+
+
+def turns_to_prompt(turns: list[tuple[str, str]], max_chars: int = MAX_CONTENT_CHARS) -> str:
+    """Format turns as a conversation snippet, truncated to max_chars."""
+    lines = []
+    for role, text in turns:
+        prefix = "Chef" if role == "user" else "Lumina"
+        lines.append(f"{prefix}: {text[:600]}")
+    full = "\n\n".join(lines)
+    if len(full) > max_chars:
+        full = full[:max_chars] + "\n\n[... truncated ...]"
+    return full
+
+
+def generate_digest(conversation: str, session_id: str) -> str:
+    """Use claude CLI to generate a session digest."""
+    prompt = f"""You are summarizing an OpenClaw AI agent session for the skmemory system.
+Session ID: {session_id}
+
+Conversation:
+{conversation}
+
+Write a concise session digest (3-6 sentences) covering:
+- Key topics discussed
+- Decisions made or actions taken
+- Any notable moments or outcomes
+
+Be specific. Use past tense. No preamble."""
+
+    try:
+        result = subprocess.run(
+            [
+                "claude", "--print",
+                "--dangerously-skip-permissions",
+                "--model", CLAUDE_MODEL,
+                "--output-format", "json",
+                "--no-session-persistence",
+            ],
+            input=prompt.encode(),
+            capture_output=True,
+            timeout=120,
+        )
+        if result.returncode != 0:
+            return f"[digest failed: {result.stderr.decode()[:200]}]"
+        parsed = json.loads(result.stdout.decode())
+        return parsed.get("result", "").strip()
+    except Exception as e:
+        return f"[digest error: {e}]"
+
+
+def save_to_skmemory(title: str, content: str, agent: str, tags: list[str]) -> bool:
+    """Save a memory snapshot via skmemory CLI."""
+    tag_str = ",".join(tags)
+    try:
+        result = subprocess.run(
+            [
+                "skmemory", "snapshot",
+                title, content,
+                "--layer", "mid-term",
+                "--tags", tag_str,
+            ],
+            capture_output=True,
+            timeout=30,
+            env={**os.environ, "SKAGENT": agent, "SKCAPSTONE_AGENT": agent},
+        )
+        if result.returncode != 0:
+            print(f"  [skmemory error] {result.stderr.decode()[:200]}", file=sys.stderr)
+            return False
+        return True
+    except Exception as e:
+        print(f"  [skmemory exception] {e}", file=sys.stderr)
+        return False
+
+
+def process_session(path: Path, agent: str = "lumina", dry_run: bool = False) -> bool:
+    session_id = path.stem[:8]
+
+    # Infer date from jsonl (first session entry)
+    session_date = None
+    try:
+        with open(path, encoding="utf-8", errors="replace") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                obj = json.loads(line)
+                if obj.get("type") == "session":
+                    ts = obj.get("timestamp", "")
+                    if ts:
+                        session_date = ts[:10]
+                    break
+    except Exception:
+        pass
+
+    turns = extract_turns(path)
+    if not turns:
+        print(f"  No usable turns in {path.name} — skipping.")
+        return False
+
+    print(f"  {len(turns)} turns extracted from {path.name}")
+
+    date_str = session_date or datetime.now(timezone.utc).strftime("%Y-%m-%d")
+    title = f"Session Digest — {date_str} ({session_id})"
+
+    if dry_run:
+        conv = turns_to_prompt(turns)
+        print(f"  [dry-run] Would save: {title}")
+        print(f"  Conversation preview ({len(conv)} chars):")
+        print(conv[:400])
+        return True
+
+    conversation = turns_to_prompt(turns)
+    print(f"  Generating digest via claude ({CLAUDE_MODEL})...")
+    digest = generate_digest(conversation, session_id)
+
+    if not digest or digest.startswith("[digest"):
+        print(f"  Digest generation failed: {digest}")
+        return False
+
+    content = f"**Session:** `{session_id}`  \n**Date:** {date_str}  \n**Turns:** {len(turns)}\n\n{digest}"
+    tags = ["auto-digest", "session-archive", f"session:{session_id}", f"agent:{agent}"]
+
+    print(f"  Saving memory: {title}")
+    ok = save_to_skmemory(title, content, agent, tags)
+    if ok:
+        print(f"  Saved to skmemory (mid-term).")
+    return ok
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Extract session to skmemory digest")
+    parser.add_argument("session_file", help="Path to session .jsonl file")
+    parser.add_argument("--agent", default="lumina", help="Agent name (default: lumina)")
+    parser.add_argument("--dry-run", action="store_true", help="Preview without saving")
+    args = parser.parse_args()
+
+    path = Path(args.session_file)
+    if not path.exists():
+        print(f"File not found: {path}", file=sys.stderr)
+        sys.exit(1)
+
+    print(f"Processing: {path.name}")
+    ok = process_session(path, agent=args.agent, dry_run=args.dry_run)
+    sys.exit(0 if ok else 1)
+
+
+if __name__ == "__main__":
+    main()