@noopolis/mneme 0.1.0

package/dist/store/store.js

@@ -0,0 +1,114 @@
+import { appendFile, mkdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import { canonicalScopeKey, makeChecksum, makeEventId } from "../identity/ids.js";
+export class JsonlMemoryStore {
+    eventsPath;
+    dirPath;
+    constructor(runtimeHomePath) {
+        this.dirPath = path.join(runtimeHomePath, "memory");
+        this.eventsPath = path.join(this.dirPath, "events.jsonl");
+    }
+    async appendOne(input) {
+        const createdAt = new Date().toISOString();
+        const event = {
+            id: makeEventId(),
+            type: input.type,
+            createdAt,
+            principal: input.principal,
+            scope: canonicalScopeKey(input.scope),
+            visibility: input.visibility,
+            source: input.source,
+            content: input.content,
+            tags: (input.tags ?? []).map((tag) => tag.toLowerCase()),
+            entities: (input.entities ?? []).map((entity) => entity.toLowerCase()),
+            sensitivity: input.sensitivity ?? "normal",
+            ttl: input.ttl,
+            parentEventIds: input.parentEventIds ?? [],
+            checksum: makeChecksum({
+                ...input,
+                id: "__temporary__",
+                createdAt,
+                checksum: ""
+            })
+        };
+        await appendFile(this.eventsPath, `${JSON.stringify(event)}\n`, { encoding: "utf8" });
+        return event;
+    }
+    async append(input) {
+        return this.appendBatch([input]).then((events) => events[0]);
+    }
+    async appendBatch(inputs) {
+        await mkdir(this.dirPath, { recursive: true });
+        if (inputs.length === 0) {
+            return [];
+        }
+        const events = [];
+        for (const input of inputs) {
+            events.push(await this.appendOne(input));
+        }
+        return events;
+    }
+    async clear() {
+        await appendFile(this.eventsPath, "", { encoding: "utf8", flag: "w" }).catch(() => Promise.resolve());
+    }
+    async read(query = {}) {
+        let payload = "";
+        try {
+            payload = await readFile(this.eventsPath, "utf8");
+        }
+        catch (error) {
+            if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+                return [];
+            }
+            throw error;
+        }
+        const queryText = (query.search ?? "").toLowerCase();
+        const searchTokens = queryText
+            .split(/\W+/u)
+            .map((value) => value.trim().toLowerCase())
+            .filter(Boolean);
+        const result = [];
+        const wantedTags = (query.tags ?? []).map((tag) => tag.toLowerCase());
+        const wantedTypes = query.types;
+        for (const line of payload.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed) {
+                continue;
+            }
+            let event;
+            try {
+                event = JSON.parse(trimmed);
+            }
+            catch {
+                continue;
+            }
+            if (query.scope && event.scope !== canonicalScopeKey(query.scope)) {
+                continue;
+            }
+            if (query.principalAgentId && event.principal.agentId !== query.principalAgentId) {
+                continue;
+            }
+            if (query.principalScope && event.principal.scope !== query.principalScope) {
+                continue;
+            }
+            if (query.principalQualifier && event.principal.qualifier !== query.principalQualifier) {
+                continue;
+            }
+            if (wantedTypes && wantedTypes.length > 0 && !wantedTypes.includes(event.type)) {
+                continue;
+            }
+            if (wantedTags.length > 0 && !wantedTags.some((tag) => event.tags.includes(tag))) {
+                continue;
+            }
+            if (searchTokens.length > 0) {
+                const eventText = JSON.stringify(event.content).toLowerCase();
+                const matched = searchTokens.every((token) => eventText.includes(token));
+                if (!matched) {
+                    continue;
+                }
+            }
+            result.push(event);
+        }
+        return result.sort((left, right) => new Date(right.createdAt).getTime() - new Date(left.createdAt).getTime());
+    }
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@noopolis/mneme",
+  "version": "0.1.0",
+  "description": "Noopolis scoped memory runtime and MCP tools for agentic systems.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "mneme": "dist/cli/index.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./mcp": {
+      "types": "./dist/mcp/index.d.ts",
+      "import": "./dist/mcp/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/noopolis/mneme.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc --project tsconfig.build.json && chmod +x dist/cli/index.js",
+    "clean": "rm -rf dist",
+    "prepack": "npm run build",
+    "prepublishOnly": "npm run typecheck && npm test",
+    "typecheck": "tsc --project tsconfig.json --noEmit",
+    "test": "node --import tsx --test \"src/**/*.test.ts\""
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^4.1.12"
+  },
+  "devDependencies": {
+    "@types/node": "^24.12.4",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  }
+}