@karmaniverous/jeeves-meta-openclaw 0.1.2 → 0.1.3

package/dist/index.js

@@ -1,4 +1,4 @@
-import { HttpWatcherClient, paginatedScan, buildMetaFilter, isLocked, normalizePath, discoverMetas, buildOwnershipTree, findNode, actualStaleness, computeEffectiveStaleness, selectCandidate, filterInScope, computeStructureHash, readLatestArchive, hasSteerChanged, isArchitectTriggered, loadSynthConfig } from '@karmaniverous/jeeves-meta';
+import { HttpWatcherClient, listMetas, normalizePath, findNode, computeEffectiveStaleness, selectCandidate, paginatedScan, filterInScope, computeStructureHash, readLatestArchive, hasSteerChanged, isArchitectTriggered, actualStaleness, loadSynthConfig } from '@karmaniverous/jeeves-meta';
 import { readFile, writeFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
 
@@ -255,6 +255,8 @@ function registerSynthTools(api) {
     };
     /** Derive watcherUrl from loaded config. */
     const getWatcherUrl = () => getConfig().watcherUrl;
+    /** Create a watcher client. */
+    const getWatcher = () => new HttpWatcherClient({ baseUrl: getWatcherUrl() });
     // ─── synth_list ──────────────────────────────────────────────
     api.registerTool({
         name: 'synth_list',
@@ -286,34 +288,31 @@ function registerSynthTools(api) {
         execute: async (_id, params) => {
             try {
                 const pathPrefix = params.pathPrefix;
-                const watcher = new HttpWatcherClient({ baseUrl: getWatcherUrl() });
                 const config = getConfig();
-                // Query watcher for synth entity points using configured filter
-                const scanFiles = await paginatedScan(watcher, {
-                    ...(pathPrefix ? { pathPrefix } : {}),
-                    filter: buildMetaFilter(config),
-                    fields: [
-                        'file_path',
-                        'synth_depth',
-                        'synth_emphasis',
-                        'synth_architect_tokens',
-                        'synth_builder_tokens',
-                        'synth_critic_tokens',
-                        'has_error',
-                        'generated_at_unix',
-                        'synth_error_step',
-                    ],
-                });
-                // Deduplicate by file_path (watcher chunks files into multiple points)
-                const seenPaths = new Set();
-                const dedupedFiles = scanFiles.filter((sf) => {
-                    const fp = sf.file_path;
-                    if (seenPaths.has(fp))
-                        return false;
-                    seenPaths.add(fp);
-                    return true;
-                });
-                const entities = [];
+                const result = await listMetas(config, getWatcher());
+                // Apply path prefix filter
+                let entries = result.entries;
+                if (pathPrefix) {
+                    entries = entries.filter((e) => e.path.includes(pathPrefix));
+                }
+                // Apply structured filter
+                const filter = params.filter;
+                if (filter) {
+                    entries = entries.filter((e) => {
+                        if (filter.hasError !== undefined && e.hasError !== filter.hasError)
+                            return false;
+                        if (filter.neverSynthesized !== undefined &&
+                            (e.stalenessSeconds === Infinity) !== filter.neverSynthesized)
+                            return false;
+                        if (filter.locked !== undefined && e.locked !== filter.locked)
+                            return false;
+                        if (typeof filter.staleHours === 'number' &&
+                            e.stalenessSeconds < filter.staleHours * 3600)
+                            return false;
+                        return true;
+                    });
+                }
+                // Recompute summary for filtered entries
                 let staleCount = 0;
                 let errorCount = 0;
                 let lockedCount = 0;
@@ -325,112 +324,69 @@ function registerSynthTools(api) {
                 let lastSynthAt = null;
                 let stalestPath = null;
                 let stalestEffective = -1;
-                for (const sf of dedupedFiles) {
-                    const filePath = sf.file_path;
-                    const depth = typeof sf['synth_depth'] === 'number' ? sf['synth_depth'] : 0;
-                    const emphasis = typeof sf['synth_emphasis'] === 'number' ? sf['synth_emphasis'] : 1;
-                    const hasError = sf['has_error'] === true || sf['has_error'] === 'true';
-                    const archTokens = typeof sf['synth_architect_tokens'] === 'number'
-                        ? sf['synth_architect_tokens']
-                        : 0;
-                    const buildTokens = typeof sf['synth_builder_tokens'] === 'number'
-                        ? sf['synth_builder_tokens']
-                        : 0;
-                    const critTokens = typeof sf['synth_critic_tokens'] === 'number'
-                        ? sf['synth_critic_tokens']
-                        : 0;
-                    const genAtUnix = typeof sf['generated_at_unix'] === 'number'
-                        ? sf['generated_at_unix']
-                        : 0;
-                    const locked = isLocked(normalizePath(filePath));
-                    const neverSynth = genAtUnix === 0;
-                    // Compute staleness from generated_at_unix
-                    let stalenessSeconds;
-                    if (neverSynth) {
-                        stalenessSeconds = Infinity;
-                    }
-                    else {
-                        stalenessSeconds = Math.floor(Date.now() / 1000) - genAtUnix;
-                        if (stalenessSeconds < 0)
-                            stalenessSeconds = 0;
-                    }
-                    // Apply structured filter
-                    const filter = params.filter;
-                    if (filter) {
-                        if (filter.hasError !== undefined && hasError !== filter.hasError)
-                            continue;
-                        if (filter.neverSynthesized !== undefined &&
-                            neverSynth !== filter.neverSynthesized)
-                            continue;
-                        if (filter.locked !== undefined && locked !== filter.locked)
-                            continue;
-                        if (typeof filter.staleHours === 'number' &&
-                            stalenessSeconds < filter.staleHours * 3600)
-                            continue;
-                    }
-                    if (stalenessSeconds > 0)
+                for (const e of entries) {
+                    if (e.stalenessSeconds > 0)
                         staleCount++;
-                    if (hasError)
+                    if (e.hasError)
                         errorCount++;
-                    if (locked)
+                    if (e.locked)
                         lockedCount++;
-                    if (neverSynth)
+                    if (e.stalenessSeconds === Infinity)
                         neverSynthesizedCount++;
-                    if (archTokens > 0)
-                        totalArchTokens += archTokens;
-                    if (buildTokens > 0)
-                        totalBuilderTokens += buildTokens;
-                    if (critTokens > 0)
-                        totalCriticTokens += critTokens;
-                    const genAtIso = genAtUnix > 0 ? new Date(genAtUnix * 1000).toISOString() : null;
-                    if (genAtIso && (!lastSynthAt || genAtIso > lastSynthAt)) {
-                        lastSynthAt = genAtIso;
-                        lastSynthPath = filePath;
+                    if (e.architectTokens)
+                        totalArchTokens += e.architectTokens;
+                    if (e.builderTokens)
+                        totalBuilderTokens += e.builderTokens;
+                    if (e.criticTokens)
+                        totalCriticTokens += e.criticTokens;
+                    if (e.lastSynthesized &&
+                        (!lastSynthAt || e.lastSynthesized > lastSynthAt)) {
+                        lastSynthAt = e.lastSynthesized;
+                        lastSynthPath = e.path;
                     }
-                    // Effective staleness for stalest computation
-                    const depthFactor = Math.pow(1 + config.depthWeight, depth);
-                    const effectiveStaleness = (stalenessSeconds === Infinity
+                    const depthFactor = Math.pow(1 + config.depthWeight, e.depth);
+                    const effectiveStaleness = (e.stalenessSeconds === Infinity
                         ? Number.MAX_SAFE_INTEGER
-                        : stalenessSeconds) *
+                        : e.stalenessSeconds) *
                         depthFactor *
-                        emphasis;
+                        e.emphasis;
                     if (effectiveStaleness > stalestEffective) {
                         stalestEffective = effectiveStaleness;
-                        stalestPath = filePath;
+                        stalestPath = e.path;
                     }
-                    // Derive meta path from file_path (strip /meta.json)
-                    const metaPath = filePath.replace(/\/meta\.json$/, '');
-                    const fields = params.fields;
-                    const raw = {
-                        path: metaPath,
-                        depth,
-                        emphasis,
-                        stalenessSeconds: stalenessSeconds === Infinity
-                            ? 'never-synthesized'
-                            : Math.round(stalenessSeconds),
-                        lastSynthesized: genAtIso,
-                        hasError,
-                        locked,
-                        architectTokens: archTokens > 0 ? archTokens : null,
-                        builderTokens: buildTokens > 0 ? buildTokens : null,
-                        criticTokens: critTokens > 0 ? critTokens : null,
-                        children: 0,
+                }
+                // Project fields
+                const fields = params.fields;
+                const items = entries.map((e) => {
+                    const stalenessDisplay = e.stalenessSeconds === Infinity
+                        ? 'never-synthesized'
+                        : Math.round(e.stalenessSeconds);
+                    const display = {
+                        path: e.path,
+                        depth: e.depth,
+                        emphasis: e.emphasis,
+                        stalenessSeconds: stalenessDisplay,
+                        lastSynthesized: e.lastSynthesized,
+                        hasError: e.hasError,
+                        locked: e.locked,
+                        architectTokens: e.architectTokens,
+                        builderTokens: e.builderTokens,
+                        criticTokens: e.criticTokens,
+                        children: e.children,
                     };
                     if (fields) {
                         const projected = {};
                         for (const f of fields) {
-                            if (f in raw)
-                                projected[f] = raw[f];
+                            if (f in display)
+                                projected[f] = display[f];
                         }
-                        entities.push(projected);
-                    }
-                    else {
-                        entities.push(raw);
+                        return projected;
                     }
-                }
+                    return display;
+                });
                 return ok({
                     summary: {
-                        total: entities.length,
+                        total: entries.length,
                         stale: staleCount,
                         errors: errorCount,
                         locked: lockedCount,
@@ -444,7 +400,11 @@ function registerSynthTools(api) {
                         lastSynthesizedPath: lastSynthPath,
                         lastSynthesizedAt: lastSynthAt,
                     },
-                    items: entities.sort((a, b) => String(a.path ?? '').localeCompare(String(b.path ?? ''))),
+                    items: items.sort((a, b) => {
+                        const ap = typeof a.path === 'string' ? a.path : '';
+                        const bp = typeof b.path === 'string' ? b.path : '';
+                        return ap.localeCompare(bp);
+                    }),
                 });
             }
             catch (error) {
@@ -487,10 +447,8 @@ function registerSynthTools(api) {
                     '_feedback',
                 ]);
                 const fields = params.fields;
-                const watcher = new HttpWatcherClient({ baseUrl: getWatcherUrl() });
-                const metaPaths = await discoverMetas(getConfig(), watcher);
-                const tree = buildOwnershipTree(metaPaths);
-                const targetNode = findNode(tree, targetPath);
+                const result = await listMetas(getConfig(), getWatcher());
+                const targetNode = findNode(result.tree, targetPath);
                 if (!targetNode) {
                     return fail('Meta path not found: ' + targetPath);
                 }
@@ -505,7 +463,6 @@ function registerSynthTools(api) {
                             result[f] = m[f];
                         return result;
                     }
-                    // Default: exclude big text blobs
                     const result = {};
                     for (const [k, v] of Object.entries(m)) {
                         if (!defaultExclude.has(k))
@@ -525,7 +482,6 @@ function registerSynthTools(api) {
                     const limit = typeof includeArchive === 'number'
                         ? includeArchive
                         : archiveFiles.length;
-                    // Most recent first (files are sorted by timestamp)
                     const selected = archiveFiles.slice(-limit).reverse();
                     const archives = selected.map((af) => {
                         const raw = readFileSync(join(targetNode.metaPath, 'archive', af), 'utf8');
@@ -557,35 +513,27 @@ function registerSynthTools(api) {
         execute: async (_id, params) => {
             try {
                 const targetPath = params.path;
-                const watcher = new HttpWatcherClient({ baseUrl: getWatcherUrl() });
-                const metaPaths = await discoverMetas(getConfig(), watcher);
-                const tree = buildOwnershipTree(metaPaths);
+                const config = getConfig();
+                const watcher = getWatcher();
+                const result = await listMetas(config, watcher);
                 let targetNode;
                 if (targetPath) {
                     const normalized = normalizePath(targetPath);
-                    targetNode = findNode(tree, normalized);
+                    targetNode = findNode(result.tree, normalized);
                     if (!targetNode) {
                         return fail('Meta path not found: ' + targetPath);
                     }
                 }
                 else {
-                    // Select stalest
-                    const { readFileSync: readFs } = await import('node:fs');
-                    const { join: joinPath } = await import('node:path');
-                    const candidates = [];
-                    for (const node of tree.nodes.values()) {
-                        try {
-                            const meta = JSON.parse(readFs(joinPath(node.metaPath, 'meta.json'), 'utf8'));
-                            const staleness = actualStaleness(meta);
-                            if (staleness > 0) {
-                                candidates.push({ node, meta, actualStaleness: staleness });
-                            }
-                        }
-                        catch {
-                            // skip unreadable
-                        }
-                    }
-                    const weighted = computeEffectiveStaleness(candidates, getConfig().depthWeight);
+                    // Select stalest candidate
+                    const candidates = result.entries
+                        .filter((e) => e.stalenessSeconds > 0)
+                        .map((e) => ({
+                        node: e.node,
+                        meta: e.meta,
+                        actualStaleness: e.stalenessSeconds,
+                    }));
+                    const weighted = computeEffectiveStaleness(candidates, config.depthWeight);
                     const winner = selectCandidate(weighted);
                     if (!winner) {
                         return ok({
@@ -597,21 +545,17 @@ function registerSynthTools(api) {
                 const { readFileSync: readMeta } = await import('node:fs');
                 const { join: joinMeta } = await import('node:path');
                 const meta = JSON.parse(readMeta(joinMeta(targetNode.metaPath, 'meta.json'), 'utf8'));
-                // Scope files (paginated for completeness)
+                // Scope files
                 const allScanFiles = await paginatedScan(watcher, {
                     pathPrefix: targetNode.ownerPath,
                 });
                 const allFiles = allScanFiles.map((f) => f.file_path);
                 const scopeFiles = filterInScope(targetNode, allFiles);
-                // Structure hash on scope-filtered files (matches orchestrator)
                 const structureHash = computeStructureHash(scopeFiles);
                 const structureChanged = structureHash !== meta._structureHash;
-                // Steer change
                 const latestArchive = readLatestArchive(targetNode.metaPath);
                 const steerChanged = hasSteerChanged(meta._steer, latestArchive?._steer, Boolean(latestArchive));
-                // Architect trigger check
-                const architectTriggered = isArchitectTriggered(meta, structureChanged, steerChanged, getConfig().architectEvery);
-                // Delta files
+                const architectTriggered = isArchitectTriggered(meta, structureChanged, steerChanged, config.architectEvery);
                 let deltaFiles = [];
                 if (meta._generatedAt) {
                     const modifiedAfter = Math.floor(new Date(meta._generatedAt).getTime() / 1000);
@@ -646,7 +590,7 @@ function registerSynthTools(api) {
                         ...(!meta._builder ? ['no cached builder (first run)'] : []),
                         ...(structureChanged ? ['structure changed'] : []),
                         ...(steerChanged ? ['steer changed'] : []),
-                        ...((meta._synthesisCount ?? 0) >= getConfig().architectEvery
+                        ...((meta._synthesisCount ?? 0) >= config.architectEvery
                             ? ['periodic refresh (architectEvery)']
                             : []),
                     ],
@@ -678,13 +622,12 @@ function registerSynthTools(api) {
             try {
                 const { orchestrate } = await import('@karmaniverous/jeeves-meta');
                 const { GatewayExecutor } = await import('@karmaniverous/jeeves-meta');
-                // Load config from canonical config file
                 const config = getConfig();
                 const executor = new GatewayExecutor({
                     gatewayUrl: config.gatewayUrl,
                     apiKey: config.gatewayApiKey,
                 });
-                const watcher = new HttpWatcherClient({ baseUrl: getWatcherUrl() });
+                const watcher = getWatcher();
                 const targetPath = params.path;
                 const results = await orchestrate(config, executor, watcher, targetPath);
                 const synthesized = results.filter((r) => r.synthesized);
@@ -729,48 +672,28 @@ function registerSynthTools(api) {
  * 2. No entities found - ACTION REQUIRED with setup guidance
  * 3. Healthy - entity stats + tool listing + skill reference
  *
- * @param watcherUrl - Watcher API base URL.
+ * @param config - Full synth config (for listMetas and watcherUrl).
  * @returns Markdown string for the Meta section.
  */
-async function generateMetaMenu(watcherUrl, metaFilter) {
-    let entities = [];
+async function generateMetaMenu(config) {
+    let result;
     try {
-        const watcher = new HttpWatcherClient({ baseUrl: watcherUrl });
-        entities = await paginatedScan(watcher, {
-            filter: metaFilter,
-            fields: [
-                'synth_depth',
-                'synth_emphasis',
-                'synth_synthesis_count',
-                'synth_architect_tokens',
-                'synth_builder_tokens',
-                'synth_critic_tokens',
-                'synth_error_step',
-                'generated_at_unix',
-                'has_error',
-            ],
-        });
+        const watcher = new HttpWatcherClient({ baseUrl: config.watcherUrl });
+        result = await listMetas(config, watcher);
     }
     catch {
         return [
             '> **ACTION REQUIRED: jeeves-watcher is unreachable.**',
             '> The jeeves-meta synthesis engine requires a running jeeves-watcher service.',
-            `> The watcher API at ${watcherUrl} is down or not configured.`,
+            '> The watcher API at ' +
+                config.watcherUrl +
+                ' is down or not configured.',
             '>',
             "> **Read the `jeeves-meta` skill's Bootstrap section immediately**",
             '> for setup instructions. Do not attempt synthesis until watcher is available.',
         ].join('\n');
     }
-    // Deduplicate by file_path (watcher chunks files into multiple points)
-    const seenPaths = new Set();
-    entities = entities.filter((e) => {
-        const fp = e.file_path;
-        if (seenPaths.has(fp))
-            return false;
-        seenPaths.add(fp);
-        return true;
-    });
-    if (entities.length === 0) {
+    if (result.entries.length === 0) {
         return [
             '> **ACTION REQUIRED: No synthesis entities found.**',
             '> The watcher is running but no `.meta/` directories were discovered',
@@ -780,55 +703,7 @@ async function generateMetaMenu(watcherUrl, metaFilter) {
             '> on creating `.meta/` directories and configuring watch paths.',
         ].join('\n');
     }
-    // Compute stats
-    const now = Math.floor(Date.now() / 1000);
-    let staleCount = 0;
-    let errorCount = 0;
-    let neverSynthesized = 0;
-    let totalArchTokens = 0;
-    let totalBuilderTokens = 0;
-    let totalCriticTokens = 0;
-    let stalestPath = '';
-    let stalestAge = 0;
-    let lastSynthPath = '';
-    let lastSynthUnix = 0;
-    for (const e of entities) {
-        const generatedAt = e['generated_at_unix'];
-        const hasError = e['has_error'];
-        const archTokens = e['synth_architect_tokens'];
-        const builderTokens = e['synth_builder_tokens'];
-        const criticTokens = e['synth_critic_tokens'];
-        if (!generatedAt) {
-            neverSynthesized++;
-            staleCount++;
-            if (!isFinite(stalestAge)) ;
-            else {
-                stalestAge = Infinity;
-                stalestPath = e.file_path;
-            }
-        }
-        else {
-            const age = now - generatedAt;
-            if (age > 0)
-                staleCount++;
-            if (age > stalestAge && isFinite(age)) {
-                stalestAge = age;
-                stalestPath = e.file_path;
-            }
-            if (generatedAt > lastSynthUnix) {
-                lastSynthUnix = generatedAt;
-                lastSynthPath = e.file_path;
-            }
-        }
-        if (hasError)
-            errorCount++;
-        if (archTokens)
-            totalArchTokens += archTokens;
-        if (builderTokens)
-            totalBuilderTokens += builderTokens;
-        if (criticTokens)
-            totalCriticTokens += criticTokens;
-    }
+    const { summary, entries } = result;
     const formatAge = (seconds) => {
         if (!isFinite(seconds))
             return 'never synthesized';
@@ -838,25 +713,42 @@ async function generateMetaMenu(watcherUrl, metaFilter) {
             return Math.round(seconds / 3600).toString() + 'h';
         return Math.round(seconds / 86400).toString() + 'd';
     };
+    // Find stalest age for display
+    let stalestAge = 0;
+    for (const e of entries) {
+        if (e.stalenessSeconds > stalestAge)
+            stalestAge = e.stalenessSeconds;
+    }
+    const stalestDisplay = summary.stalestPath
+        ? summary.stalestPath + ' (' + formatAge(stalestAge) + ')'
+        : 'n/a';
+    const lastSynthDisplay = summary.lastSynthesizedAt
+        ? (summary.lastSynthesizedPath ?? '') +
+            ' (' +
+            summary.lastSynthesizedAt +
+            ')'
+        : 'n/a';
     const lines = [
-        `The jeeves-meta synthesis engine manages ${entities.length.toString()} meta entities.`,
+        'The jeeves-meta synthesis engine manages ' +
+            entries.length.toString() +
+            ' meta entities.',
         '',
         '### Entity Summary',
         '| Metric | Value |',
         '|--------|-------|',
-        `| Total | ${entities.length.toString()} |`,
-        `| Stale | ${staleCount.toString()} |`,
-        `| Errors | ${errorCount.toString()} |`,
-        `| Never synthesized | ${neverSynthesized.toString()} |`,
-        `| Stalest | ${stalestPath ? stalestPath + ' (' + formatAge(stalestAge) + ')' : 'n/a'} |`,
-        `| Last synthesized | ${lastSynthPath ? lastSynthPath + ' (' + new Date(lastSynthUnix * 1000).toISOString() + ')' : 'n/a'} |`,
+        '| Total | ' + summary.total.toString() + ' |',
+        '| Stale | ' + summary.stale.toString() + ' |',
+        '| Errors | ' + summary.errors.toString() + ' |',
+        '| Never synthesized | ' + summary.neverSynthesized.toString() + ' |',
+        '| Stalest | ' + stalestDisplay + ' |',
+        '| Last synthesized | ' + lastSynthDisplay + ' |',
         '',
         '### Token Usage (cumulative)',
         '| Step | Tokens |',
         '|------|--------|',
-        `| Architect | ${totalArchTokens.toLocaleString()} |`,
-        `| Builder | ${totalBuilderTokens.toLocaleString()} |`,
-        `| Critic | ${totalCriticTokens.toLocaleString()} |`,
+        '| Architect | ' + summary.tokens.architect.toLocaleString() + ' |',
+        '| Builder | ' + summary.tokens.builder.toLocaleString() + ' |',
+        '| Critic | ' + summary.tokens.critic.toLocaleString() + ' |',
         '',
         '### Tools',
         '| Tool | Description |',
@@ -946,7 +838,7 @@ function upsertMetaSection(existing, metaMenu) {
  * @returns True if the file was updated.
  */
 async function refreshToolsMd(api, config) {
-    const menu = await generateMetaMenu(config.watcherUrl, buildMetaFilter(config));
+    const menu = await generateMetaMenu(config);
     if (menu === lastWrittenMenu) {
         return false;
     }

package/dist/src/promptInjection.d.ts

@@ -6,6 +6,7 @@
  *
  * @module promptInjection
  */
+import { type SynthConfig } from '@karmaniverous/jeeves-meta';
 /**
  * Generate the Meta menu Markdown for TOOLS.md.
  *
@@ -14,7 +15,7 @@
  * 2. No entities found - ACTION REQUIRED with setup guidance
  * 3. Healthy - entity stats + tool listing + skill reference
  *
- * @param watcherUrl - Watcher API base URL.
+ * @param config - Full synth config (for listMetas and watcherUrl).
  * @returns Markdown string for the Meta section.
  */
-export declare function generateMetaMenu(watcherUrl: string, metaFilter: Record<string, unknown>): Promise<string>;
+export declare function generateMetaMenu(config: SynthConfig): Promise<string>;

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "jeeves-meta-openclaw",
   "name": "Jeeves Meta",
   "description": "Knowledge synthesis tools — trigger synthesis, view status, manage entities.",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "skills": [
     "dist/skills/jeeves-meta"
   ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@karmaniverous/jeeves-meta-openclaw",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "author": "Jason Williscroft",
   "description": "OpenClaw plugin for jeeves-meta — synthesis tools and virtual rule registration",
   "license": "BSD-3-Clause",