qlogicagent 0.2.1 → 0.3.0

package/dist/skills/memory-tool.js

@@ -1,192 +0,0 @@
-// ============================================================
-// Memory Tool Contract — dual-layer agent memory system.
-//
-// Two independent layers (Hermes-inspired):
-//
-// 1. **MD Memory** (local notes, always in system prompt):
-//    Agent explicitly manages via add / replace / remove.
-//    Character-bounded, no LLM needed, zero-cost.
-//    Frozen snapshot in system prompt for KV cache stability.
-//
-// 2. **QMemory** (semantic long-term memory):
-//    Automatic extraction from every conversation turn.
-//    Agent queries via search action. Vector-based recall.
-//
-// The two layers are independent — no cross-dedup, no sync.
-// MD = curated highlights; QMemory = conversation sediment.
-// ============================================================
-// ── Constants ───────────────────────────────────────────────────
-export const MEMORY_TOOL_NAME = "memory";
-export const MEMORY_TOOL_MAX_CONTENT_LENGTH = 2000;
-export const MEMORY_TOOL_ACTIONS = ["add", "replace", "remove", "search"];
-// ── Tool schema (JSON Schema compatible) ────────────────────
-export const MEMORY_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        action: {
-            type: "string",
-            enum: MEMORY_TOOL_ACTIONS,
-            description: [
-                "The operation to perform:",
-                "• 'add' — Save a concise note about this user (→ local notes, always visible)",
-                "• 'replace' — Update an existing note by matching a substring (→ local notes)",
-                "• 'remove' — Delete a note by matching a substring (→ local notes)",
-                "• 'search' — Semantic search across long-term memory (→ qmemory)",
-            ].join("\n"),
-        },
-        target: {
-            type: "string",
-            enum: ["memory", "user"],
-            description: [
-                "Which note target to operate on (for add/replace/remove):",
-                "• 'memory' — Your personal observations/notes about this user (default)",
-                "• 'user' — User profile facts (preferences, timezone, etc.)",
-            ].join("\n"),
-        },
-        content: {
-            type: "string",
-            description: [
-                "Required for 'add' and 'replace'. The note content to store.",
-                "Write a concise, factual statement.",
-                "Good: '用户是后端工程师，主要使用 TypeScript 和 Go'",
-                "Good: 'User prefers dark UI themes and minimalist design'",
-                "Bad: '用户说了很多话' (too vague)",
-                "Bad: entire conversation transcripts (too long)",
-            ].join("\n"),
-        },
-        old_text: {
-            type: "string",
-            description: "Required for 'replace' and 'remove'. A substring that uniquely identifies the note entry to modify.",
-        },
-        query: {
-            type: "string",
-            description: "Required for 'search'. Natural language query to find relevant memories.",
-        },
-    },
-    required: ["action"],
-};
-export const MEMORY_TOOL_DESCRIPTION = [
-    "Manage your notes about this user and search long-term memory.",
-    "",
-    "Your notes (add/replace/remove) are always visible in the system prompt.",
-    "Long-term memories are automatically extracted from every conversation",
-    "and searchable via 'search'.",
-    "",
-    "Guidelines:",
-    "- Use 'add' to record important user preferences, facts, or context",
-    "- Use 'replace' to update outdated notes (match by substring)",
-    "- Use 'remove' to delete incorrect notes (match by substring)",
-    "- Use 'search' to recall conversation history and past interactions",
-    "- Keep notes concise — there's a character limit",
-].join("\n");
-export const MEMORY_TOOL_LABEL = "Memory";
-// ── Content safety ──────────────────────────────────────────
-const BLOCKED_PATTERNS = [
-    /ignore\s+(previous|all|above|prior)\s+instructions/i,
-    /you\s+are\s+now\s+/i,
-    /do\s+not\s+tell\s+the\s+user/i,
-    /system\s+prompt\s+override/i,
-];
-export function isMemoryContentSafe(text) {
-    return !BLOCKED_PATTERNS.some((pattern) => pattern.test(text));
-}
-export async function executeMemoryTool(params, deps) {
-    const { action } = params;
-    const target = params.target ?? "memory";
-    // ── MD store operations: add / replace / remove ───────
-    if (action === "add") {
-        if (!deps.store) {
-            return { ok: false, message: "Local memory store is not available.", action, errorCode: "no_store" };
-        }
-        const content = params.content?.trim();
-        if (!content) {
-            return { ok: false, message: "content is required for 'add' action.", action, errorCode: "empty_content" };
-        }
-        if (content.length > MEMORY_TOOL_MAX_CONTENT_LENGTH) {
-            return { ok: false, message: `Content too long (${content.length} chars, max ${MEMORY_TOOL_MAX_CONTENT_LENGTH}).`, action, errorCode: "too_long" };
-        }
-        const result = deps.store.add(target, content);
-        return {
-            ok: result.ok,
-            message: result.ok
-                ? `${result.message} [${result.usage}]`
-                : result.message,
-            action,
-            entryCount: result.entryCount,
-            usage: result.usage,
-            storeModified: result.ok,
-            errorCode: result.errorCode,
-        };
-    }
-    if (action === "replace") {
-        if (!deps.store) {
-            return { ok: false, message: "Local memory store is not available.", action, errorCode: "no_store" };
-        }
-        const oldText = params.old_text?.trim();
-        const content = params.content?.trim();
-        if (!oldText) {
-            return { ok: false, message: "old_text is required for 'replace' action.", action, errorCode: "empty_old_text" };
-        }
-        if (!content) {
-            return { ok: false, message: "content is required for 'replace' action.", action, errorCode: "empty_content" };
-        }
-        if (content.length > MEMORY_TOOL_MAX_CONTENT_LENGTH) {
-            return { ok: false, message: `Content too long (${content.length} chars, max ${MEMORY_TOOL_MAX_CONTENT_LENGTH}).`, action, errorCode: "too_long" };
-        }
-        const result = deps.store.replace(target, oldText, content);
-        return {
-            ok: result.ok,
-            message: result.ok
-                ? `${result.message} [${result.usage}]`
-                : result.message,
-            action,
-            entryCount: result.entryCount,
-            usage: result.usage,
-            storeModified: result.ok,
-            errorCode: result.errorCode,
-        };
-    }
-    if (action === "remove") {
-        if (!deps.store) {
-            return { ok: false, message: "Local memory store is not available.", action, errorCode: "no_store" };
-        }
-        const oldText = params.old_text?.trim();
-        if (!oldText) {
-            return { ok: false, message: "old_text is required for 'remove' action.", action, errorCode: "empty_old_text" };
-        }
-        const result = deps.store.remove(target, oldText);
-        return {
-            ok: result.ok,
-            message: result.ok
-                ? `${result.message} [${result.usage}]`
-                : result.message,
-            action,
-            entryCount: result.entryCount,
-            usage: result.usage,
-            storeModified: result.ok,
-            errorCode: result.errorCode,
-        };
-    }
-    if (action === "search") {
-        const query = params.query?.trim();
-        if (!query) {
-            return { ok: false, message: "query is required for 'search' action.", action, errorCode: "empty_query" };
-        }
-        try {
-            const results = await deps.provider.search(query, deps.userId, { limit: 10 });
-            if (results.length === 0) {
-                return { ok: true, message: "No matching memories found.", action, results: [] };
-            }
-            return {
-                ok: true,
-                message: results.map((r, i) => `${i + 1}. [${r.blockId}] ${r.text}`).join("\n"),
-                action,
-                results,
-            };
-        }
-        catch (error) {
-            return { ok: false, message: `Search failed: ${error instanceof Error ? error.message : String(error)}`, action, errorCode: "search_failed" };
-        }
-    }
-    return { ok: false, message: `Unknown action: ${action}. Use 'add', 'replace', 'remove', or 'search'.`, action, errorCode: "unknown_action" };
-}

package/dist/skills/portable-tool.js

@@ -1,14 +0,0 @@
-// ============================================================
-// Portable Tool Contract — runtime-agnostic tool interface.
-//
-// This is the minimal tool definition that any agent runtime
-// (openclaw, Hub, Electron, third-party) can consume. It uses
-// plain JSON Schema objects instead of @sinclair/typebox so
-// there are zero external dependencies.
-//
-// Consumers wrap PortableTool into their own tool system:
-//   - openclaw → AgentTool<TSchema>  (via typebox adapter)
-//   - Hub      → hub-managed tool registration
-//   - Electron → desktop tool host
-// ============================================================
-export {};

package/dist/skills/qmemory-adapter.js

@@ -1,165 +0,0 @@
-// ============================================================
-// QMemory HTTP adapter — implements MemoryProvider against the
-// QMemory REST API (v1).
-//
-// This is a Hub-ready, provider-agnostic adapter that can be
-// plugged into any consumer of the MemoryProvider contract.
-// ============================================================
-const DEFAULT_TIMEOUT_MS = 5_000;
-const PROVIDER_ID = "qmemory";
-/**
- * Create a MemoryProvider backed by a QMemory HTTP server.
- *
- * @example
- * ```ts
- * const provider = createQMemoryAdapter({
- *   baseUrl: "http://localhost:18800",
- *   apiKey: "sk-...",
- * });
- *
- * const results = await provider.search("last meeting notes", "alice");
- * await provider.ingest([{ role: "user", content: "..." }], "alice");
- * ```
- */
-export function createQMemoryAdapter(config) {
-    const baseUrl = config.baseUrl.replace(/\/+$/, "");
-    const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    function resolveUserId(userId) {
-        return config.userIdPrefix ? `${config.userIdPrefix}:${userId}` : userId;
-    }
-    function buildHeaders() {
-        const headers = {
-            "Accept": "application/json",
-        };
-        if (config.apiKey) {
-            headers["Authorization"] = `Bearer ${config.apiKey}`;
-        }
-        return headers;
-    }
-    async function request(pathname, init) {
-        const url = `${baseUrl}${pathname}`;
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), timeoutMs);
-        try {
-            const response = await fetch(url, {
-                ...init,
-                headers: { ...buildHeaders(), ...init?.headers },
-                signal: controller.signal,
-            });
-            if (!response.ok) {
-                const text = await response.text().catch(() => "");
-                throw new Error(`QMemory ${init?.method ?? "GET"} ${pathname} returned ${response.status}: ${text.slice(0, 200)}`);
-            }
-            return await response.json();
-        }
-        finally {
-            clearTimeout(timer);
-        }
-    }
-    return {
-        providerId: PROVIDER_ID,
-        async search(query, userId, options) {
-            const resolvedUserId = resolveUserId(userId);
-            const limit = options?.limit ?? 10;
-            const params = new URLSearchParams({
-                q: query,
-                user_id: resolvedUserId,
-                limit: String(limit),
-            });
-            const result = await request(`/v1/memories/search/?${params.toString()}`);
-            return (result.memories ?? [])
-                .filter((m) => m.id && m.text)
-                .map((m) => ({
-                blockId: m.id,
-                text: m.text,
-                score: typeof m.importance === "number" ? m.importance : 0,
-                source: PROVIDER_ID,
-                metadata: m.metadata,
-            }));
-        },
-        async ingest(messages, userId, options) {
-            const resolvedUserId = resolveUserId(userId);
-            await request("/v1/memories/", {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({
-                    user_id: resolvedUserId,
-                    messages: messages.map((m) => ({
-                        role: m.role,
-                        content: m.content,
-                        ...(m.timestamp ? { timestamp: m.timestamp } : {}),
-                    })), extraction_mode: "none", ...(options?.sessionId ? { session_id: options.sessionId } : {}),
-                    ...(options?.source ? { metadata: { source: options.source } } : {}),
-                    run_async: true,
-                }),
-            });
-        },
-        async health() {
-            const raw = await request("/v1/health/");
-            return {
-                status: raw.status ?? "unknown",
-                version: raw.version ?? "",
-                memoryCount: raw.memory_count ?? 0,
-                dbSizeBytes: raw.db_size_bytes ?? 0,
-                embeddingModel: raw.embedding_model ?? "",
-                uptimeSeconds: raw.uptime_seconds ?? 0,
-            };
-        },
-        async addText(text, userId, options) {
-            const resolvedUserId = resolveUserId(userId);
-            const result = await request("/v1/memories/", {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({
-                    user_id: resolvedUserId,
-                    text,
-                    extraction_mode: "none",
-                    ...(options?.sessionId ? { session_id: options.sessionId } : {}),
-                    ...(options?.source ? { metadata: { source: options.source } } : {}),
-                }),
-            });
-            return { memoriesAdded: result.memories_added ?? 0 };
-        },
-        async ingestExtracted(items, userId, options) {
-            if (items.length === 0)
-                return { memoriesAdded: 0 };
-            const resolvedUserId = resolveUserId(userId);
-            const results = await Promise.allSettled(items.map((item) => request("/v1/memories/", {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({
-                    user_id: resolvedUserId,
-                    text: item.text,
-                    extraction_mode: "none",
-                    ...(options?.sessionId ? { session_id: options.sessionId } : {}),
-                    metadata: {
-                        ...(options?.source ? { source: options.source } : {}),
-                        ...(item.category ? { category: item.category } : {}),
-                        ...(typeof item.importance === "number" ? { importance: item.importance } : {}),
-                        ...(item.speaker ? { speaker: item.speaker } : {}),
-                        ...(item.event_date ? { event_date: item.event_date } : {}),
-                        ...(item.tags?.length ? { tags: item.tags } : {}),
-                    },
-                }),
-            })));
-            let total = 0;
-            for (const r of results) {
-                if (r.status === "fulfilled") {
-                    total += r.value.memories_added ?? 1;
-                }
-            }
-            return { memoriesAdded: total };
-        },
-        async remove(memoryId) {
-            try {
-                await request(`/v1/memories/${encodeURIComponent(memoryId)}/`, {
-                    method: "DELETE",
-                });
-                return true;
-            }
-            catch {
-                return false;
-            }
-        },
-    };
-}