@hyperspell/openclaw-hyperspell 0.4.2 → 0.7.1

package/commands/setup.ts

@@ -1,41 +1,17 @@
-import { exec } from "node:child_process"
+import { execFileSync } from "node:child_process"
 import * as fs from "node:fs"
 import * as path from "node:path"
-import { homedir, platform, userInfo } from "node:os"
+import { userInfo } from "node:os"
 import * as p from "@clack/prompts"
 import type { Command } from "commander"
 import Hyperspell from "hyperspell"
 import { syncAllMemoryFiles, getMemoryFiles } from "../sync/markdown.ts"
+import { openInBrowser } from "../lib/browser.ts"
 import { HyperspellClient } from "../client.ts"
-import { getWorkspaceDir } from "../config.ts"
-
-/**
- * Resolve OpenClaw state directory, matching OpenClaw's logic.
- * Checks OPENCLAW_STATE_DIR env var, falls back to ~/.openclaw
- */
-function resolveStateDir(): string {
-  const override = process.env.OPENCLAW_STATE_DIR?.trim() || process.env.CLAWDBOT_STATE_DIR?.trim()
-  if (override) {
-    return override.startsWith("~")
-      ? override.replace(/^~(?=$|[\\/])/, homedir())
-      : path.resolve(override)
-  }
-  return path.join(homedir(), ".openclaw")
-}
-
-/**
- * Resolve OpenClaw config path, matching OpenClaw's logic.
- * Checks OPENCLAW_CONFIG_PATH env var, falls back to $STATE_DIR/openclaw.json
- */
-function resolveConfigPath(): string {
-  const override = process.env.OPENCLAW_CONFIG_PATH?.trim() || process.env.CLAWDBOT_CONFIG_PATH?.trim()
-  if (override) {
-    return override.startsWith("~")
-      ? override.replace(/^~(?=$|[\\/])/, homedir())
-      : path.resolve(override)
-  }
-  return path.join(resolveStateDir(), "openclaw.json")
-}
+import { getWorkspaceDir, parseConfig, resolveConfigPath } from "../config.ts"
+import { buildExtractionPrompt, CRON_JOB_NAME } from "../graph/cron.ts"
+import { NetworkStateManager } from "../graph/state.ts"
+import { scanMemories, formatScanResults, completeMemories } from "../graph/ops.ts"
 
 async function fetchConnectionSources(client: Hyperspell, userId: string): Promise<string[]> {
   try {
@@ -66,26 +42,6 @@ function updateConfigSources(configPath: string, sources: string[]): void {
   }
 }
 
-function openUrl(url: string): Promise<void> {
-  return new Promise((resolve, reject) => {
-    let command: string
-    switch (platform()) {
-      case "darwin":
-        command = `open "${url}"`
-        break
-      case "win32":
-        command = `start "" "${url}"`
-        break
-      default:
-        command = `xdg-open "${url}"`
-    }
-    exec(command, (error) => {
-      if (error) reject(error)
-      else resolve()
-    })
-  })
-}
-
 async function runSetup(): Promise<void> {
   p.intro("Hyperspell Setup")
 
@@ -117,7 +73,7 @@ async function runSetup(): Promise<void> {
     }
 
     if (openSignup) {
-      await openUrl("https://app.hyperspell.com")
+      await openInBrowser("https://app.hyperspell.com")
       p.log.info("Browser opened. Come back when you've created your account.")
     }
 
@@ -226,7 +182,7 @@ async function runSetup(): Promise<void> {
       })
 
       if (!p.isCancel(openConnect) && openConnect) {
-        await openUrl(connectUrl)
+        await openInBrowser(connectUrl)
         p.log.info("Browser opened. Connect your accounts and come back when done.")
 
         await p.confirm({
@@ -379,7 +335,9 @@ async function runSetup(): Promise<void> {
         syncMemories: true,
         sources: [],
         maxResults: 10,
+        relevanceThreshold: 0.6,
         debug: false,
+        knowledgeGraph: { enabled: false, scanIntervalMinutes: 60, batchSize: 20 },
       })
 
       const result = await syncAllMemoryFiles(hyperspellClient, workspaceDir)
@@ -397,18 +355,129 @@ async function runSetup(): Promise<void> {
     }
   }
 
+  // Step 8: Memory Network setup
+  p.note(
+    "The Memory Network automatically extracts entities (people, projects,\n" +
+      "organizations, topics) from your memories into structured markdown\n" +
+      "files. This runs as a periodic cron job in the main session.",
+    "Memory Network",
+  )
+
+  const enableNetwork = await p.confirm({
+    message: "Enable the Memory Network?",
+    initialValue: false,
+  })
+
+  if (!p.isCancel(enableNetwork) && enableNetwork) {
+    // Update config to enable knowledgeGraph
+    try {
+      const configPath = resolveConfigPath()
+      if (fs.existsSync(configPath)) {
+        const configContent = fs.readFileSync(configPath, "utf-8")
+        const config = JSON.parse(configContent)
+        const pluginEntry = config?.plugins?.entries?.["openclaw-hyperspell"]?.config
+        if (pluginEntry) {
+          pluginEntry.knowledgeGraph = { enabled: true }
+          fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n")
+        }
+      }
+      p.log.success("Memory Network enabled in config")
+    } catch {
+      p.log.warn("Could not update config — add knowledgeGraph.enabled: true manually")
+    }
+
+    // Write the extraction prompt to a file and create the cron job
+    const networkWorkspaceDir = getWorkspaceDir()
+    const promptPath = path.join(networkWorkspaceDir, "HYPERSPELL-MEMORY-NETWORK.md")
+    const prompt = buildExtractionPrompt(networkWorkspaceDir)
+    fs.mkdirSync(path.dirname(promptPath), { recursive: true })
+    fs.writeFileSync(promptPath, prompt)
+
+    const s4 = p.spinner()
+    s4.start("Creating Memory Network cron job")
+
+    let cronJobId: string | null = null
+    try {
+      const output = execFileSync("openclaw", [
+        "cron", "add",
+        "--name", CRON_JOB_NAME,
+        "--every", "1h",
+        "--session", "isolated",
+        "--message", `Read the file at ${promptPath} and follow the instructions inside it.`,
+      ], { stdio: ["pipe", "pipe", "pipe"], timeout: 10_000 })
+
+      // Extract job ID from the JSON output
+      const text = output.toString().trim()
+      // Find the JSON object in the output (skip any non-JSON prefix lines)
+      const jsonStart = text.indexOf("{")
+      if (jsonStart >= 0) {
+        try {
+          const job = JSON.parse(text.slice(jsonStart))
+          cronJobId = job?.id || null
+        } catch {}
+      }
+
+      s4.stop("Cron job created — Memory Network will scan every hour")
+    } catch (cronErr) {
+      s4.stop("Could not create cron job automatically")
+
+      p.log.warn(`Cron creation failed. Create it manually:`)
+
+      p.note(
+        `openclaw cron add \\\n` +
+          `  --name "${CRON_JOB_NAME}" \\\n` +
+          `  --every 1h \\\n` +
+          `  --session isolated \\\n` +
+          `  --message "Read the file at ${promptPath} and follow the instructions inside it."`,
+        "Manual cron setup",
+      )
+    }
+
+    // Ask if they want to run the first extraction now
+    const runNow = await p.confirm({
+      message: "Run the Memory Network now? (If not, it will run automatically on the next cron cycle)",
+      initialValue: true,
+    })
+
+    if (!p.isCancel(runNow) && runNow) {
+      if (cronJobId) {
+        const s5 = p.spinner()
+        s5.start("Triggering Memory Network extraction")
+
+        try {
+          execFileSync("openclaw", [
+            "cron", "run", cronJobId,
+          ], { stdio: "pipe", timeout: 10_000 })
+
+          s5.stop("Memory Network extraction triggered — running in the background")
+        } catch {
+          s5.stop("Could not trigger automatically")
+          p.log.info(`You can trigger it manually with: openclaw cron run ${cronJobId}`)
+        }
+      } else {
+        p.log.info("Create the cron job first, then run it with: openclaw cron run <job-id>")
+      }
+    }
+  }
+
   const syncNote = syncMemories
     ? "\n\nMemory sync is enabled — markdown files in memory/ will be\n" +
       "automatically synced to Hyperspell when they change."
     : ""
 
+  const networkNote = !p.isCancel(enableNetwork) && enableNetwork
+    ? "\n\nMemory Network is enabled — entities will be extracted into\n" +
+      "memory/people/, memory/projects/, memory/organizations/, memory/topics/"
+    : ""
+
   p.note(
     "/getcontext <query>  Search your memories for relevant context\n" +
       "/remember <text>     Save something directly to your vault\n\n" +
       "To connect more apps, run: openclaw openclaw-hyperspell connect\n\n" +
       "Auto-context is enabled by default — relevant memories are\n" +
       "automatically injected before each AI response." +
-      syncNote,
+      syncNote +
+      networkNote,
     "How to use Hyperspell",
   )
 
@@ -440,7 +509,7 @@ async function runConnect(pluginConfig: unknown): Promise<void> {
 
     s.stop("Connect URL ready")
 
-    await openUrl(connectUrl)
+    await openInBrowser(connectUrl)
     p.log.success("Browser opened to connect.hyperspell.com")
 
     await p.confirm({
@@ -533,4 +602,70 @@ export function registerCliCommands(program: Command, pluginConfig: unknown): vo
     .action(async () => {
       await runConnect(pluginConfig)
     })
+
+  // Memory Network CLI commands (used by isolated cron sessions via exec)
+  const networkCmd = hyperspellCmd
+    .command("network")
+    .description("Memory Network operations")
+
+  networkCmd
+    .command("scan")
+    .description("Scan for unprocessed memories and output summaries")
+    .option("--batch-size <n>", "Max memories to return", "20")
+    .action(async (opts) => {
+      try {
+        const cfg = parseConfig(pluginConfig)
+        const client = new HyperspellClient(cfg)
+        const workspaceDir = getWorkspaceDir()
+        const stateManager = new NetworkStateManager(workspaceDir)
+        const batchSize = Number.parseInt(opts.batchSize, 10) || 20
+
+        const memories = await scanMemories(client, stateManager, batchSize)
+        const text = formatScanResults(memories, stateManager.getProcessedCount(), stateManager.getLastScanAt())
+        process.stdout.write(text + "\n")
+      } catch (err) {
+        process.stderr.write(`Scan failed: ${err instanceof Error ? err.message : String(err)}\n`)
+        process.exit(1)
+      }
+    })
+
+  networkCmd
+    .command("complete")
+    .description("Mark memory IDs as processed")
+    .requiredOption("--ids <ids>", "Comma-separated resource_ids")
+    .action((opts) => {
+      try {
+        const workspaceDir = getWorkspaceDir()
+        const stateManager = new NetworkStateManager(workspaceDir)
+        const memoryIds = (opts.ids as string).split(",").map((s: string) => s.trim()).filter(Boolean)
+
+        const { newCount, totalCount } = completeMemories(stateManager, memoryIds)
+        process.stdout.write(`Marked ${newCount} new memories as processed (${totalCount} total)\n`)
+      } catch (err) {
+        process.stderr.write(`Complete failed: ${err instanceof Error ? err.message : String(err)}\n`)
+        process.exit(1)
+      }
+    })
+
+  networkCmd
+    .command("sync")
+    .description("Sync entity files in memory/ to Hyperspell")
+    .action(async () => {
+      try {
+        const cfg = parseConfig(pluginConfig)
+        const client = new HyperspellClient(cfg)
+        const workspaceDir = getWorkspaceDir()
+
+        const result = await syncAllMemoryFiles(client, workspaceDir)
+        process.stdout.write(`Synced ${result.synced} files, ${result.failed} failed\n`)
+        if (result.errors.length > 0) {
+          for (const error of result.errors) {
+            process.stderr.write(`  ${error}\n`)
+          }
+        }
+      } catch (err) {
+        process.stderr.write(`Sync failed: ${err instanceof Error ? err.message : String(err)}\n`)
+        process.exit(1)
+      }
+    })
 }

package/commands/wine.ts

@@ -0,0 +1,164 @@
+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)}`,
+        }
+      }
+    },
+  })
+}