@karmaniverous/jeeves-watcher-openclaw 0.1.2 → 0.3.0

package/dist/index.js

@@ -1,8 +1,31 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { readFile } from 'node:fs/promises';
+
 /**
  * @module plugin/helpers
  * Shared types and utility functions for the OpenClaw plugin tool registrations.
  */
 const DEFAULT_API_URL = 'http://127.0.0.1:3458';
+/** Source identifier for virtual rule registration. */
+const PLUGIN_SOURCE = 'jeeves-watcher-openclaw';
+/** Normalize a path to forward slashes and lowercase drive letter on Windows. */
+function normalizePath(p) {
+    let result = p.replace(/\\/g, '/');
+    if (/^[A-Z]:/.test(result)) {
+        result = result[0].toLowerCase() + result.slice(1);
+    }
+    return result;
+}
+/**
+ * Resolve the workspace path from gateway config.
+ * Priority: agent-specific > defaults > fallback (~/.openclaw/workspace).
+ */
+function getWorkspacePath(api) {
+    const agentWorkspace = api.config?.agents?.entries?.['main']?.workspace ??
+        api.config?.agents?.defaults?.workspace;
+    return agentWorkspace ?? join(homedir(), '.openclaw', 'workspace');
+}
 /** Resolve the watcher API base URL from plugin config. */
 function getApiUrl(api) {
     const url = api.config?.plugins?.entries?.['jeeves-watcher']?.config?.apiUrl;
@@ -22,6 +45,30 @@ function fail(error) {
         isError: true,
     };
 }
+/** Format a connection error with actionable guidance. */
+function connectionFail(error, baseUrl) {
+    const cause = error instanceof Error ? error.cause : undefined;
+    const code = cause && typeof cause === 'object' && 'code' in cause
+        ? String(cause.code)
+        : '';
+    const isConnectionError = code === 'ECONNREFUSED' || code === 'ENOTFOUND' || code === 'ETIMEDOUT';
+    if (isConnectionError) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: [
+                        `Watcher service not reachable at ${baseUrl}.`,
+                        'Either start the watcher service, or if it runs on a different port,',
+                        'set plugins.entries.jeeves-watcher.config.apiUrl in openclaw.json.',
+                    ].join('\n'),
+                },
+            ],
+            isError: true,
+        };
+    }
+    return fail(error);
+}
 /** Fetch JSON from a URL, throwing on non-OK responses. */
 async function fetchJson(url, init) {
     const res = await fetch(url, init);
@@ -30,238 +77,414 @@ async function fetchJson(url, init) {
     }
     return res.json();
 }
+/** POST JSON to a URL and return parsed response. */
+async function postJson(url, body) {
+    return fetchJson(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+}
 
 /**
- * @module plugin
- * OpenClaw plugin entry point. Registers all jeeves-watcher tools.
+ * @module plugin/memoryTools
+ * memory_search and memory_get tool implementations with lazy init.
+ *
+ * Lazy init registers virtual inference rules with the watcher on first
+ * memory_search call. Re-attempts on failure. memory_get reads files
+ * directly from the filesystem with path validation.
  */
-/** Register all jeeves-watcher tools with the OpenClaw plugin API. */
-function register(api) {
-    const baseUrl = getApiUrl(api);
-    api.registerTool({
-        name: 'watcher_status',
-        description: 'Get jeeves-watcher service health, uptime, and collection statistics.',
-        parameters: { type: 'object', properties: {} },
-        execute: async () => {
-            try {
-                return ok(await fetchJson(`${baseUrl}/status`));
-            }
-            catch (error) {
-                return fail(error);
-            }
-        },
-    }, { optional: true });
-    api.registerTool({
-        name: 'watcher_search',
-        description: 'Semantic search over indexed documents. Supports Qdrant filters.',
-        parameters: {
-            type: 'object',
-            required: ['query'],
-            properties: {
-                query: { type: 'string', description: 'Search query text.' },
-                limit: {
-                    type: 'number',
-                    description: 'Max results (default 10).',
+/** Build virtual inference rules for a workspace path. */
+function buildVirtualRules(workspace) {
+    const ws = normalizePath(workspace);
+    return [
+        {
+            name: 'openclaw-memory-longterm',
+            description: 'OpenClaw long-term memory file',
+            match: {
+                type: 'object',
+                properties: {
+                    file: {
+                        type: 'object',
+                        properties: {
+                            path: { type: 'string', pattern: `^${ws}/MEMORY\\.md$` },
+                        },
+                    },
                 },
-                offset: {
-                    type: 'number',
-                    description: 'Number of results to skip for pagination.',
-                },
-                filter: {
+            },
+            schema: [
+                {
                     type: 'object',
-                    description: 'Qdrant filter object.',
+                    properties: {
+                        domain: { type: 'string', set: 'memory' },
+                        kind: { type: 'string', set: 'long-term' },
+                    },
                 },
-            },
+            ],
         },
-        execute: async (_id, params) => {
-            try {
-                const body = { query: params.query };
-                if (params.limit !== undefined)
-                    body.limit = params.limit;
-                if (params.offset !== undefined)
-                    body.offset = params.offset;
-                if (params.filter !== undefined)
-                    body.filter = params.filter;
-                return ok(await fetchJson(`${baseUrl}/search`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify(body),
-                }));
-            }
-            catch (error) {
-                return fail(error);
-            }
-        },
-    }, { optional: true });
-    api.registerTool({
-        name: 'watcher_enrich',
-        description: 'Set or update metadata on a document by file path.',
-        parameters: {
-            type: 'object',
-            required: ['path', 'metadata'],
-            properties: {
-                path: {
-                    type: 'string',
-                    description: 'Relative file path of the document.',
+        {
+            name: 'openclaw-memory-daily',
+            description: 'OpenClaw daily memory logs',
+            match: {
+                type: 'object',
+                properties: {
+                    file: {
+                        type: 'object',
+                        properties: {
+                            path: { type: 'string', pattern: `^${ws}/memory/.*\\.md$` },
+                        },
+                    },
                 },
-                metadata: {
+            },
+            schema: [
+                {
                     type: 'object',
-                    description: 'Key-value metadata to set on the document.',
+                    properties: {
+                        domain: { type: 'string', set: 'memory' },
+                        kind: { type: 'string', set: 'daily-log' },
+                    },
                 },
-            },
+            ],
         },
+    ];
+}
+/** Validate a path is within the memory scope. */
+function isAllowedMemoryPath(filePath, workspace) {
+    const norm = normalizePath(filePath).toLowerCase();
+    const ws = normalizePath(workspace).toLowerCase();
+    // Exact match: {workspace}/MEMORY.md
+    if (norm === `${ws}/memory.md`)
+        return true;
+    // Prefix match: {workspace}/memory/**/*.md
+    if (norm.startsWith(`${ws}/memory/`) && norm.endsWith('.md'))
+        return true;
+    return false;
+}
+/**
+ * Create memory tool registrations for the plugin.
+ * Returns register functions for memory_search and memory_get.
+ */
+function createMemoryTools(api, baseUrl) {
+    const workspace = getWorkspacePath(api);
+    const state = {
+        initialized: false,
+        workspace,
+        baseUrl,
+    };
+    /** Lazy init: register virtual rules with watcher. */
+    async function ensureInit() {
+        if (state.initialized)
+            return;
+        // Check watcher is reachable
+        await fetchJson(`${state.baseUrl}/status`);
+        // Clear any stale rules
+        await fetchJson(`${state.baseUrl}/rules/unregister`, {
+            method: 'DELETE',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ source: PLUGIN_SOURCE }),
+        });
+        // Register virtual rules
+        await postJson(`${state.baseUrl}/rules/register`, {
+            source: PLUGIN_SOURCE,
+            rules: buildVirtualRules(state.workspace),
+        });
+        state.initialized = true;
+    }
+    const memorySearch = async (_id, params) => {
+        try {
+            await ensureInit();
+            const body = {
+                query: params.query,
+                filter: {
+                    must: [{ key: 'domain', match: { value: 'memory' } }],
+                },
+            };
+            if (params.maxResults !== undefined)
+                body.limit = params.maxResults;
+            const raw = await postJson(`${state.baseUrl}/search`, body);
+            // Map results to system-prompt-compatible format
+            const results = raw.map((r) => {
+                const payload = r.payload;
+                const mapped = {
+                    path: payload.file_path,
+                    snippet: payload.chunk_text,
+                    score: r.score,
+                };
+                if (payload.line_start != null)
+                    mapped.from = payload.line_start;
+                if (payload.line_end != null)
+                    mapped.to = payload.line_end;
+                return mapped;
+            });
+            const minScore = typeof params.minScore === 'number' ? params.minScore : 0;
+            const filtered = results.filter((r) => typeof r.score === 'number' && r.score >= minScore);
+            return ok(filtered);
+        }
+        catch (error) {
+            state.initialized = false;
+            return connectionFail(error, state.baseUrl);
+        }
+    };
+    const memoryGet = async (_id, params) => {
+        try {
+            const filePath = String(params.path);
+            // Re-derive workspace on every call for immediate pickup of moves
+            const currentWorkspace = getWorkspacePath(api);
+            if (!isAllowedMemoryPath(filePath, currentWorkspace)) {
+                return fail(`Path not within memory scope. Allowed: ${currentWorkspace}/MEMORY.md and ${currentWorkspace}/memory/**/*.md`);
+            }
+            const content = await readFile(filePath, 'utf-8');
+            if (params.from !== undefined) {
+                const from = Number(params.from);
+                const lines = content.split('\n');
+                const startIdx = Math.max(0, from - 1); // 1-indexed to 0-indexed
+                const count = params.lines !== undefined
+                    ? Number(params.lines)
+                    : lines.length - startIdx;
+                const sliced = lines.slice(startIdx, startIdx + count);
+                return ok(sliced.join('\n'));
+            }
+            return ok(content);
+        }
+        catch (error) {
+            return fail(error);
+        }
+    };
+    return { memorySearch, memoryGet };
+}
+
+/**
+ * @module plugin/watcherTools
+ * Watcher tool registrations (watcher_* tools) for the OpenClaw plugin.
+ */
+/** Register a single API tool with standard try/catch + ok/connectionFail. */
+function registerApiTool(api, baseUrl, config) {
+    api.registerTool({
+        name: config.name,
+        description: config.description,
+        parameters: config.parameters,
         execute: async (_id, params) => {
             try {
-                return ok(await fetchJson(`${baseUrl}/metadata`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({
-                        path: params.path,
-                        metadata: params.metadata,
-                    }),
-                }));
+                const [endpoint, body] = config.buildRequest(params);
+                const url = `${baseUrl}${endpoint}`;
+                const data = body !== undefined
+                    ? await postJson(url, body)
+                    : await fetchJson(url);
+                return ok(data);
             }
             catch (error) {
-                return fail(error);
+                return connectionFail(error, baseUrl);
             }
         },
     }, { optional: true });
-    api.registerTool({
-        name: 'watcher_query',
-        description: 'Query the merged virtual document via JSONPath.',
-        parameters: {
-            type: 'object',
-            required: ['path'],
-            properties: {
-                path: {
-                    type: 'string',
-                    description: 'JSONPath expression.',
+}
+/** Pick defined keys from params into a body object. */
+function pickDefined(params, keys) {
+    const body = {};
+    for (const key of keys) {
+        if (params[key] !== undefined)
+            body[key] = params[key];
+    }
+    return body;
+}
+/** Register all 8 watcher_* tools with the OpenClaw plugin API. */
+function registerWatcherTools(api, baseUrl) {
+    const tools = [
+        {
+            name: 'watcher_status',
+            description: 'Get jeeves-watcher service health, uptime, and collection statistics.',
+            parameters: { type: 'object', properties: {} },
+            buildRequest: () => ['/status'],
+        },
+        {
+            name: 'watcher_search',
+            description: 'Semantic search over indexed documents. Supports Qdrant filters.',
+            parameters: {
+                type: 'object',
+                required: ['query'],
+                properties: {
+                    query: { type: 'string', description: 'Search query text.' },
+                    limit: { type: 'number', description: 'Max results (default 10).' },
+                    offset: {
+                        type: 'number',
+                        description: 'Number of results to skip for pagination.',
+                    },
+                    filter: { type: 'object', description: 'Qdrant filter object.' },
                 },
-                resolve: {
-                    type: 'array',
-                    items: { type: 'string', enum: ['files', 'globals'] },
-                    description: 'Resolution scopes to include (e.g., ["files"], ["globals"], or both).',
+            },
+            buildRequest: (params) => {
+                const body = pickDefined(params, [
+                    'query',
+                    'limit',
+                    'offset',
+                    'filter',
+                ]);
+                return ['/search', body];
+            },
+        },
+        {
+            name: 'watcher_enrich',
+            description: 'Set or update metadata on a document by file path.',
+            parameters: {
+                type: 'object',
+                required: ['path', 'metadata'],
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'Relative file path of the document.',
+                    },
+                    metadata: {
+                        type: 'object',
+                        description: 'Key-value metadata to set on the document.',
+                    },
                 },
             },
+            buildRequest: (params) => [
+                '/metadata',
+                { path: params.path, metadata: params.metadata },
+            ],
         },
-        execute: async (_id, params) => {
-            try {
-                const body = { path: params.path };
-                if (params.resolve !== undefined)
-                    body.resolve = params.resolve;
-                return ok(await fetchJson(`${baseUrl}/config/query`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify(body),
-                }));
-            }
-            catch (error) {
-                return fail(error);
-            }
+        {
+            name: 'watcher_query',
+            description: 'Query the merged virtual document via JSONPath.',
+            parameters: {
+                type: 'object',
+                required: ['path'],
+                properties: {
+                    path: { type: 'string', description: 'JSONPath expression.' },
+                    resolve: {
+                        type: 'array',
+                        items: { type: 'string', enum: ['files', 'globals'] },
+                        description: 'Resolution scopes to include (e.g., ["files"], ["globals"], or both).',
+                    },
+                },
+            },
+            buildRequest: (params) => {
+                const body = pickDefined(params, ['path', 'resolve']);
+                return ['/config/query', body];
+            },
         },
-    }, { optional: true });
-    api.registerTool({
-        name: 'watcher_validate',
-        description: 'Validate a candidate config (or current config if omitted). Optionally test file paths against the config to preview rule matching and metadata output.',
-        parameters: {
-            type: 'object',
-            properties: {
-                config: {
-                    type: 'object',
-                    description: 'Candidate config (partial or full). Omit to validate current config.',
+        {
+            name: 'watcher_validate',
+            description: 'Validate a candidate config (or current config if omitted). Optionally test file paths against the config to preview rule matching and metadata output.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    config: {
+                        type: 'object',
+                        description: 'Candidate config (partial or full). Omit to validate current config.',
+                    },
+                    testPaths: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'File paths to test against the config for dry-run preview.',
+                    },
                 },
-                testPaths: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'File paths to test against the config for dry-run preview.',
+            },
+            buildRequest: (params) => {
+                const body = pickDefined(params, ['config', 'testPaths']);
+                return ['/config/validate', body];
+            },
+        },
+        {
+            name: 'watcher_config_apply',
+            description: 'Apply a full or partial config. Validates, writes to disk, and triggers configured reindex behavior.',
+            parameters: {
+                type: 'object',
+                required: ['config'],
+                properties: {
+                    config: {
+                        type: 'object',
+                        description: 'Full or partial config to apply.',
+                    },
                 },
             },
+            buildRequest: (params) => ['/config/apply', { config: params.config }],
         },
-        execute: async (_id, params) => {
-            try {
-                const body = {};
-                if (params.config !== undefined)
-                    body.config = params.config;
-                if (params.testPaths !== undefined)
-                    body.testPaths = params.testPaths;
-                return ok(await fetchJson(`${baseUrl}/config/validate`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify(body),
-                }));
-            }
-            catch (error) {
-                return fail(error);
-            }
+        {
+            name: 'watcher_reindex',
+            description: 'Trigger a reindex of the watched files.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    scope: {
+                        type: 'string',
+                        enum: ['rules', 'full'],
+                        description: 'Reindex scope: "rules" (default) re-applies inference rules; "full" re-embeds everything.',
+                    },
+                },
+            },
+            buildRequest: (params) => [
+                '/config-reindex',
+                { scope: params.scope ?? 'rules' },
+            ],
         },
-    }, { optional: true });
+        {
+            name: 'watcher_issues',
+            description: 'Get runtime embedding failures. Shows files that failed processing and why.',
+            parameters: { type: 'object', properties: {} },
+            buildRequest: () => ['/issues'],
+        },
+    ];
+    for (const tool of tools) {
+        registerApiTool(api, baseUrl, tool);
+    }
+}
+
+/**
+ * @module plugin
+ * OpenClaw plugin entry point. Registers all jeeves-watcher tools.
+ */
+/** Register all jeeves-watcher tools with the OpenClaw plugin API. */
+function register(api) {
+    const baseUrl = getApiUrl(api);
+    // Register 8 watcher_* tools
+    registerWatcherTools(api, baseUrl);
+    // Register memory slot tools (memory_search + memory_get)
+    const { memorySearch, memoryGet } = createMemoryTools(api, baseUrl);
     api.registerTool({
-        name: 'watcher_config_apply',
-        description: 'Apply a full or partial config. Validates, writes to disk, and triggers configured reindex behavior.',
+        name: 'memory_search',
+        description: 'Semantically search MEMORY.md and memory/*.md files. Returns top snippets with path and line numbers.',
         parameters: {
             type: 'object',
-            required: ['config'],
+            required: ['query'],
             properties: {
-                config: {
-                    type: 'object',
-                    description: 'Full or partial config to apply.',
+                query: { type: 'string', description: 'Search query text.' },
+                maxResults: {
+                    type: 'number',
+                    description: 'Maximum results to return.',
+                },
+                minScore: {
+                    type: 'number',
+                    description: 'Minimum similarity score threshold.',
                 },
             },
         },
-        execute: async (_id, params) => {
-            try {
-                return ok(await fetchJson(`${baseUrl}/config/apply`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ config: params.config }),
-                }));
-            }
-            catch (error) {
-                return fail(error);
-            }
-        },
-    }, { optional: true });
+        execute: memorySearch,
+    });
     api.registerTool({
-        name: 'watcher_reindex',
-        description: 'Trigger a reindex of the watched files.',
+        name: 'memory_get',
+        description: 'Read content from MEMORY.md or memory/*.md files with optional line range.',
         parameters: {
             type: 'object',
+            required: ['path'],
             properties: {
-                scope: {
+                path: {
                     type: 'string',
-                    enum: ['rules', 'full'],
-                    description: 'Reindex scope: "rules" (default) re-applies inference rules; "full" re-embeds everything.',
+                    description: 'Path to the memory file to read.',
+                },
+                from: {
+                    type: 'number',
+                    description: 'Line number to start reading from (1-indexed).',
+                },
+                lines: {
+                    type: 'number',
+                    description: 'Number of lines to read.',
                 },
             },
         },
-        execute: async (_id, params) => {
-            try {
-                return ok(await fetchJson(`${baseUrl}/config-reindex`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({
-                        scope: params.scope ?? 'rules',
-                    }),
-                }));
-            }
-            catch (error) {
-                return fail(error);
-            }
-        },
-    }, { optional: true });
-    api.registerTool({
-        name: 'watcher_issues',
-        description: 'Get runtime embedding failures. Shows files that failed processing and why.',
-        parameters: { type: 'object', properties: {} },
-        execute: async () => {
-            try {
-                return ok(await fetchJson(`${baseUrl}/issues`));
-            }
-            catch (error) {
-                return fail(error);
-            }
-        },
-    }, { optional: true });
+        execute: memoryGet,
+    });
 }
 
 export { register as default };

package/dist/scripts/build-skills.d.ts

@@ -1,5 +1,5 @@
 /**
  * @module scripts/build-skills
- * Compiles SKILL.src.md files with Handlebars partials into dist/skills/.
+ * Copies skill files to dist/skills/ for plugin packaging.
  */
 export {};