@dn-inc/openclaw-seahorse 0.1.0 → 0.2.0

package/README.md

@@ -3,9 +3,16 @@
 Drop-in replacement for OpenClaw's built-in memory search, powered by [Seahorse](https://seahorse.dnotitia.ai).
 
 - Uploads local memory files (`MEMORY.md`, `memory/**/*.md`) to Seahorse Storage
+- Optionally syncs the entire workspace for full semantic search over all files
 - Routes `memory_search` to Seahorse's vector search API
 - Keeps `memory_get` reading from local files (same as native)
 
+## Requirements
+
+- Node.js 20+
+- OpenClaw >= 2026.1.26
+- Seahorse account (Storage + Table tenants)
+
 ## Quick Start (Zero Config)
 
 1. Install the plugin:
@@ -16,29 +23,21 @@ openclaw plugins install @dn-inc/openclaw-seahorse
 
 2. Get your Storage URL, Table URL, and API key from the [Seahorse console](https://seahorse.dnotitia.ai), then add to `plugins.entries` in `openclaw.json`:
 
-```json
+```jsonc
 "openclaw-seahorse": {
   "config": {
     "storageUrl": "https://<your-storage-id>.api.seahorse.dnotitia.ai",
     "tableUrl": "https://<your-table-id>.api.seahorse.dnotitia.ai",
-    "apiKey": "your-key-here"
+    "apiKey": "your-key-here",
+    // Optional: search your entire workspace, not just memory files
+    "syncWorkspace": true
   }
 }
 ```
 
 If you prefer not to store the key in config, you can set the `SEAHORSE_API_KEY` environment variable instead. The `apiKey` field also supports `${ENV_VAR}` syntax (e.g., `"${SEAHORSE_API_KEY}"`).
 
-That's it. With zero additional config, the plugin behaves identically to OpenClaw's built-in memory search:
-
-- **Hybrid search** (dense 70% + sparse 30%)
-- **6 results** per query
-- **0.35 minimum score** threshold
-
-## Requirements
-
-- Node.js 20+
-- OpenClaw >= 2026.1.26
-- Seahorse account (Storage + Table tenants)
+That's it. The plugin auto-syncs your files on startup and watches for changes in real time. With zero additional config, search behaves identically to OpenClaw's built-in memory search.
 
 ## Config Reference
 
@@ -50,7 +49,7 @@ That's it. With zero additional config, the plugin behaves identically to OpenCl
 | `tableUrl` | string | Yes | Seahorse Table tenant URL |
 | `apiKey` | string | No | API key. Auto-reads from `SEAHORSE_API_KEY` env var if omitted. Also supports `${ENV_VAR}` syntax. |
 
-### Layer 1: Search Behavior (optional)
+### Layer 1: Search & Sync Behavior (optional)
 
 These override the OpenClaw-compatible defaults.
 
@@ -59,6 +58,8 @@ These override the OpenClaw-compatible defaults.
 | `topK` | number | `6` | Number of results to return |
 | `minScore` | number | `0.35` | Minimum relevance score (0-1) |
 | `searchMode` | string | `"hybrid"` | `"dense"`, `"sparse"`, or `"hybrid"` |
+| `syncWorkspace` | boolean | `false` | Sync entire workspace (not just memory files) |
+| `syncBlacklist` | string[] | `[]` | Additional blacklist patterns for workspace sync (see [File Sync](#file-sync)) |
 
 Example — return more results with a lower score threshold:
 
@@ -146,7 +147,7 @@ The plugin ships with OpenClaw-compatible defaults so it works as a drop-in repl
 
 ### `memory_search`
 
-Semantic vector search over memory files via Seahorse.
+Semantic vector search over synced files via Seahorse.
 
 | Parameter | Type | Required | Description |
 |-----------|------|----------|-------------|
@@ -174,7 +175,28 @@ All memory files are stored under the `openclaw/` prefix in Seahorse Storage (e.
 
 The plugin runs a background service (`seahorse-sync`) that keeps Seahorse Storage in sync:
 
-- **Initial sync**: scans existing memory files on startup, uploads only changed files
+- **Initial sync**: scans files on startup, uploads only changed files
 - **Live watch**: detects file create/modify/delete via `fs.watch` (1.5s debounce)
 - **Dedup**: mtime-based state tracking prevents redundant uploads
 - **Delete sync**: local file deletion triggers Seahorse Storage deletion
+
+By default, only memory files (`MEMORY.md` + `memory/**/*.md`) are synced. Set `syncWorkspace: true` to sync the entire workspace — all files become searchable via `memory_search` without any tool or API changes.
+
+When workspace sync is enabled, dotfiles/dotdirs (`.*`) are always excluded. Add further patterns via `syncBlacklist`:
+
+```json
+{
+  "storageUrl": "...", "tableUrl": "...", "apiKey": "...",
+  "syncWorkspace": true,
+  "syncBlacklist": ["node_modules/", "dist/", "*.log", "*.tmp"]
+}
+```
+
+Supported blacklist patterns:
+
+| Pattern | Example | Matches |
+|---------|---------|---------|
+| `"dir/"` | `"node_modules/"` | Directory with that exact name |
+| `"*.ext"` | `"*.tmp"` | Any segment ending with `.tmp` |
+| `"prefix*"` | `".*"` | Any segment starting with `.` (built-in) |
+| `"name"` | `"Thumbs.db"` | Exact filename in any directory |

package/index.ts

@@ -37,6 +37,12 @@ const plugin: OpenClawPluginDefinition = {
       const rawSparse = (rawConfig.sparse ?? {}) as Record<string, unknown>;
       const rawFusion = (rawConfig.fusion ?? {}) as Record<string, unknown>;
 
+      const syncWorkspace = rawConfig.syncWorkspace === true;
+      const rawBlacklist = rawConfig.syncBlacklist;
+      const syncBlacklist: string[] = Array.isArray(rawBlacklist)
+        ? rawBlacklist.filter((item): item is string => typeof item === "string")
+        : [];
+
       config = {
         storageUrl: resolveEnvVars(String(rawConfig.storageUrl ?? "")),
         tableUrl: resolveEnvVars(String(rawConfig.tableUrl ?? "")),
@@ -59,6 +65,8 @@ const plugin: OpenClawPluginDefinition = {
           ...(rawFusion.k != null && { k: parsePositiveNumber(rawFusion.k, "fusion.k") }),
         },
         projection: String(rawConfig.projection ?? DEFAULTS.projection),
+        syncWorkspace,
+        syncBlacklist,
       };
     } catch (err: unknown) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -87,7 +95,7 @@ const plugin: OpenClawPluginDefinition = {
 
     registerMemorySearchTool(api, config, client);
     registerMemoryGetTool(api);
-    registerSyncService(api, client);
+    registerSyncService(api, client, config);
 
     api.logger.info("[openclaw-seahorse] Plugin registered (memory_search, memory_get, sync service).");
   },

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dn-inc/openclaw-seahorse",
   "type": "module",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Seahorse memory plugin for OpenClaw",
   "license": "MIT",
   "main": "./index.ts",

package/src/helpers.ts

@@ -103,6 +103,83 @@ export function parseUnitInterval(raw: unknown, name: string): number | undefine
   return n;
 }
 
+/**
+ * Check whether a POSIX relative path matches any blacklist pattern.
+ * Each pattern is tested against every segment (directory or file name) of the path:
+ *   - `"dir/"` — directory exact match (segment equals name without trailing slash)
+ *   - `"*.ext"` — suffix wildcard (segment ends with ext portion)
+ *   - `"prefix*"` — prefix wildcard (segment starts with prefix portion)
+ *   - `"name"` — exact match (segment equals pattern exactly)
+ */
+export function isBlacklisted(relPath: string, blacklist: readonly string[]): boolean {
+  if (blacklist.length === 0) return false;
+  const segments = relPath.split("/");
+  for (const pattern of blacklist) {
+    if (pattern.endsWith("/")) {
+      // Directory exact match — match any directory segment
+      const dirName = pattern.slice(0, -1);
+      // All segments except the last are directories
+      for (let i = 0; i < segments.length - 1; i++) {
+        if (segments[i] === dirName) return true;
+      }
+    } else if (pattern.startsWith("*")) {
+      // Suffix wildcard — match any segment ending with the suffix
+      const suffix = pattern.slice(1);
+      for (const seg of segments) {
+        if (seg.endsWith(suffix)) return true;
+      }
+    } else if (pattern.endsWith("*")) {
+      // Prefix wildcard — match any segment starting with the prefix
+      const prefix = pattern.slice(0, -1);
+      for (const seg of segments) {
+        if (seg.startsWith(prefix)) return true;
+      }
+    } else {
+      // Exact name match — match any segment
+      for (const seg of segments) {
+        if (seg === pattern) return true;
+      }
+    }
+  }
+  return false;
+}
+
+/**
+ * Recursively find all files in a workspace directory, excluding blacklisted paths.
+ * Blacklisted directories are not entered (efficient pruning).
+ */
+export async function findWorkspaceFiles(
+  workspaceDir: string,
+  blacklist: readonly string[],
+): Promise<string[]> {
+  const files: string[] = [];
+  await collectAllFiles(workspaceDir, "", blacklist, files);
+  return files;
+}
+
+/** Recursively collect files, skipping blacklisted entries. */
+async function collectAllFiles(
+  absDir: string,
+  relDir: string,
+  blacklist: readonly string[],
+  out: string[],
+): Promise<void> {
+  const entries = await fs.readdir(absDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const relPath = relDir ? toPosixPath(path.join(relDir, entry.name)) : entry.name;
+    if (entry.isDirectory()) {
+      // Construct a fake child path so directory patterns ("dir/") are checked
+      // against this directory name appearing as a non-last segment.
+      if (isBlacklisted(relPath + "/_", blacklist)) continue;
+      await collectAllFiles(path.join(absDir, entry.name), relPath, blacklist, out);
+    } else if (entry.isFile()) {
+      if (!isBlacklisted(relPath, blacklist)) {
+        out.push(relPath);
+      }
+    }
+  }
+}
+
 /** Check whether a resolved absolute path is within the allowed memory directories. */
 export function isAllowedMemoryPath(resolvedPath: string, workspaceDir: string): boolean {
   const normalizedWorkspace = path.resolve(workspaceDir);

package/src/service.ts

@@ -3,8 +3,10 @@ import { watch, type FSWatcher } from "node:fs";
 import * as path from "node:path";
 import type { OpenClawPluginApi, OpenClawPluginServiceContext } from "openclaw/plugin-sdk";
 import type { SeahorseClient } from "./client.js";
+import type { SeahorseConfig } from "./types.js";
+import { DEFAULT_BLACKLIST } from "./types.js";
 import { SyncState } from "./sync-state.js";
-import { sanitizeError, findMemoryFiles, isAllowedMemoryPath, toPosixPath } from "./helpers.js";
+import { sanitizeError, findMemoryFiles, findWorkspaceFiles, isAllowedMemoryPath, isBlacklisted, toPosixPath } from "./helpers.js";
 
 const DEBOUNCE_MS = 1500;
 
@@ -14,6 +16,7 @@ const DEBOUNCE_MS = 1500;
 export function registerSyncService(
   api: OpenClawPluginApi,
   client: SeahorseClient,
+  config: SeahorseConfig,
 ): void {
   let watchers: FSWatcher[] = [];
   let syncState: SyncState;
@@ -35,15 +38,19 @@ export function registerSyncService(
       await syncState.load();
 
       const memoryDir = path.join(workspaceDir, "memory");
+      const mergedBlacklist = [...DEFAULT_BLACKLIST, ...config.syncBlacklist];
+      const findFiles = config.syncWorkspace
+        ? () => findWorkspaceFiles(workspaceDir, mergedBlacklist)
+        : () => findMemoryFiles(workspaceDir);
 
-      // Scan and upload memory files that need syncing
-      const syncMemoryFiles = async (label: string): Promise<number> => {
+      // Scan and upload files that need syncing
+      const syncFiles = async (label: string): Promise<number> => {
         let files: string[];
         try {
-          files = await findMemoryFiles(workspaceDir);
+          files = await findFiles();
         } catch (err: unknown) {
           logger.warn(
-            `[openclaw-seahorse] Error scanning memory files (${label}): ${sanitizeError(err)}`,
+            `[openclaw-seahorse] Error scanning files (${label}): ${sanitizeError(err)}`,
           );
           return 0;
         }
@@ -79,7 +86,7 @@ export function registerSyncService(
       };
 
       // Initial sync
-      const fileCount = await syncMemoryFiles("initial");
+      const fileCount = await syncFiles("initial");
       logger.info(
         `[openclaw-seahorse] Initial sync complete. ${fileCount} file(s) checked.`,
       );
@@ -87,9 +94,11 @@ export function registerSyncService(
       abortController = new AbortController();
 
       const processFileEvent = (relPath: string) => {
-        const absCheck = path.resolve(workspaceDir, relPath);
-        if (!isAllowedMemoryPath(absCheck, workspaceDir)) {
-          return;
+        if (config.syncWorkspace) {
+          if (isBlacklisted(relPath, mergedBlacklist)) return;
+        } else {
+          const absCheck = path.resolve(workspaceDir, relPath);
+          if (!isAllowedMemoryPath(absCheck, workspaceDir)) return;
         }
 
         logger.debug?.(`[openclaw-seahorse] File event: ${relPath} (debounce ${DEBOUNCE_MS}ms)`);
@@ -141,89 +150,111 @@ export function registerSyncService(
         );
       };
 
-      const setupMemoryDirWatcher = (): void => {
+      if (config.syncWorkspace) {
+        // Workspace mode: single recursive watcher on the workspace root
         try {
-          const memWatcher = watch(
-            memoryDir,
+          const wsWatcher = watch(
+            workspaceDir,
             { recursive: true, signal: abortController.signal },
             (_eventType, filename) => {
               if (!filename) return;
-              const normalized = filename.replace(/\\/g, "/");
-              if (!normalized.endsWith(".md")) return;
-              const relPath = toPosixPath(path.join("memory", normalized));
+              const relPath = toPosixPath(filename);
               processFileEvent(relPath);
             },
           );
-          watchers.push(memWatcher);
-          logger.info("[openclaw-seahorse] Watching memory/ directory.");
+          watchers.push(wsWatcher);
+          logger.info("[openclaw-seahorse] Watching workspace directory (recursive).");
         } catch (err: unknown) {
           logger.warn(
-            `[openclaw-seahorse] Could not watch memory/ directory: ${sanitizeError(err)}`,
+            `[openclaw-seahorse] Could not watch workspace directory: ${sanitizeError(err)}`,
           );
         }
-      };
+      } else {
+        // Memory-only mode: root watcher + lazy memory/ watcher
+        const setupMemoryDirWatcher = (): void => {
+          try {
+            const memWatcher = watch(
+              memoryDir,
+              { recursive: true, signal: abortController.signal },
+              (_eventType, filename) => {
+                if (!filename) return;
+                const normalized = filename.replace(/\\/g, "/");
+                if (!normalized.endsWith(".md")) return;
+                const relPath = toPosixPath(path.join("memory", normalized));
+                processFileEvent(relPath);
+              },
+            );
+            watchers.push(memWatcher);
+            logger.info("[openclaw-seahorse] Watching memory/ directory.");
+          } catch (err: unknown) {
+            logger.warn(
+              `[openclaw-seahorse] Could not watch memory/ directory: ${sanitizeError(err)}`,
+            );
+          }
+        };
 
-      // Watch workspace root for MEMORY.md changes and memory/ directory creation
-      let memoryDirWatcherSet = false;
-      try {
-        const rootWatcher = watch(
-          workspaceDir,
-          { signal: abortController.signal },
-          (eventType, filename) => {
-            if (filename === "MEMORY.md") {
-              processFileEvent("MEMORY.md");
-            }
-            // Detect memory/ directory creation
-            if (!memoryDirWatcherSet && filename === "memory" && eventType === "rename") {
-              memoryDirWatcherSet = true;
-              const op = (async () => {
-                try {
-                  const dirStat = await fs.stat(memoryDir);
-                  if (!dirStat.isDirectory()) {
+        // Watch workspace root for MEMORY.md changes and memory/ directory creation
+        let memoryDirWatcherSet = false;
+        try {
+          const rootWatcher = watch(
+            workspaceDir,
+            { signal: abortController.signal },
+            (eventType, filename) => {
+              if (filename === "MEMORY.md") {
+                processFileEvent("MEMORY.md");
+              }
+              // Detect memory/ directory creation
+              if (!memoryDirWatcherSet && filename === "memory" && eventType === "rename") {
+                memoryDirWatcherSet = true;
+                const op = (async () => {
+                  try {
+                    const dirStat = await fs.stat(memoryDir);
+                    if (!dirStat.isDirectory()) {
+                      memoryDirWatcherSet = false;
+                      return;
+                    }
+                    setupMemoryDirWatcher();
+                    // Catch-up sync: upload files written before/during watcher setup
+                    const count = await syncFiles("catch-up");
+                    if (count > 0) {
+                      logger.info(
+                        `[openclaw-seahorse] Catch-up sync complete. ${count} file(s) checked.`,
+                      );
+                    }
+                  } catch (err: unknown) {
                     memoryDirWatcherSet = false;
-                    return;
-                  }
-                  setupMemoryDirWatcher();
-                  // Catch-up sync: upload files written before/during watcher setup
-                  const count = await syncMemoryFiles("catch-up");
-                  if (count > 0) {
-                    logger.info(
-                      `[openclaw-seahorse] Catch-up sync complete. ${count} file(s) checked.`,
+                    logger.warn(
+                      `[openclaw-seahorse] Catch-up sync error: ${sanitizeError(err)}`,
                     );
                   }
-                } catch (err: unknown) {
-                  memoryDirWatcherSet = false;
-                  logger.warn(
-                    `[openclaw-seahorse] Catch-up sync error: ${sanitizeError(err)}`,
-                  );
-                }
-              })();
-              trackOp(op);
-            }
-          },
-        );
-        watchers.push(rootWatcher);
-      } catch (err: unknown) {
-        logger.warn(
-          `[openclaw-seahorse] Could not watch workspace root: ${sanitizeError(err)}`,
-        );
-      }
-
-      // Watch memory/ directory if it already exists
-      try {
-        await fs.access(memoryDir);
-        memoryDirWatcherSet = true;
-        setupMemoryDirWatcher();
-      } catch (err: unknown) {
-        if ((err as NodeJS.ErrnoException).code === "ENOENT") {
-          logger.info(
-            "[openclaw-seahorse] memory/ directory does not exist yet. Will start watching when created.",
+                })();
+                trackOp(op);
+              }
+            },
           );
-        } else {
+          watchers.push(rootWatcher);
+        } catch (err: unknown) {
           logger.warn(
-            `[openclaw-seahorse] Could not access memory/ directory: ${sanitizeError(err)}`,
+            `[openclaw-seahorse] Could not watch workspace root: ${sanitizeError(err)}`,
           );
         }
+
+        // Watch memory/ directory if it already exists
+        try {
+          await fs.access(memoryDir);
+          memoryDirWatcherSet = true;
+          setupMemoryDirWatcher();
+        } catch (err: unknown) {
+          if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+            logger.info(
+              "[openclaw-seahorse] memory/ directory does not exist yet. Will start watching when created.",
+            );
+          } else {
+            logger.warn(
+              `[openclaw-seahorse] Could not access memory/ directory: ${sanitizeError(err)}`,
+            );
+          }
+        }
       }
     },
 

package/src/types.ts

@@ -35,8 +35,13 @@ export const DEFAULTS = {
   sparse: { column: "sparse_vector" },
   fusion: { type: "rrf", alpha: 0.7 },
   projection: "id, text, metadata, distance, score",
+  syncWorkspace: false,
+  syncBlacklist: [] as string[],
 } as const;
 
+/** Default blacklist patterns applied when syncWorkspace is enabled. */
+export const DEFAULT_BLACKLIST: readonly string[] = [".*"] as const;
+
 /** Seahorse RRF default k parameter (server default). */
 export const RRF_DEFAULT_K = 60;
 
@@ -55,6 +60,8 @@ export interface SeahorseConfig {
   sparse: SparseConfig;
   fusion: FusionConfig;
   projection: string;
+  syncWorkspace: boolean;
+  syncBlacklist: string[];
 }
 
 /** Parsed search result from Seahorse */