pi-observational-memory-extension 0.1.2 → 0.2.0

package/package.json

@@ -1,13 +1,39 @@
 {
   "name": "pi-observational-memory-extension",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Mastra-style Observational Memory extension for Pi compaction and runtime context.",
   "license": "MIT",
   "author": "Nikita Nosov <20nik.nosov21@gmail.com>",
   "type": "module",
-  "keywords": ["pi-package", "pi", "pi-coding-agent", "observational-memory", "memory", "compaction"],
-  "files": ["extensions", "docs", "scripts", "README.md", "LICENSE", "CHANGELOG.md"],
-  "pi": { "extensions": ["./extensions"] },
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-coding-agent",
+    "observational-memory",
+    "memory",
+    "compaction"
+  ],
+  "homepage": "https://github.com/nik1t7n/pi-observational-memory-extension#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nik1t7n/pi-observational-memory-extension.git"
+  },
+  "bugs": {
+    "url": "https://github.com/nik1t7n/pi-observational-memory-extension/issues"
+  },
+  "files": [
+    "extensions",
+    "docs",
+    "scripts",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "pi": {
+    "extensions": [
+      "./extensions"
+    ]
+  },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "*",
     "@earendil-works/pi-ai": "*",
@@ -24,6 +50,7 @@
     "typecheck": "tsc --noEmit",
     "validate": "node scripts/validate.mjs",
     "pack:check": "npm pack --dry-run",
-    "prepublishOnly": "npm run validate && npm run typecheck && npm run pack:check"
+    "prepublishOnly": "npm run validate && npm run typecheck && npm test && npm run pack:check",
+    "test": "node scripts/test.mjs"
   }
 }

package/scripts/test.mjs

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+const dist = ".tmp-test-dist";
+await rm(dist, { recursive: true, force: true });
+execFileSync("npx", ["tsc", "--outDir", dist, "--declaration", "false", "--noEmit", "false", "--rootDir", "."], { stdio: "inherit" });
+const { __test } = await import(`../${dist}/extensions/index.js?${Date.now()}`);
+
+// Secret redaction: state/debug/observer text must not persist common tokens.
+const redacted = __test.redactSecrets("npm_abcdefghijklmnopqrstuvwxyz sk-abcdefghijklmnopqrstuvwxyz Bearer abcdefghijklmnopqrstuvwxyz token=supersecrettoken");
+assert(!redacted.includes("npm_abcdefghijklmnopqrstuvwxyz"));
+assert(!redacted.includes("sk-abcdefghijklmnopqrstuvwxyz"));
+assert(!redacted.includes("Bearer abcdefghijklmnopqrstuvwxyz"));
+assert(!redacted.includes("supersecrettoken"));
+assert(redacted.includes("[REDACTED_NPM_TOKEN]"));
+
+// Observer prompt limiting: previous observations are capped to a safe tail.
+const huge = Array.from({ length: 5000 }, (_, i) => `* 🔴 old observation ${i}`).join("\n");
+const prompt = __test.buildObserverTaskPrompt(huge, { priorCurrentTask: "continue tests" });
+assert(prompt.length < huge.length / 2, "observer prompt should not include full previous observations");
+assert(prompt.includes("truncated"));
+assert(prompt.includes("continue tests"));
+
+// Stale lock recovery: old operation locks are cleared and recorded as errors.
+const state = __test.createDefaultState({ sessionId: "s", cwd: process.cwd() });
+state.operationLock = { type: "observation", startedAt: new Date(Date.now() - 30 * 60 * 1000).toISOString() };
+state.status = "observing";
+assert.equal(__test.recoverStaleOperationLock(state), true);
+assert.equal(state.operationLock, undefined);
+assert.equal(state.status, "idle");
+assert.match(state.lastError, /Recovered stale OM operation lock/);
+
+// Settings parser: full /om set surface mutates persisted config safely.
+__test.applySetting(state, "observation-model", "google/gemini-2.5-flash");
+__test.applySetting(state, "reflection-threshold", "12345");
+__test.applySetting(state, "caveman", "on");
+__test.applySetting(state, "attachments", "off");
+__test.applySetting(state, "retrieval", "local");
+__test.applySetting(state, "retrieval-top-k", "4");
+__test.applySetting(state, "retrieval-threshold", "25%");
+__test.applySetting(state, "scope", "project");
+assert.equal(state.settings.observationModel, "google/gemini-2.5-flash");
+assert.equal(state.thresholds.reflection, 12345);
+assert.equal(state.settings.caveman, true);
+assert.equal(state.settings.observeAttachments, "off");
+assert.equal(state.settings.retrieval.provider, "local");
+assert.equal(state.settings.retrieval.topK, 4);
+assert.equal(state.settings.retrieval.threshold, 0.25);
+assert.equal(state.scope, "project");
+state.vectorIndex = { provider: "local", model: "local/hash-bow-v1", scopeKey: "session:old", updatedAt: new Date().toISOString(), entries: [] };
+__test.applySetting(state, "scope", "session");
+assert.equal(state.scope, "session");
+assert.equal(state.vectorIndex, undefined);
+assert.throws(() => __test.applySetting(state, "buffer-activation", "2"), /ratio/);
+
+// Migration/normalization: v1 state keeps observations and receives v2 settings.
+const migrated = __test.normalizeState({ version: 1, observations: "token=do-not-keep-this-secret", thresholds: { observation: 10 } }, { sessionId: "m", cwd: process.cwd() });
+assert.equal(migrated.version, 3);
+assert.equal(migrated.thresholds.observation, 10);
+assert.equal(migrated.settings.caveman, false);
+assert.equal(migrated.settings.observeAttachments, "auto");
+assert.equal(migrated.settings.retrieval.provider, "off");
+assert(!migrated.observations.includes("do-not-keep-this-secret"));
+
+// Duplicate suppression and local retrieval: exact/similar repeats are skipped, relevant chunks rank first.
+const deduped = __test.suppressDuplicateObservations("* 🔴 User likes Pi loopflows", "* 🔴 User likes Pi loopflows\n* 🟡 Vector retrieval implemented locally");
+assert(!deduped.includes("User likes Pi loopflows"));
+assert(deduped.includes("Vector retrieval"));
+state.observations = "* 🔴 User builds Pi loopflows\n* 🟡 unrelated cooking note\n* ✅ Vector retrieval implemented locally";
+state.vectorIndex = __test.buildLocalVectorIndex(state);
+const retrieved = await __test.retrieveRelevantObservations({ }, state, "local vector retrieval for loopflows");
+assert(retrieved.includes("Vector retrieval"));
+assert(__test.formatVectorStatus(state).includes("provider: local"));
+
+// Attachment observation: auto mode accepts small images, rejects non-images and oversized payloads.
+state.settings.observeAttachments = "auto";
+assert.equal(__test.shouldObserveAttachment({ type: "image", mimeType: "image/png", data: "abc" }, state), true);
+assert.equal(__test.shouldObserveAttachment({ type: "image", mimeType: "application/pdf", data: "abc" }, state), false);
+assert.equal(__test.shouldObserveAttachment({ type: "image", mimeType: "image/png", data: "x".repeat(3_000_000) }, state), false);
+state.settings.observeAttachments = "off";
+assert.equal(__test.shouldObserveAttachment({ type: "image", mimeType: "image/png", data: "abc" }, state), false);
+
+// Attachment input builder: off/auto never leaks base64 into text; on + unsupported model hard-fails; Gemini model includes image part.
+const attachmentEntry = {
+  id: "att-1",
+  type: "message",
+  timestamp: new Date().toISOString(),
+  message: { role: "user", content: [{ type: "text", text: "see image" }, { type: "image", mimeType: "image/png", data: "aGVsbG8=" }] },
+};
+state.settings.observationModel = "local/text-only";
+state.settings.observeAttachments = "off";
+let built = __test.buildObserverInput({ model: { provider: "local", id: "text-only" } }, [attachmentEntry], state);
+assert(built.text.includes("Attachment omitted"));
+assert(!built.text.includes("aGVsbG8="));
+assert.equal(built.attachmentParts.length, 0);
+state.settings.observeAttachments = "auto";
+built = __test.buildObserverInput({ model: { provider: "local", id: "text-only" } }, [attachmentEntry], state);
+assert(built.text.includes("unsupported observer model"));
+assert.equal(built.attachmentParts.length, 0);
+state.settings.observeAttachments = "on";
+assert.throws(() => __test.buildObserverInput({ model: { provider: "local", id: "text-only" } }, [attachmentEntry], state), /unsupported observer model/);
+state.settings.observationModel = "google/gemini-2.5-flash";
+built = __test.buildObserverInput({ model: { provider: "google", id: "gemini-2.5-flash" } }, [attachmentEntry], state);
+assert.equal(built.attachmentParts.length, 1);
+assert.equal(built.attachmentParts[0].type, "image");
+
+// Atomic write: writes valid JSON, creates backup on subsequent write, removes temp files.
+const dir = await mkdtemp(join(tmpdir(), "pi-om-test-"));
+try {
+  const file = join(dir, "state.json");
+  await __test.atomicWriteJson(file, { a: 1, accessToken: "supersecrettoken", observationTokens: 238, pendingMessageTokens: 12, observations: 'Secret check: api_key="sk-live-test-should-redact-1234567890" stays JSON-safe' });
+  const firstWrite = JSON.parse(await readFile(file, "utf8"));
+  assert.equal(firstWrite.accessToken, "[REDACTED_SECRET]");
+  assert.equal(firstWrite.observationTokens, 238);
+  assert.equal(firstWrite.pendingMessageTokens, 12);
+  assert(firstWrite.observations.includes("[REDACTED_SECRET]"));
+  assert(!firstWrite.observations.includes("sk-live-test-should-redact"));
+  await __test.atomicWriteJson(file, { a: 2 });
+  assert.equal(JSON.parse(await readFile(file, "utf8")).a, 2);
+  assert.equal(existsSync(`${file}.bak`), true);
+} finally {
+  await rm(dir, { recursive: true, force: true });
+  await rm(dist, { recursive: true, force: true });
+}
+
+console.log("pi-observational-memory-extension tests passed");