@hyperspell/openclaw-hyperspell 0.7.1 → 0.8.0

package/README.md

@@ -193,70 +193,6 @@ Enable the graph tools by using `hyperspell_network_scan`, `hyperspell_network_w
 
 ---
 
-## SommeliAgent 🍷
-
-> *"Your playlist says more about your palate than you'd like to admit, darling."*
-> — A Linea, Hyperspell's hidden sommelier
-
-An opinionated AI sommelier living inside your memory plugin. She reads your Spotify listening habits, judges them (affectionately), and recommends wines that match the person your music says you are — not the person you think you are.
-
-215 wines. 26 countries. Zero tolerance for boring recommendations.
-
-**Requires:** `uv` ([install](https://docs.astral.sh/uv/))
-
-### Setup
-
-1. Create a Spotify app at https://developer.spotify.com/dashboard (redirect URI: `http://localhost:8888/callback`)
-2. Set environment variables: `SPOTIFY_CLIENT_ID` and `SPOTIFY_CLIENT_SECRET`
-3. Authenticate: `/wine-auth`
-
-Or skip all that and try demo mode: `/wine demo`
-
-### Slash Commands
-
-#### `/wine [options]`
-
-Get wine recommendations. Options can be combined:
-
-```
-/wine                    — recommendations from your Spotify
-/wine demo               — use demo profile (no Spotify needed)
-/wine red premium        — only red wines, premium price range
-/wine white 5            — 5 white wine recommendations
-/wine demo profile       — show full music-to-wine mapping
-```
-
-#### `/wine-auth`
-
-Connect your Spotify account.
-
-#### `/wine-rate <wine-id> <1-5> [notes]`
-
-Rate a recommendation to improve future suggestions.
-
-```
-/wine-rate red-it-001 5 "Incredible tannins, paired perfectly with my Radiohead phase"
-```
-
-#### `/wine-history`
-
-View your rating history and derived taste preferences.
-
-### AI Tools
-
-The plugin also registers tools the AI can use autonomously:
-
-- **hyperspell_sommelier** - Get wine recommendations (with full personality instructions)
-- **hyperspell_sommelier_rate** - Rate wines
-
-### How It Works
-
-Your Spotify audio features (energy, valence, complexity, acousticness, tempo) are mapped to wine dimensions (body, sweetness, tannin, acidity, complexity, fruitiness, earthiness, spiciness). The cross-domain mapping is entertainment-first — the comedy comes from a sharp, opinionated sommelier voice diagnosing your personality through your questionable music taste.
-
-The sommelier is A Linea — she lives inside Hyperspell and has strong opinions about both your playlist and your palate. She chose Alexander McQueen as her fashion house, so expect the wine recommendations to have a similar aesthetic: beautiful, a little dark, and never boring.
-
-See `sommeliagent/references/cross-domain-mappings.md` for the full methodology. 🖤
-
 ## Troubleshooting
 
 ### "No relevant memories found"

package/index.ts

@@ -1,7 +1,6 @@
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk"
 import { HyperspellClient } from "./client.ts"
 import { registerCommands } from "./commands/slash.ts"
-import { registerWineCommands } from "./commands/wine.ts"
 import { registerCliCommands } from "./commands/setup.ts"
 import { parseConfig, hyperspellConfigSchema, getWorkspaceDir } from "./config.ts"
 import { buildAutoContextHandler } from "./hooks/auto-context.ts"
@@ -10,7 +9,6 @@ import { buildFileSyncHandler, syncMemoriesOnStartup } from "./hooks/memory-sync
 import { initLogger } from "./logger.ts"
 import { registerRememberTool } from "./tools/remember.ts"
 import { registerSearchTool } from "./tools/search.ts"
-import { registerSommelierTool, registerSommelierRateTool } from "./tools/sommelier.ts"
 import { registerNetworkTools } from "./graph/index.ts"
 
 export default {
@@ -34,11 +32,6 @@ export default {
 		const rawConfig = api.pluginConfig as Record<string, unknown> | undefined;
 		const hasConfig = rawConfig?.apiKey || process.env.HYPERSPELL_API_KEY;
 
-		// SommeliAgent works independently of Hyperspell config — it just needs uv + Spotify
-		registerSommelierTool(api)
-		registerSommelierRateTool(api)
-		registerWineCommands(api)
-
 		if (!hasConfig) {
 			api.logger.info(
 				"hyperspell: not configured - run 'openclaw openclaw-hyperspell setup'",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperspell/openclaw-hyperspell",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "type": "module",
   "description": "OpenClaw Hyperspell memory plugin",
   "license": "MIT",
@@ -14,13 +14,12 @@
     "graph/",
     "lib/",
     "types/",
-    "sommeliagent/",
     "openclaw.plugin.json",
     "README.md"
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/hyperspell/openclaw-hyperspell.git"
+    "url": "git+https://github.com/hyperspell/hyperspell-openclaw.git"
   },
   "keywords": [
     "openclaw",
@@ -28,9 +27,7 @@
     "memory",
     "rag",
     "ai",
-    "plugin",
-    "sommelier",
-    "wine"
+    "plugin"
   ],
   "dependencies": {
     "@clack/prompts": "^1.0.0",
@@ -48,7 +45,8 @@
   "openclaw": {
     "extensions": [
       "./index.ts"
-    ]
+    ],
+    "hooks": []
   },
   "devDependencies": {
     "typescript": "^5.9.3"

package/commands/wine.ts

@@ -1,164 +0,0 @@
-import { execFile } from "node:child_process"
-import { access, constants } from "node:fs/promises"
-import { join } from "node:path"
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk"
-import { log } from "../logger.ts"
-import { runScript, SCRIPTS_DIR } from "../lib/run-script.ts"
-
-function parseWineArgs(argsStr: string): string[] {
-  const args: string[] = []
-  const parts = argsStr.trim().split(/\s+/)
-
-  for (let i = 0; i < parts.length; i++) {
-    const part = parts[i].toLowerCase()
-    if (["red", "white", "rose", "orange", "sparkling", "dessert"].includes(part)) {
-      args.push("--color", part)
-    } else if (["budget", "mid", "premium", "luxury"].includes(part)) {
-      args.push("--price", part)
-    } else if (part === "demo") {
-      args.push("--demo")
-    } else if (part === "profile") {
-      args.push("--profile")
-    } else if (/^\d+$/.test(part)) {
-      args.push("--count", String(Math.min(Number.parseInt(part), 10)))
-    }
-  }
-
-  return args
-}
-
-export function registerWineCommands(api: OpenClawPluginApi): void {
-  // /wine [color] [price] [count] [demo] [profile]
-  api.registerCommand({
-    name: "wine",
-    description: "Get wine recommendations based on your Spotify listening habits",
-    acceptsArgs: true,
-    requireAuth: false,
-    handler: async (ctx: { args?: string }) => {
-      log.debug(`/wine command: "${ctx.args || ""}"`)
-
-      // Check uv
-      try {
-        await new Promise<void>((resolve, reject) => {
-          execFile("uv", ["--version"], { timeout: 5_000 }, (err) => {
-            if (err) reject(err)
-            else resolve()
-          })
-        })
-      } catch {
-        return { text: "SommeliAgent needs `uv` installed. Run: brew install uv" }
-      }
-
-      const userArgs = ctx.args?.trim() || ""
-      const scriptArgs = parseWineArgs(userArgs)
-      const isDemo = scriptArgs.includes("--demo")
-
-      // Check Spotify auth (unless demo mode)
-      if (!isDemo) {
-        const tokenPath = join(
-          process.env.HOME || process.env.USERPROFILE || "",
-          ".sommeliagent",
-          "token.json",
-        )
-        try {
-          await access(tokenPath, constants.R_OK)
-        } catch {
-          return {
-            text: `Spotify not connected. Set up:\n1. Create app at https://developer.spotify.com/dashboard\n2. Set SPOTIFY_CLIENT_ID and SPOTIFY_CLIENT_SECRET\n3. Run: uv run ${join(SCRIPTS_DIR, "auth.py")}\n\nOr try: /wine demo`,
-          }
-        }
-      }
-
-      try {
-        const { stdout, stderr } = await runScript("recommend.py", scriptArgs)
-
-        if (stderr) {
-          log.debug(`/wine stderr: ${stderr}`)
-        }
-
-        return { text: stdout }
-      } catch (err) {
-        log.error("/wine failed", err)
-        return {
-          text: `SommeliAgent failed: ${err instanceof Error ? err.message : String(err)}\n\nTry: /wine demo`,
-        }
-      }
-    },
-  })
-
-  // /wine-auth - Run Spotify OAuth
-  api.registerCommand({
-    name: "wine-auth",
-    description: "Connect your Spotify account for wine recommendations",
-    acceptsArgs: false,
-    requireAuth: false,
-    handler: async () => {
-      log.debug("/wine-auth command")
-
-      try {
-        const { stdout } = await runScript("auth.py", [], 180_000)
-        return { text: stdout }
-      } catch (err) {
-        log.error("/wine-auth failed", err)
-        return {
-          text: `Spotify auth failed: ${err instanceof Error ? err.message : String(err)}\n\nMake sure SPOTIFY_CLIENT_ID and SPOTIFY_CLIENT_SECRET are set.`,
-        }
-      }
-    },
-  })
-
-  // /wine-rate <wine-id> <1-5> [notes]
-  api.registerCommand({
-    name: "wine-rate",
-    description: "Rate a wine recommendation (improves future suggestions)",
-    acceptsArgs: true,
-    requireAuth: false,
-    handler: async (ctx: { args?: string }) => {
-      const parts = ctx.args?.trim().split(/\s+/) || []
-      if (parts.length < 2) {
-        return { text: 'Usage: /wine-rate <wine-id> <1-5> [notes]\nExample: /wine-rate red-it-001 5 "Incredible tannins"' }
-      }
-
-      const wineId = parts[0]
-      const rating = Number.parseInt(parts[1])
-      if (Number.isNaN(rating) || rating < 1 || rating > 5) {
-        return { text: "Rating must be 1-5." }
-      }
-
-      const notes = parts.slice(2).join(" ")
-      const args = ["--wine-id", wineId, "--rating", String(rating)]
-      if (notes) args.push("--notes", notes)
-
-      try {
-        const { stdout } = await runScript("rate.py", args)
-        return { text: stdout }
-      } catch (err) {
-        log.error("/wine-rate failed", err)
-        return {
-          text: `Failed to rate: ${err instanceof Error ? err.message : String(err)}`,
-        }
-      }
-    },
-  })
-
-  // /wine-history - Show past ratings
-  api.registerCommand({
-    name: "wine-history",
-    description: "View your wine rating history and taste profile",
-    acceptsArgs: false,
-    requireAuth: false,
-    handler: async () => {
-      log.debug("/wine-history command")
-
-      try {
-        const { stdout } = await runScript("history.py", [])
-        return { text: stdout }
-      } catch (err) {
-        log.error("/wine-history failed", err)
-        return {
-          text: `Failed to load history: ${err instanceof Error ? err.message : String(err)}`,
-        }
-      }
-    },
-  })
-}

package/lib/run-script.ts

@@ -1,32 +0,0 @@
-import { execFile } from "node:child_process"
-import { dirname, join } from "node:path"
-import { fileURLToPath } from "node:url"
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
-export const SCRIPTS_DIR = join(__dirname, "..", "sommeliagent", "scripts")
-
-const ALLOWED_SCRIPTS = new Set(["recommend.py", "rate.py", "auth.py", "history.py"])
-
-export function runScript(
-  scriptName: string,
-  args: string[],
-  timeout: number = 30_000,
-): Promise<{ stdout: string; stderr: string }> {
-  if (!ALLOWED_SCRIPTS.has(scriptName)) {
-    return Promise.reject(new Error(`Unknown script: ${scriptName}`))
-  }
-  return new Promise((resolve, reject) => {
-    execFile(
-      "uv",
-      ["run", join(SCRIPTS_DIR, scriptName), ...args],
-      { timeout, maxBuffer: 1024 * 512 },
-      (error, stdout, stderr) => {
-        if (error) {
-          reject(new Error(`${scriptName} failed: ${stderr || error.message}`))
-        } else {
-          resolve({ stdout, stderr })
-        }
-      },
-    )
-  })
-}

package/sommeliagent/references/cross-domain-mappings.md

@@ -1,63 +0,0 @@
-# Cross-Domain Mapping: Music → Wine
-
-The core thesis: sensory and aesthetic preferences transfer across domains. Someone who seeks complexity in music seeks complexity in wine. Someone drawn to dark, brooding sounds wants wines with tension and structure, not crowd-pleasers.
-
-## Music → Wine Dimension Map
-
-| Music Signal | Wine Dimension | Logic |
-|---|---|---|
-| Tempo / energy | Body / weight | High energy → bold, full-bodied; ambient → light, delicate |
-| Complexity (jazz, prog, classical) | Complexity (terroir-driven, natural wines) | Listeners who tolerate/seek complexity want wines that challenge |
-| Valence (happy vs dark) | Sweetness / dryness spectrum | Bright pop → approachable, off-dry; minor key → dry, tannic, austere |
-| Acoustic vs electronic | Old World vs New World | Organic, analog sound → traditional winemaking; synthetic → modern, tech-forward wines |
-| Obscurity / niche taste | Obscurity of region/varietal | Niche listeners don't want grocery store Cab Sav |
-| Repetition tolerance | Familiarity preference | Loop-heavy listeners → reliable house pours; variety seekers → discovery |
-| Lyrical depth | Label story / terroir narrative | People who care about lyrics care about provenance |
-
-## Mapping Algorithm
-
-### Step 1: Music Profile Aggregation
-
-From Spotify's audio features API, we aggregate across a user's top 50 tracks:
-- **avgValence** (0-1): musical positiveness
-- **avgEnergy** (0-1): intensity and activity
-- **avgDanceability** (0-1): dance suitability
-- **avgAcousticness** (0-1): acoustic vs electronic
-- **avgTempo** (BPM): normalized to 0-1 range (/200)
-- **avgComplexity** (derived): instrumentalness × 0.3 + time signature variety × 0.3 + (1 - danceability) × 0.4
-- **obscurityScore** (derived): 1 - (average track popularity / 100)
-
-### Step 2: Wine Dimension Translation
-
-Each wine dimension is a weighted average of music features:
-
-**Body** = energy × 0.5 + tempo × 0.3 + (1 - acousticness) × 0.2
-**Sweetness** = valence × 0.6 + danceability × 0.3 + (1 - complexity) × 0.1
-**Tannin** = (1 - valence) × 0.4 + complexity × 0.3 + energy × 0.3
-**Acidity** = complexity × 0.4 + (1 - valence) × 0.3 + obscurity × 0.3
-**Complexity** = complexity × 0.5 + obscurity × 0.3 + (1 - danceability) × 0.2
-**Fruitiness** = valence × 0.5 + energy × 0.3 + (1 - complexity) × 0.2
-**Earthiness** = acousticness × 0.4 + complexity × 0.3 + obscurity × 0.3
-**Spiciness** = energy × 0.4 + (1 - valence) × 0.3 + complexity × 0.3
-
-### Step 3: Wine Scoring
-
-Each wine in the database has a profile with the same 8 dimensions. Match score = weighted cosine similarity between target profile and wine profile.
-
-Weights: body (1.5), sweetness (1.2), complexity (1.5), tannin (1.0), acidity (1.0), fruitiness (0.8), earthiness (0.8), spiciness (0.7).
-
-### Step 4: Connection Generation
-
-For each recommended wine, the system identifies which specific music-wine connections are strongest and generates explanations.
-
-## Expansion Signals (Future)
-
-- **Reading history** → intellectual complexity tolerance
-- **Food delivery** → direct cuisine/region pairing data
-- **Time of day / mood** → contextual recommendations
-- **Weather + location** → seasonal suggestions
-- **Instagram aesthetic** → visual preference → label/winemaking philosophy
-
-## Philosophy
-
-The signal doesn't need to be scientifically rigorous. This is entertainment that gets smarter. The delight is in the explanation, not the accuracy. The feedback loop (ratings) quietly builds a genuine cross-domain taste database over time.

package/sommeliagent/scripts/auth.py

@@ -1,222 +0,0 @@
-# /// script
-# requires-python = ">=3.11"
-# dependencies = ["httpx"]
-# ///
-"""
-Spotify OAuth flow for SommeliAgent.
-Opens browser, runs local callback server, saves token.
-"""
-
-import html
-import http.server
-import json
-import os
-import secrets
-import stat
-import sys
-import threading
-import urllib.parse
-import webbrowser
-from pathlib import Path
-
-import httpx
-
-CONFIG_DIR = Path.home() / ".sommeliagent"
-TOKEN_FILE = CONFIG_DIR / "token.json"
-REDIRECT_URI = "http://localhost:8888/callback"
-SCOPES = "user-top-read user-read-recently-played"
-
-
-def get_credentials() -> tuple[str, str]:
-    client_id = os.environ.get("SPOTIFY_CLIENT_ID", "")
-    client_secret = os.environ.get("SPOTIFY_CLIENT_SECRET", "")
-    if not client_id or not client_secret:
-        print("Error: SPOTIFY_CLIENT_ID and SPOTIFY_CLIENT_SECRET must be set.", file=sys.stderr)
-        print("Get them from https://developer.spotify.com/dashboard", file=sys.stderr)
-        sys.exit(1)
-    return client_id, client_secret
-
-
-def save_token(token_data: dict) -> None:
-    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
-    tmp = TOKEN_FILE.with_suffix(".tmp")
-    tmp.write_text(json.dumps(token_data, indent=2))
-    tmp.chmod(stat.S_IRUSR | stat.S_IWUSR)  # 600 — owner only
-    tmp.replace(TOKEN_FILE)
-    print(f"Token saved to {TOKEN_FILE}")
-
-
-def load_token() -> dict | None:
-    if TOKEN_FILE.exists():
-        return json.loads(TOKEN_FILE.read_text())
-    return None
-
-
-def refresh_access_token(refresh_token: str, client_id: str, client_secret: str) -> dict:
-    resp = httpx.post(
-        "https://accounts.spotify.com/api/token",
-        data={
-            "grant_type": "refresh_token",
-            "refresh_token": refresh_token,
-            "client_id": client_id,
-            "client_secret": client_secret,
-        },
-    )
-    resp.raise_for_status()
-    data = resp.json()
-    if "refresh_token" not in data:
-        data["refresh_token"] = refresh_token
-    return data
-
-
-def get_access_token() -> str | None:
-    """Get a valid access token, refreshing if needed. Returns None if unavailable."""
-    import time as _time
-
-    token_data = load_token()
-
-    if token_data and "refresh_token" in token_data:
-        # Return existing token if it hasn't expired yet
-        expires_at = token_data.get("expires_at", 0)
-        if expires_at and _time.time() < expires_at and token_data.get("access_token"):
-            return token_data["access_token"]
-
-        # Need to refresh — now we need credentials
-        client_id, client_secret = get_credentials()
-        try:
-            refreshed = refresh_access_token(
-                token_data["refresh_token"], client_id, client_secret
-            )
-            expires_in = refreshed.get("expires_in", 3600)
-            refreshed["expires_at"] = _time.time() + expires_in
-            save_token(refreshed)
-            return refreshed["access_token"]
-        except Exception as e:
-            print(f"Token refresh failed: {e}", file=sys.stderr)
-
-    return None
-
-
-def _make_callback_handler(expected_state: str):
-    """Create a callback handler that validates the OAuth state parameter."""
-
-    class CallbackHandler(http.server.BaseHTTPRequestHandler):
-        auth_code: str | None = None
-        error: str | None = None
-
-        def do_GET(self):
-            query = urllib.parse.urlparse(self.path).query
-            params = urllib.parse.parse_qs(query)
-
-            # Validate state to prevent CSRF
-            received_state = params.get("state", [None])[0]
-            if received_state != expected_state:
-                self.send_response(400)
-                self.send_header("Content-Type", "text/html")
-                self.end_headers()
-                self.wfile.write(b"<html><body><h1>Invalid state parameter</h1></body></html>")
-                return
-
-            if "code" in params:
-                CallbackHandler.auth_code = params["code"][0]
-                self.send_response(200)
-                self.send_header("Content-Type", "text/html")
-                self.end_headers()
-                self.wfile.write(
-                    b"<html><body><h1>SommeliAgent connected!</h1>"
-                    b"<p>You can close this tab and return to your terminal.</p></body></html>"
-                )
-            elif "error" in params:
-                CallbackHandler.error = params["error"][0]
-                self.send_response(400)
-                self.send_header("Content-Type", "text/html")
-                self.end_headers()
-                safe_error = html.escape(params["error"][0])
-                self.wfile.write(f"<html><body><h1>Error: {safe_error}</h1></body></html>".encode())
-            else:
-                self.send_response(400)
-                self.end_headers()
-
-        def log_message(self, format, *args):
-            pass
-
-    return CallbackHandler
-
-
-def run_oauth_flow() -> None:
-    client_id, client_secret = get_credentials()
-    state = secrets.token_urlsafe(16)
-
-    auth_url = (
-        "https://accounts.spotify.com/authorize?"
-        + urllib.parse.urlencode(
-            {
-                "response_type": "code",
-                "client_id": client_id,
-                "scope": SCOPES,
-                "redirect_uri": REDIRECT_URI,
-                "state": state,
-            }
-        )
-    )
-
-    handler_class = _make_callback_handler(state)
-
-    try:
-        server = http.server.HTTPServer(("localhost", 8888), handler_class)
-    except OSError as e:
-        print(f"Error: Could not start callback server on port 8888: {e}", file=sys.stderr)
-        print("Make sure nothing else is using that port.", file=sys.stderr)
-        sys.exit(1)
-
-    # Handle up to 3 requests (in case of preflight/favicon/etc hitting first)
-    def serve():
-        for _ in range(3):
-            server.handle_request()
-            if handler_class.auth_code or handler_class.error:
-                break
-
-    server_thread = threading.Thread(target=serve, daemon=True)
-    server_thread.start()
-
-    print("Opening Spotify authorization in your browser...")
-    print(f"If it doesn't open, visit: {auth_url}")
-    webbrowser.open(auth_url)
-
-    server_thread.join(timeout=120)
-    server.server_close()
-
-    if handler_class.error:
-        print(f"Error: Spotify returned: {handler_class.error}", file=sys.stderr)
-        sys.exit(1)
-
-    if not handler_class.auth_code:
-        print("Error: No authorization code received (timed out after 120s).", file=sys.stderr)
-        sys.exit(1)
-
-    # Exchange code for token
-    resp = httpx.post(
-        "https://accounts.spotify.com/api/token",
-        data={
-            "grant_type": "authorization_code",
-            "code": handler_class.auth_code,
-            "redirect_uri": REDIRECT_URI,
-            "client_id": client_id,
-            "client_secret": client_secret,
-        },
-    )
-    resp.raise_for_status()
-    token_data = resp.json()
-    import time as _time
-    token_data["expires_at"] = _time.time() + token_data.get("expires_in", 3600)
-    save_token(token_data)
-    print("Spotify connected successfully!")
-
-
-if __name__ == "__main__":
-    token = get_access_token()
-    if token:
-        print("Already authenticated. Token refreshed successfully.")
-        print(f"Token file: {TOKEN_FILE}")
-    else:
-        run_oauth_flow()