@hyperspell/openclaw-hyperspell 0.11.1 → 0.13.0

package/commands/slash.ts

@@ -1,198 +0,0 @@
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk"
-import type { HyperspellClient } from "../client.ts"
-import type { CanReadScope, HyperspellConfig } from "../config.ts"
-import { getWorkspaceDir } from "../config.ts"
-import {
-  buildScopeFilter,
-  getCanReadScopes,
-  getDefaultWriteScope,
-  resolveRole,
-  resolveUser,
-  routeWrite,
-} from "../lib/sender.ts"
-import { log } from "../logger.ts"
-import { syncAllMemoryFiles } from "../sync/markdown.ts"
-
-/**
- * Strip a `#scope-name` prefix from free text. Returns the scope and the
- * remainder. Used by /remember and /getcontext to let users narrow or route
- * via a single keystroke.
- */
-function parseScopePrefix(text: string): { scope?: string; rest: string } {
-  const m = text.match(/^#(\S+)\s+(.*)$/)
-  if (!m) return { rest: text }
-  return { scope: m[1], rest: m[2] }
-}
-
-function truncate(text: string, maxLength: number): string {
-  if (text.length <= maxLength) return text
-  return `${text.slice(0, maxLength)}…`
-}
-
-function formatScore(score: number | null): string {
-  if (score === null) return ""
-  return ` (${Math.round(score * 100)}%)`
-}
-
-export function registerCommands(
-  api: OpenClawPluginApi,
-  client: HyperspellClient,
-  cfg: HyperspellConfig,
-): void {
-  // /getcontext <query> - Search memories and show summaries
-  api.registerCommand({
-    name: "getcontext",
-    description: "Search your memories for relevant context",
-    acceptsArgs: true,
-    requireAuth: true,
-    handler: async (ctx: { args?: string; senderId?: string; channel?: string }) => {
-      const rawArgs = ctx.args?.trim()
-      if (!rawArgs) {
-        return { text: "Usage: /getcontext [#scope] <search query>" }
-      }
-      const { scope: requestedScope, rest: query } = parseScopePrefix(rawArgs)
-
-      const resolved = resolveUser(ctx as Record<string, unknown>, cfg)
-      const userId = resolved?.userId
-
-      // Build scope filter: intersect requested scope (if any) with caller's canRead.
-      let filter: Record<string, unknown> | undefined
-      if (cfg.multiUser?.scoping) {
-        const canRead = getCanReadScopes(resolved, cfg)
-        const allowed: CanReadScope[] = requestedScope
-          ? canRead.includes("*") || canRead.includes(requestedScope)
-            ? [requestedScope]
-            : []
-          : canRead
-        filter = buildScopeFilter(allowed, resolved?.userId ?? "")
-      }
-
-      log.debug(
-        `/getcontext command: "${query}" userId=${userId} scope=${requestedScope ?? "any"}`,
-      )
-
-      try {
-        const results = await client.search(query, { limit: 5, userId, filter })
-
-        if (results.length === 0) {
-          return { text: `No memories found for: "${query}"` }
-        }
-
-        const lines = results.map((r, i) => {
-          const title = r.title ? truncate(r.title, 60) : `[${r.source}]`
-          const score = formatScore(r.score)
-          return `${i + 1}. ${title}${score}`
-        })
-
-        return {
-          text: `Found ${results.length} memories:\n\n${lines.join("\n")}`,
-        }
-      } catch (err) {
-        log.error("/getcontext failed", err)
-        return { text: "Failed to search memories. Check logs for details." }
-      }
-    },
-  })
-
-  // /remember <text> - Add a new memory
-  api.registerCommand({
-    name: "remember",
-    description: "Save something to memory",
-    acceptsArgs: true,
-    requireAuth: true,
-    handler: async (ctx: { args?: string; senderId?: string; channel?: string }) => {
-      const rawArgs = ctx.args?.trim()
-      if (!rawArgs) {
-        return { text: "Usage: /remember [#scope] <text to remember>" }
-      }
-      const { scope: requestedScope, rest: text } = parseScopePrefix(rawArgs)
-
-      const resolved = resolveUser(ctx as Record<string, unknown>, cfg)
-      const scopingEnabled = !!cfg.multiUser?.scoping
-      const availableScopes = cfg.multiUser?.scoping?.scopes ?? []
-
-      // Scope resolution: prefix > role default > global default > "private"
-      const scope = scopingEnabled
-        ? (requestedScope ?? getDefaultWriteScope(resolved, cfg))
-        : "private"
-
-      // Validate scope is in declared vocabulary
-      if (
-        scopingEnabled &&
-        requestedScope &&
-        availableScopes.length > 0 &&
-        !availableScopes.includes(scope)
-      ) {
-        return {
-          text: `Unknown scope "${scope}". Available: ${availableScopes.join(", ")}.`,
-        }
-      }
-
-      // canWriteScopes enforcement
-      if (scopingEnabled) {
-        const role = resolveRole(resolved, cfg)
-        if (role?.canWriteScopes && !role.canWriteScopes.includes(scope)) {
-          return { text: `You cannot write to scope "${scope}".` }
-        }
-      }
-
-      const { userId, collection } = scopingEnabled
-        ? routeWrite(resolved, scope, cfg)
-        : { userId: resolved?.userId, collection: undefined }
-
-      log.debug(
-        `/remember command: "${truncate(text, 50)}" userId=${userId} scope=${scope}`,
-      )
-
-      try {
-        await client.addMemory(text, {
-          metadata: { source: "openclaw_command" },
-          collection,
-          userId,
-          scope: scopingEnabled ? scope : undefined,
-        })
-
-        const preview = truncate(text, 60)
-        const scopeHint = scopingEnabled ? ` [${scope}]` : ""
-        return { text: `Remembered${scopeHint}: "${preview}"` }
-      } catch (err) {
-        log.error("/remember failed", err)
-        return { text: "Failed to save memory. Check logs for details." }
-      }
-    },
-  })
-
-  // /sync - Manually sync memory files
-  api.registerCommand({
-    name: "sync",
-    description: "Sync memory/*.md files with Hyperspell",
-    acceptsArgs: false,
-    requireAuth: true,
-    handler: async () => {
-      log.debug("/sync command")
-
-      try {
-        const workspaceDir = getWorkspaceDir()
-        const result = await syncAllMemoryFiles(client, workspaceDir, {
-          userId: cfg.multiUser?.sharedUserId,
-        })
-
-        if (result.synced === 0 && result.failed === 0) {
-          return { text: "No memory files found in memory/ directory." }
-        }
-
-        if (result.failed > 0) {
-          const errors = result.errors.map((e) => `  • ${e}`).join("\n")
-          return {
-            text: `Synced ${result.synced} files, ${result.failed} failed:\n${errors}`,
-          }
-        }
-
-        return { text: `Synced ${result.synced} memory file(s) to Hyperspell.` }
-      } catch (err) {
-        log.error("/sync failed", err)
-        return { text: "Failed to sync memory files. Check logs for details." }
-      }
-    },
-  })
-}

package/config.test.ts

@@ -1,202 +0,0 @@
-import assert from "node:assert/strict"
-import { test } from "node:test"
-import { parseConfig } from "./config.ts"
-
-const base = {
-  apiKey: "test-key",
-  userId: "u1",
-}
-
-test("parseConfig — no multiUser returns no scoping", () => {
-  const cfg = parseConfig(base)
-  assert.equal(cfg.multiUser, undefined)
-})
-
-test("parseConfig — multiUser without scoping is valid", () => {
-  const cfg = parseConfig({
-    ...base,
-    multiUser: {
-      senderMap: { "u1-phone": { userId: "u1", name: "U1" } },
-      sharedUserId: "shared",
-    },
-  })
-  assert.equal(cfg.multiUser?.scoping, undefined)
-  assert.equal(cfg.multiUser?.sharedUserId, "shared")
-})
-
-test("parseConfig — scoping disabled returns no scoping", () => {
-  const cfg = parseConfig({
-    ...base,
-    multiUser: {
-      senderMap: { "u1-phone": { userId: "u1", name: "U1" } },
-      scoping: {
-        enabled: false,
-        defaultScope: "private",
-        scopes: ["private"],
-        roles: {},
-        users: {},
-      },
-    },
-  })
-  assert.equal(cfg.multiUser?.scoping, undefined)
-})
-
-test("parseConfig — empty scopes array throws", () => {
-  assert.throws(
-    () =>
-      parseConfig({
-        ...base,
-        multiUser: {
-          senderMap: { "u1-phone": { userId: "u1", name: "U1" } },
-          scoping: {
-            enabled: true,
-            defaultScope: "private",
-            scopes: [],
-            roles: {},
-            users: {},
-          },
-        },
-      }),
-    /scoping\.scopes/,
-  )
-})
-
-test("parseConfig — defaultScope not in scopes throws", () => {
-  assert.throws(
-    () =>
-      parseConfig({
-        ...base,
-        multiUser: {
-          senderMap: { "u1-phone": { userId: "u1", name: "U1" } },
-          scoping: {
-            enabled: true,
-            defaultScope: "nonexistent",
-            scopes: ["private", "family"],
-            roles: {},
-            users: {},
-          },
-        },
-      }),
-    /defaultScope/,
-  )
-})
-
-test("parseConfig — role canRead with unknown scope throws", () => {
-  assert.throws(
-    () =>
-      parseConfig({
-        ...base,
-        multiUser: {
-          senderMap: { "u1-phone": { userId: "u1", name: "U1" } },
-          scoping: {
-            enabled: true,
-            defaultScope: "private",
-            scopes: ["private", "family"],
-            roles: {
-              weird: { canRead: ["private", "ghost"], defaultWriteScope: "private" },
-            },
-            users: {},
-          },
-        },
-      }),
-    /canRead.*ghost/,
-  )
-})
-
-test("parseConfig — role defaultWriteScope not in scopes throws", () => {
-  assert.throws(
-    () =>
-      parseConfig({
-        ...base,
-        multiUser: {
-          senderMap: { "u1-phone": { userId: "u1", name: "U1" } },
-          scoping: {
-            enabled: true,
-            defaultScope: "private",
-            scopes: ["private", "family"],
-            roles: {
-              weird: { canRead: ["family"], defaultWriteScope: "nonexistent" },
-            },
-            users: {},
-          },
-        },
-      }),
-    /defaultWriteScope/,
-  )
-})
-
-test("parseConfig — canWriteScopes with unknown scope throws", () => {
-  assert.throws(
-    () =>
-      parseConfig({
-        ...base,
-        multiUser: {
-          senderMap: { "u1-phone": { userId: "u1", name: "U1" } },
-          scoping: {
-            enabled: true,
-            defaultScope: "private",
-            scopes: ["private", "family"],
-            roles: {
-              weird: {
-                canRead: ["*"],
-                defaultWriteScope: "private",
-                canWriteScopes: ["ghost"],
-              },
-            },
-            users: {},
-          },
-        },
-      }),
-    /canWriteScopes.*ghost/,
-  )
-})
-
-test("parseConfig — user role keying into unknown role throws", () => {
-  assert.throws(
-    () =>
-      parseConfig({
-        ...base,
-        multiUser: {
-          senderMap: { "u1-phone": { userId: "u1", name: "U1" } },
-          scoping: {
-            enabled: true,
-            defaultScope: "private",
-            scopes: ["private", "family"],
-            roles: {
-              parent: { canRead: ["*"], defaultWriteScope: "private" },
-            },
-            users: { u1: { role: "nonexistent" } },
-          },
-        },
-      }),
-    /does not key into scoping\.roles/,
-  )
-})
-
-test("parseConfig — valid scoping parses", () => {
-  const cfg = parseConfig({
-    ...base,
-    multiUser: {
-      senderMap: { "u1-phone": { userId: "u1", name: "U1" } },
-      scoping: {
-        enabled: true,
-        defaultScope: "private",
-        scopes: ["private", "family", "parent_only"],
-        roles: {
-          parent: { canRead: ["*"], defaultWriteScope: "private" },
-          kid: { canRead: ["family"], defaultWriteScope: "family" },
-        },
-        users: {
-          u1: { role: "parent" },
-        },
-        collections: { family: "household" },
-        voiceId: { enabled: true, confidenceThreshold: 0.8 },
-      },
-    },
-  })
-  assert.equal(cfg.multiUser?.scoping?.enabled, true)
-  assert.deepEqual(cfg.multiUser?.scoping?.scopes, ["private", "family", "parent_only"])
-  assert.equal(cfg.multiUser?.scoping?.roles.parent?.defaultWriteScope, "private")
-  assert.equal(cfg.multiUser?.scoping?.collections?.family, "household")
-  assert.equal(cfg.multiUser?.scoping?.voiceId?.confidenceThreshold, 0.8)
-})