@hyperspell/openclaw-hyperspell 0.11.1 → 0.13.0

package/tools/search.ts

@@ -1,131 +0,0 @@
-import { Type } from "@sinclair/typebox"
-import type { HyperspellClient } from "../client.ts"
-import type { CanReadScope, HyperspellConfig } from "../config.ts"
-import { buildScopeFilter, getCanReadScopes, resolveUser } from "../lib/sender.ts"
-import { log } from "../logger.ts"
-
-export function createSearchToolFactory(
-  client: HyperspellClient,
-  cfg: HyperspellConfig,
-) {
-  const scopingEnabled = !!cfg.multiUser?.scoping
-  const availableScopes = cfg.multiUser?.scoping?.scopes ?? []
-  const scopeDescription = scopingEnabled
-    ? `Narrow search to a single privacy scope. Available: ${availableScopes.join(", ")}. Omit to search all scopes visible to the caller's role.`
-    : "Privacy scope (only used when scoping is enabled in config)."
-
-  return (ctx: Record<string, unknown>) => ({
-    name: "hyperspell_search",
-    label: "Memory Search",
-    description:
-      "Search through the user's connected sources (Notion, Slack, Gmail, Google Drive, etc.) for relevant information.",
-    parameters: Type.Object({
-      query: Type.String({ description: "Search query" }),
-      limit: Type.Optional(
-        Type.Number({ description: "Max results (default: 5)" }),
-      ),
-      after: Type.Optional(
-        Type.String({ description: "Only return memories created on or after this date (ISO 8601 or YYYY-MM-DD)" }),
-      ),
-      before: Type.Optional(
-        Type.String({ description: "Only return memories created before this date (ISO 8601 or YYYY-MM-DD)" }),
-      ),
-      userId: Type.Optional(
-        Type.String({
-          description:
-            "Search as a specific user (e.g. 'ben', 'shared'). Omit to search as current sender.",
-        }),
-      ),
-      scope: Type.Optional(Type.String({ description: scopeDescription })),
-    }),
-    async execute(
-      _toolCallId: string,
-      params: {
-        query: string
-        limit?: number
-        after?: string
-        before?: string
-        userId?: string
-        scope?: string
-      },
-    ) {
-      const limit = params.limit ?? 5
-      const resolved = resolveUser(ctx, cfg)
-      const userId = params.userId ?? resolved?.userId
-
-      // Build scope filter: intersect requested scope (if any) with caller's canRead
-      let filter: Record<string, unknown> | undefined
-      if (scopingEnabled) {
-        const canRead = getCanReadScopes(resolved, cfg)
-        const allowed: CanReadScope[] = params.scope
-          ? canRead.includes("*")
-            ? [params.scope]
-            : canRead.includes(params.scope)
-              ? [params.scope]
-              : [] // requested scope not allowed → match nothing
-          : canRead
-        filter = buildScopeFilter(allowed, resolved?.userId ?? "")
-      }
-
-      log.debug(
-        `search tool: query="${params.query}" limit=${limit} after=${params.after ?? "none"} before=${params.before ?? "none"} userId=${userId} scope=${params.scope ?? "any"}`,
-      )
-
-      try {
-        const response = await client.searchRaw(params.query, {
-          limit,
-          after: params.after,
-          before: params.before,
-          userId,
-          filter,
-        })
-        const documents = (response.documents ?? []) as Array<{
-          source: string
-          resource_id: string
-          score?: number
-          summary?: string
-          title?: string
-          metadata?: Record<string, unknown>
-          highlights?: Array<{ text: string }>
-          data?: Array<{ text: string }>
-        }>
-
-        if (documents.length === 0) {
-          return {
-            content: [
-              { type: "text" as const, text: "No relevant memories found." },
-            ],
-          }
-        }
-
-        const formattedDocs = documents
-          .map((doc, i) => {
-            const relevance = doc.score
-              ? `${Math.round(doc.score * 100)}%`
-              : "N/A"
-            const title = doc.title || "(untitled)"
-            const summary = doc.summary || "(no summary)"
-            return `${i + 1}. Source: ${doc.source}\n   Title: ${title}\n   Summary: ${summary}\n   Relevance: ${relevance}`
-          })
-          .join("\n\n")
-
-        const text = `Found ${documents.length} memories:\n\n${formattedDocs}`
-
-        return {
-          content: [{ type: "text" as const, text }],
-          details: { count: documents.length, documents },
-        }
-      } catch (err) {
-        log.error("search tool failed", err)
-        return {
-          content: [
-            {
-              type: "text" as const,
-              text: `Search failed: ${err instanceof Error ? err.message : String(err)}`,
-            },
-          ],
-        }
-      }
-    },
-  })
-}

package/types/openclaw.d.ts

@@ -1,76 +0,0 @@
-declare module "openclaw/plugin-sdk" {
-  import type { Command } from "commander"
-
-  export interface OpenClawPluginCliContext {
-    program: Command
-    config: unknown
-    workspaceDir?: string
-    logger: {
-      info: (message: string, ...args: unknown[]) => void
-      warn: (message: string, ...args: unknown[]) => void
-      error: (message: string, ...args: unknown[]) => void
-      debug: (message: string, ...args: unknown[]) => void
-    }
-  }
-
-  export type OpenClawPluginCliRegistrar = (ctx: OpenClawPluginCliContext) => void | Promise<void>
-
-  export interface OpenClawPluginApi {
-    pluginConfig: unknown
-    workspaceDir?: string
-    logger: {
-      info: (message: string, ...args: unknown[]) => void
-      warn: (message: string, ...args: unknown[]) => void
-      error: (message: string, ...args: unknown[]) => void
-      debug: (message: string, ...args: unknown[]) => void
-    }
-    registerCommand(options: {
-      name: string
-      description: string
-      acceptsArgs: boolean
-      requireAuth: boolean
-      handler: (ctx: { args?: string; senderId?: string; channel?: string }) => Promise<{ text: string }>
-    }): void
-    registerCli(registrar: OpenClawPluginCliRegistrar, opts?: { commands?: string[] }): void
-    registerTool<T = unknown>(
-      options: {
-        name: string
-        label: string
-        description: string
-        parameters: unknown
-        execute: (
-          toolCallId: string,
-          params: T,
-        ) => Promise<{
-          content: Array<{ type: "text"; text: string }>
-          details?: Record<string, unknown>
-        }>
-      },
-      meta: { name: string },
-    ): void
-    registerTool<T = unknown>(
-      factory: (ctx: Record<string, unknown>) => {
-        name: string
-        label: string
-        description: string
-        parameters: unknown
-        execute: (
-          toolCallId: string,
-          params: T,
-        ) => Promise<{
-          content: Array<{ type: "text"; text: string }>
-          details?: Record<string, unknown>
-        }>
-      },
-      meta: { name: string },
-    ): void
-    on(event: string, handler: (event: Record<string, unknown>, ctx?: Record<string, unknown>) => Promise<{ prependContext?: string } | void> | void): void
-    registerService(options: {
-      id: string
-      start: () => void
-      stop: () => void
-    }): void
-  }
-
-  export function stringEnum<T extends string>(values: readonly T[]): unknown
-}