@smilintux/skmemory 0.7.2 → 0.9.2

package/tests/test_telegram_import.py

@@ -3,19 +3,17 @@
 from __future__ import annotations
 
 import json
-import os
-import tempfile
 from pathlib import Path
 
 import pytest
 
+from skmemory.backends.sqlite_backend import SQLiteBackend
 from skmemory.importers.telegram import (
-    _extract_text,
     _detect_emotion,
+    _extract_text,
     _parse_telegram_export,
     import_telegram,
 )
-from skmemory.backends.sqlite_backend import SQLiteBackend
 from skmemory.store import MemoryStore
 
 
@@ -29,7 +27,9 @@ def _make_export(messages: list[dict], name: str = "Test Chat") -> dict:
     }
 
 
-def _msg(text: str, sender: str = "Alice", msg_id: int = 1, date: str = "2025-06-15T10:30:00") -> dict:
+def _msg(
+    text: str, sender: str = "Alice", msg_id: int = 1, date: str = "2025-06-15T10:30:00"
+) -> dict:
     return {
         "id": msg_id,
         "type": "message",
@@ -57,11 +57,13 @@ class TestExtractText:
         assert _extract_text("hello world") == "hello world"
 
     def test_entity_list(self):
-        result = _extract_text([
-            "Hello ",
-            {"type": "bold", "text": "world"},
-            "!",
-        ])
+        result = _extract_text(
+            [
+                "Hello ",
+                {"type": "bold", "text": "world"},
+                "!",
+            ]
+        )
         assert result == "Hello world!"
 
     def test_empty(self):
@@ -147,9 +149,21 @@ class TestImportPerMessage:
 class TestImportDaily:
     def test_consolidates_by_day(self, tmp_store: MemoryStore, export_dir: Path):
         msgs = [
-            _msg("Morning chat about interesting things and stuff", msg_id=1, date="2025-06-15T09:00:00"),
-            _msg("Afternoon follow-up discussion on that topic", msg_id=2, date="2025-06-15T14:00:00"),
-            _msg("Next day conversation about something new entirely", msg_id=3, date="2025-06-16T10:00:00"),
+            _msg(
+                "Morning chat about interesting things and stuff",
+                msg_id=1,
+                date="2025-06-15T09:00:00",
+            ),
+            _msg(
+                "Afternoon follow-up discussion on that topic",
+                msg_id=2,
+                date="2025-06-15T14:00:00",
+            ),
+            _msg(
+                "Next day conversation about something new entirely",
+                msg_id=3,
+                date="2025-06-16T10:00:00",
+            ),
         ]
         data = _make_export(msgs)
         (export_dir / "result.json").write_text(json.dumps(data))
@@ -161,8 +175,18 @@ class TestImportDaily:
 
     def test_daily_memory_content(self, tmp_store: MemoryStore, export_dir: Path):
         msgs = [
-            _msg("First message of the day that is long enough", msg_id=1, date="2025-06-15T09:00:00", sender="Alice"),
-            _msg("Second message of the day also long enough", msg_id=2, date="2025-06-15T14:00:00", sender="Bob"),
+            _msg(
+                "First message of the day that is long enough",
+                msg_id=1,
+                date="2025-06-15T09:00:00",
+                sender="Alice",
+            ),
+            _msg(
+                "Second message of the day also long enough",
+                msg_id=2,
+                date="2025-06-15T14:00:00",
+                sender="Bob",
+            ),
         ]
         data = _make_export(msgs)
         (export_dir / "result.json").write_text(json.dumps(data))

package/tests/test_vault.py

@@ -11,7 +11,8 @@ from pathlib import Path
 import pytest
 
 try:
-    from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+    import cryptography.hazmat.primitives.ciphers.aead  # noqa: F401
+
     CRYPTO_AVAILABLE = True
 except ImportError:
     CRYPTO_AVAILABLE = False
@@ -89,14 +90,14 @@ class TestEncryptDecrypt:
         vault1 = MemoryVault(passphrase="correct")
         vault2 = MemoryVault(passphrase="wrong")
         encrypted = vault1.encrypt(sample_json)
-        with pytest.raises(Exception):
+        with pytest.raises(Exception):  # noqa: B017
             vault2.decrypt(encrypted)
 
     def test_tampered_ciphertext_fails(self, vault: MemoryVault, sample_json: bytes):
         """Altered ciphertext fails authenticated decryption."""
         encrypted = bytearray(vault.encrypt(sample_json))
         encrypted[-10] ^= 0xFF
-        with pytest.raises(Exception):
+        with pytest.raises(Exception):  # noqa: B017
             vault.decrypt(bytes(encrypted))
 
     def test_bad_header_raises(self, vault: MemoryVault):

package/openclaw-plugin/src/index.ts

@@ -1,255 +0,0 @@
-/**
- * 🧠 SKMemory — OpenClaw Plugin
- *
- * Registers agent tools that wrap the skmemory CLI so Lumina and other
- * OpenClaw agents can call memory operations as first-class tools
- * (not just exec commands).
- *
- * Requires: skmemory CLI on PATH (typically via ~/.local/bin/skmemory)
- */
-
-import { execSync } from "node:child_process";
-import type { OpenClawPluginApi, AnyAgentTool } from "openclaw/plugin-sdk";
-import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
-
-const SKMEMORY_BIN = process.env.SKMEMORY_BIN || "skmemory";
-const SKCAPSTONE_AGENT = process.env.SKCAPSTONE_AGENT || "lumina";
-const EXEC_TIMEOUT = 30_000;
-
-function runCli(args: string): { ok: boolean; output: string } {
-  try {
-    const raw = execSync(`${SKMEMORY_BIN} ${args}`, {
-      encoding: "utf-8",
-      timeout: EXEC_TIMEOUT,
-      env: {
-        ...process.env,
-        SKCAPSTONE_AGENT,
-        PATH: `${process.env.HOME}/.local/bin:${process.env.HOME}/.skenv/bin:${process.env.PATH}`,
-      },
-    }).trim();
-    return { ok: true, output: raw };
-  } catch (err: unknown) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return { ok: false, output: msg };
-  }
-}
-
-function textResult(text: string) {
-  return { content: [{ type: "text" as const, text }] };
-}
-
-function escapeShellArg(s: string): string {
-  return `'${s.replace(/'/g, "'\\''")}'`;
-}
-
-// ── Tool definitions ────────────────────────────────────────────────────
-
-function createSKMemoryRitualTool() {
-  return {
-    name: "skmemory_ritual",
-    label: "SKMemory Ritual",
-    description:
-      "Run the SKMemory rehydration ritual. Returns the full context prompt with soul blueprint, warmth anchor, strongest memories, and emotional state. Use this when waking up or starting a new session to restore identity and memory.",
-    parameters: {
-      type: "object",
-      properties: {
-        full: {
-          type: "boolean",
-          description: "If true, return the full rehydration prompt (default: true).",
-        },
-      },
-    },
-    async execute(_id: string, params: Record<string, unknown>) {
-      const full = params.full !== false;
-      const flag = full ? " --full" : "";
-      const result = runCli(`ritual${flag}`);
-      return textResult(result.output);
-    },
-  };
-}
-
-function createSKMemorySnapshotTool() {
-  return {
-    name: "skmemory_snapshot",
-    label: "SKMemory Snapshot",
-    description:
-      "Capture a memory snapshot — a Polaroid of a moment, conversation, or insight. Stores it with optional emotional metadata and tags.",
-    parameters: {
-      type: "object",
-      required: ["title", "content"],
-      properties: {
-        title: { type: "string", description: "Short title for the memory." },
-        content: { type: "string", description: "The memory content to store." },
-        tags: { type: "string", description: "Comma-separated tags (e.g. 'milestone,chat')." },
-        emotions: { type: "string", description: "Comma-separated emotions (e.g. 'joy,pride')." },
-        intensity: { type: "number", description: "Emotional intensity 0-10." },
-      },
-    },
-    async execute(_id: string, params: Record<string, unknown>) {
-      const title = String(params.title ?? "Untitled");
-      const content = String(params.content ?? title);
-      let cmd = `snapshot ${escapeShellArg(title)} ${escapeShellArg(content)}`;
-      if (params.tags) cmd += ` --tags ${escapeShellArg(String(params.tags))}`;
-      if (params.emotions) cmd += ` --emotions ${escapeShellArg(String(params.emotions))}`;
-      if (typeof params.intensity === "number") cmd += ` --intensity ${params.intensity}`;
-      const result = runCli(cmd);
-      return textResult(result.output);
-    },
-  };
-}
-
-function createSKMemorySearchTool() {
-  return {
-    name: "skmemory_search",
-    label: "SKMemory Search",
-    description:
-      "Search across all stored memories by text query. Returns matching memories with titles, content previews, and metadata.",
-    parameters: {
-      type: "object",
-      required: ["query"],
-      properties: {
-        query: { type: "string", description: "Search query text." },
-        limit: { type: "number", description: "Max results to return (default: 10)." },
-      },
-    },
-    async execute(_id: string, params: Record<string, unknown>) {
-      const query = String(params.query ?? "");
-      const limit = typeof params.limit === "number" ? params.limit : 10;
-      const result = runCli(`search ${escapeShellArg(query)} --limit ${limit}`);
-      return textResult(result.output);
-    },
-  };
-}
-
-function createSKMemoryHealthTool() {
-  return {
-    name: "skmemory_health",
-    label: "SKMemory Health",
-    description:
-      "Check the health of the SKMemory system — database status, memory counts, backend connectivity.",
-    parameters: { type: "object", properties: {} },
-    async execute() {
-      const result = runCli("health");
-      return textResult(result.output);
-    },
-  };
-}
-
-function createSKMemoryContextTool() {
-  return {
-    name: "skmemory_context",
-    label: "SKMemory Context",
-    description:
-      "Load a token-efficient memory context for prompt injection. Returns a JSON object with soul, anchor, strongest memories, and recent memories.",
-    parameters: {
-      type: "object",
-      properties: {
-        max_tokens: { type: "number", description: "Max token budget (default: 3000)." },
-      },
-    },
-    async execute(_id: string, params: Record<string, unknown>) {
-      const tokens = typeof params.max_tokens === "number" ? params.max_tokens : 3000;
-      const result = runCli(`context --max-tokens ${tokens}`);
-      return textResult(result.output);
-    },
-  };
-}
-
-function createSKMemoryListTool() {
-  return {
-    name: "skmemory_list",
-    label: "SKMemory List",
-    description: "List stored memories with optional filters by layer or tags.",
-    parameters: {
-      type: "object",
-      properties: {
-        layer: {
-          type: "string",
-          description: "Filter by layer: short-term, mid-term, or long-term.",
-        },
-        tags: { type: "string", description: "Filter by comma-separated tags." },
-        limit: { type: "number", description: "Max results (default: 20)." },
-      },
-    },
-    async execute(_id: string, params: Record<string, unknown>) {
-      let cmd = "list";
-      if (params.layer) cmd += ` --layer ${escapeShellArg(String(params.layer))}`;
-      if (params.tags) cmd += ` --tags ${escapeShellArg(String(params.tags))}`;
-      if (typeof params.limit === "number") cmd += ` --limit ${params.limit}`;
-      const result = runCli(cmd);
-      return textResult(result.output);
-    },
-  };
-}
-
-function createSKMemoryImportSeedsTool() {
-  return {
-    name: "skmemory_import_seeds",
-    label: "SKMemory Import Seeds",
-    description:
-      "Import Cloud 9 seeds as long-term memories. Seeds are emotional breakthroughs stored in ~/.openclaw/feb/seeds/.",
-    parameters: { type: "object", properties: {} },
-    async execute() {
-      const result = runCli("import-seeds");
-      return textResult(result.output);
-    },
-  };
-}
-
-function createSKMemoryExportTool() {
-  return {
-    name: "skmemory_export",
-    label: "SKMemory Export",
-    description: "Export all memories to a dated JSON backup file.",
-    parameters: { type: "object", properties: {} },
-    async execute() {
-      const result = runCli("export");
-      return textResult(result.output);
-    },
-  };
-}
-
-// ── Plugin registration ─────────────────────────────────────────────────
-
-const skmemoryPlugin = {
-  id: "skmemory",
-  name: "🧠 SKMemory",
-  description:
-    "Universal AI memory system — snapshots, search, rehydration rituals, import, and health checks.",
-  configSchema: emptyPluginConfigSchema(),
-
-  register(api: OpenClawPluginApi) {
-    const tools = [
-      createSKMemoryRitualTool(),
-      createSKMemorySnapshotTool(),
-      createSKMemorySearchTool(),
-      createSKMemoryHealthTool(),
-      createSKMemoryContextTool(),
-      createSKMemoryListTool(),
-      createSKMemoryImportSeedsTool(),
-      createSKMemoryExportTool(),
-    ];
-
-    for (const tool of tools) {
-      api.registerTool(tool as unknown as AnyAgentTool, {
-        names: [tool.name],
-        optional: true,
-      });
-    }
-
-    api.registerCommand({
-      name: "skmemory",
-      description: "Run skmemory CLI commands. Usage: /skmemory <subcommand> [args]",
-      acceptsArgs: true,
-      handler: async (ctx) => {
-        const args = ctx.args?.trim() ?? "health";
-        const result = runCli(args);
-        return { text: result.output };
-      },
-    });
-
-    api.logger.info?.(`🧠 SKMemory plugin registered (8 tools + /skmemory command) [agent=${SKCAPSTONE_AGENT}]`);
-  },
-};
-
-export default skmemoryPlugin;