@alisio/plugin-memory 0.1.0-alpha.9 → 0.1.0

package/dist/index.js

@@ -9,6 +9,7 @@ import { COMPACTION_GUIDANCE, formatObservation, MEMORY_PROTOCOL, memoryLine, OB
 import { projectId, SQLiteMemoryStore } from "./store.js";
 import { memoryContextText, memoryTools } from "./tools.js";
 import { loadVersion } from "./version.js";
+import { memoryViews } from "./views.js";
 const userTexts = (messages) => messages.flatMap((m) => (m.role === "user" && !m.summary && m.text.trim() ? [m.text] : []));
 function transcript(messages, maxChars = 60_000) {
     const lines = messages.map((m) => m.role === "user"
@@ -91,6 +92,9 @@ export function createMemoryPlugin(rawOptions, context) {
             };
             for (const tool of memoryTools(deps))
                 api.tools.register(tool);
+            // Read-only data views for the web UI. A core without `api.views` simply lacks the tab.
+            for (const view of memoryViews({ store: db, project }))
+                api.views?.register(view);
             api.context.register(async () => MEMORY_PROTOCOL);
             api.compaction.register({
                 async beforeCompact() {
@@ -141,7 +145,17 @@ export function createMemoryPlugin(rawOptions, context) {
             });
             api.session.onStart(async (info) => {
                 refresh();
-                return memoryContextText(deps, info.sessionId);
+                const text = memoryContextText(deps, info.sessionId);
+                // Remember what this chat was given so the web can show it without parsing the transcript.
+                if (text) {
+                    try {
+                        db.saveInjectedContext(project, info.sessionId, text);
+                    }
+                    catch {
+                        /* A bookkeeping failure never blocks the context itself. */
+                    }
+                }
+                return text;
             });
             api.session.onEnd(async (info) => {
                 const prompts = userTexts(info.messages);

package/dist/store.d.ts

@@ -1,5 +1,7 @@
 import type { SqlDatabase } from "@alisio/sdk";
-import type { MemoryHit, MemoryInput, MemoryRecord, MemoryStore, SaveAction, SearchOptions, SessionSummary } from "./types.ts";
+import type { MemoryHit, MemoryInput, MemoryRecord, MemoryStore, SaveAction, SearchOptions, SessionRecord, SessionRecordsQuery, SessionSummary } from "./types.ts";
+/** Largest context text kept per session (the 20 000-token budget at 4 characters per token). */
+export declare const MAX_INJECTED_CONTEXT = 80000;
 export declare const MAX_OBSERVATION_LENGTH = 50000;
 /** Stable project id: `<basename>-<sha256(realpath)[0:8]>` of the git root or cwd. */
 export declare function projectId(path: string): Promise<string>;
@@ -12,7 +14,9 @@ export declare class SQLiteMemoryStore implements MemoryStore {
         now?: () => number;
         dedupWindowMs?: number;
     });
+    private applied;
     private migrate;
+    private migrateBase;
     save(input: MemoryInput): {
         id: number;
         action: SaveAction;
@@ -36,6 +40,20 @@ export declare class SQLiteMemoryStore implements MemoryStore {
     }[];
     saveSummary(project: string, session: string, content: string): string;
     lastSummary(project: string): SessionSummary | undefined;
+    recordsOfSession(project: string, session: string, query: SessionRecordsQuery): {
+        items: SessionRecord[];
+        total: number;
+        hasMore: boolean;
+    };
+    summaryRow(project: string, session: string): {
+        content: string;
+        updatedAt: number;
+    } | undefined;
+    saveInjectedContext(project: string, session: string, content: string): void;
+    injectedContext(project: string, session: string): {
+        content: string;
+        injectedAt: number;
+    } | undefined;
     /** Session summary of one session, used to confirm an archive write. */
     summaryOf(session: string): string | undefined;
     close(): void;

package/dist/store.js

@@ -4,6 +4,10 @@ import { basename } from "node:path";
 import { ftsQuery, normalizeTopicKey, rankScore, redactPrivate } from "./format.js";
 /** Memory schema versions live at 100+ so the file can be shared with the session store. */
 const MEMORY_SCHEMA_VERSION = 100;
+/** Adds `injected_context` (what the plugin put in a chat when it started). */
+const INJECTED_CONTEXT_VERSION = 101;
+/** Largest context text kept per session (the 20 000-token budget at 4 characters per token). */
+export const MAX_INJECTED_CONTEXT = 80_000;
 export const MAX_OBSERVATION_LENGTH = 50_000;
 const TRUNCATED = "... [truncated]";
 const SNIPPET = 300;
@@ -41,9 +45,22 @@ export class SQLiteMemoryStore {
         this.db.exec("PRAGMA journal_mode=WAL; PRAGMA busy_timeout=5000; CREATE TABLE IF NOT EXISTS schema_migrations(version INTEGER PRIMARY KEY);");
         this.migrate();
     }
+    applied(version) {
+        return !!this.db.prepare("SELECT 1 FROM schema_migrations WHERE version=?").get(version);
+    }
     migrate() {
-        if (this.db.prepare("SELECT 1 FROM schema_migrations WHERE version=?").get(MEMORY_SCHEMA_VERSION))
-            return;
+        if (!this.applied(MEMORY_SCHEMA_VERSION))
+            this.migrateBase();
+        if (!this.applied(INJECTED_CONTEXT_VERSION))
+            this.db.transaction(() => {
+                this.db.exec(`CREATE TABLE IF NOT EXISTS injected_context(session_id TEXT PRIMARY KEY, project TEXT NOT NULL,
+             content TEXT NOT NULL, created_at INTEGER NOT NULL);`);
+                this.db
+                    .prepare("INSERT OR IGNORE INTO schema_migrations VALUES(?)")
+                    .run(INJECTED_CONTEXT_VERSION);
+            });
+    }
+    migrateBase() {
         this.db.transaction(() => {
             this.db.exec(`
           CREATE TABLE IF NOT EXISTS observations(id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -266,6 +283,88 @@ export class SQLiteMemoryStore {
             ? { project: row.project, session: row.id, content: row.summary, createdAt: row.ended_at }
             : undefined;
     }
+    recordsOfSession(project, session, query) {
+        const like = (text) => `%${text.replace(/[\\%_]/g, "\\$&")}%`;
+        const filters = [
+            "o.session_id=?",
+            VISIBLE,
+            ...(query.type ? ["o.type=?"] : []),
+            ...(query.text
+                ? [
+                    "(o.title LIKE ? ESCAPE '\\' OR o.content LIKE ? ESCAPE '\\' OR COALESCE(o.topic_key,'') LIKE ? ESCAPE '\\')",
+                ]
+                : []),
+        ];
+        const params = [
+            session,
+            project,
+            ...(query.type ? [query.type] : []),
+            ...(query.text ? [like(query.text), like(query.text), like(query.text)] : []),
+        ];
+        const total = this.db
+            .prepare(`SELECT COUNT(*) AS n FROM observations o WHERE ${filters.join(" AND ")}`)
+            .get(...params).n;
+        const after = query.after;
+        const page = after
+            ? [
+                ...filters,
+                "(o.pinned<? OR (o.pinned=? AND o.updated_at<?) OR (o.pinned=? AND o.updated_at=? AND o.id<?))",
+            ]
+            : filters;
+        const pageParams = after
+            ? [
+                ...params,
+                after.pinned,
+                after.pinned,
+                after.updatedAt,
+                after.pinned,
+                after.updatedAt,
+                after.id,
+            ]
+            : params;
+        const limit = Math.min(Math.max(query.limit, 1), 50);
+        const rows = this.db
+            .prepare(`SELECT o.* FROM observations o WHERE ${page.join(" AND ")}
+         ORDER BY o.pinned DESC, o.updated_at DESC, o.id DESC LIMIT ?`)
+            .all(...pageParams, limit + 1);
+        return {
+            total,
+            hasMore: rows.length > limit,
+            items: rows.slice(0, limit).map((r) => ({
+                id: r.id,
+                type: r.type,
+                title: r.title,
+                content: r.content,
+                scope: r.scope,
+                ...(r.topic_key ? { topicKey: r.topic_key } : {}),
+                ...(r.tool_name ? { source: r.tool_name } : {}),
+                pinned: !!r.pinned,
+                createdAt: r.created_at,
+                updatedAt: r.updated_at,
+                revisionCount: r.revision_count,
+                duplicateCount: r.duplicate_count,
+            })),
+        };
+    }
+    summaryRow(project, session) {
+        const row = this.db
+            .prepare("SELECT summary, ended_at FROM memory_sessions WHERE id=? AND project=? AND summary IS NOT NULL")
+            .get(session, project);
+        return row ? { content: row.summary, updatedAt: row.ended_at ?? 0 } : undefined;
+    }
+    saveInjectedContext(project, session, content) {
+        this.db
+            .prepare(`INSERT INTO injected_context(session_id,project,content,created_at) VALUES(?,?,?,?)
+         ON CONFLICT(session_id) DO UPDATE SET project=excluded.project, content=excluded.content,
+           created_at=excluded.created_at`)
+            .run(session, project, cap(content, MAX_INJECTED_CONTEXT), this.now());
+    }
+    injectedContext(project, session) {
+        const row = this.db
+            .prepare("SELECT content, created_at FROM injected_context WHERE session_id=? AND project=?")
+            .get(session, project);
+        return row ? { content: row.content, injectedAt: row.created_at } : undefined;
+    }
     /** Session summary of one session, used to confirm an archive write. */
     summaryOf(session) {
         const row = this.db.prepare("SELECT summary FROM memory_sessions WHERE id=?").get(session);

package/dist/types.d.ts

@@ -41,6 +41,35 @@ export interface SessionSummary {
     content: string;
     createdAt: number;
 }
+/** One row of the "saved in this chat" list (full body, capped by the caller). */
+export interface SessionRecord {
+    id: number;
+    type: MemoryType;
+    title: string;
+    content: string;
+    scope: MemoryScope;
+    topicKey?: string;
+    /** Producer, e.g. memory_save or compaction. */
+    source?: string;
+    pinned: boolean;
+    createdAt: number;
+    updatedAt: number;
+    revisionCount: number;
+    duplicateCount: number;
+}
+/** Keyset position in the `pinned DESC, updated_at DESC, id DESC` order. */
+export interface RecordsCursor {
+    pinned: 0 | 1;
+    updatedAt: number;
+    id: number;
+}
+export interface SessionRecordsQuery {
+    type?: MemoryType;
+    /** Case-insensitive substring of title, content or topic key (literal, not a pattern). */
+    text?: string;
+    limit: number;
+    after?: RecordsCursor;
+}
 export interface SearchOptions {
     limit?: number;
     type?: MemoryType;
@@ -79,5 +108,25 @@ export interface MemoryStore {
     /** Summary of one session, used to confirm an archive write. */
     summaryOf(session: string): string | undefined;
     lastSummary(project: string): SessionSummary | undefined;
+    /**
+     * Read-only listing for the web "Memory" tab: this chat's records (visible to the project),
+     * pinned first then newest, by keyset. Never touches access counters or timestamps.
+     */
+    recordsOfSession(project: string, session: string, query: SessionRecordsQuery): {
+        items: SessionRecord[];
+        total: number;
+        hasMore: boolean;
+    };
+    /** Summary stored for one session of this project (read-only). */
+    summaryRow(project: string, session: string): {
+        content: string;
+        updatedAt: number;
+    } | undefined;
+    /** Remembers the context injected at session start, one row per session. */
+    saveInjectedContext(project: string, session: string, content: string): void;
+    injectedContext(project: string, session: string): {
+        content: string;
+        injectedAt: number;
+    } | undefined;
     close(): void;
 }

package/dist/views.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Read-only data views of the memory plugin for the web "Memory" tab. They never write: every
+ * query is a plain SELECT (no access counters, no timestamps). Ids and shapes are a contract with
+ * the web (`records`, `summary`, `context`); see specs/alisio-web-memory-tab-v1.md.
+ */
+import { type ViewDefinition } from "@alisio/sdk";
+import { type MemoryStore, type RecordsCursor } from "./types.ts";
+/** Per-entry content cap in a list (the full body stays available through `/memory show`). */
+export declare const ENTRY_CONTENT_CAP = 10000;
+/** Cap of the summary and context texts shown in the tab. */
+export declare const TEXT_CAP = 50000;
+export interface MemoryViewDeps {
+    store: MemoryStore;
+    project: string;
+}
+export declare const encodeCursor: (cursor: RecordsCursor) => string;
+export declare function decodeCursor(text: string): RecordsCursor;
+export declare function memoryViews({ store, project }: MemoryViewDeps): ViewDefinition[];

package/dist/views.js

@@ -0,0 +1,103 @@
+/**
+ * Read-only data views of the memory plugin for the web "Memory" tab. They never write: every
+ * query is a plain SELECT (no access counters, no timestamps). Ids and shapes are a contract with
+ * the web (`records`, `summary`, `context`); see specs/alisio-web-memory-tab-v1.md.
+ */
+import { ViewParamsError } from "@alisio/sdk";
+import { MEMORY_TYPES } from "./types.js";
+/** Per-entry content cap in a list (the full body stays available through `/memory show`). */
+export const ENTRY_CONTENT_CAP = 10_000;
+/** Cap of the summary and context texts shown in the tab. */
+export const TEXT_CAP = 50_000;
+const DEFAULT_LIMIT = 20;
+export const encodeCursor = (cursor) => Buffer.from(JSON.stringify([cursor.pinned, cursor.updatedAt, cursor.id])).toString("base64url");
+export function decodeCursor(text) {
+    try {
+        const value = JSON.parse(Buffer.from(text, "base64url").toString("utf8"));
+        if (Array.isArray(value) &&
+            value.length === 3 &&
+            (value[0] === 0 || value[0] === 1) &&
+            Number.isSafeInteger(value[1]) &&
+            Number.isSafeInteger(value[2]))
+            return { pinned: value[0], updatedAt: value[1], id: value[2] };
+    }
+    catch {
+        /* falls through to the error below */
+    }
+    throw new ViewParamsError("Invalid cursor");
+}
+const clip = (text, max) => ({
+    text: text.length > max ? text.slice(0, max) : text,
+    truncated: text.length > max,
+});
+export function memoryViews({ store, project }) {
+    return [
+        {
+            id: "records",
+            description: "Memory records saved in the session, pinned first, then newest first",
+            params: {
+                type: "object",
+                properties: {
+                    type: { type: "string", enum: [...MEMORY_TYPES] },
+                    q: { type: "string", maxLength: 200 },
+                    limit: { type: "integer", minimum: 1, maximum: 50, default: DEFAULT_LIMIT },
+                    cursor: { type: "string", maxLength: 200 },
+                },
+            },
+            handler(params, context) {
+                const text = typeof params.q === "string" ? params.q.trim() : "";
+                const page = store.recordsOfSession(project, context.sessionId, {
+                    ...(typeof params.type === "string" ? { type: params.type } : {}),
+                    ...(text ? { text } : {}),
+                    limit: typeof params.limit === "number" ? params.limit : DEFAULT_LIMIT,
+                    ...(typeof params.cursor === "string" && params.cursor
+                        ? { after: decodeCursor(params.cursor) }
+                        : {}),
+                });
+                const last = page.items.at(-1);
+                return {
+                    items: page.items.map(({ content, ...entry }) => {
+                        const body = clip(content, ENTRY_CONTENT_CAP);
+                        return { ...entry, content: body.text, contentTruncated: body.truncated };
+                    }),
+                    total: page.total,
+                    ...(page.hasMore && last
+                        ? {
+                            next: encodeCursor({
+                                pinned: last.pinned ? 1 : 0,
+                                updatedAt: last.updatedAt,
+                                id: last.id,
+                            }),
+                        }
+                        : {}),
+                };
+            },
+        },
+        {
+            id: "summary",
+            description: "The session summary the memory plugin stored for the session",
+            handler(_params, context) {
+                const row = store.summaryRow(project, context.sessionId);
+                if (!row)
+                    return { summary: null };
+                const body = clip(row.content, TEXT_CAP);
+                return {
+                    summary: { content: body.text, updatedAt: row.updatedAt, truncated: body.truncated },
+                };
+            },
+        },
+        {
+            id: "context",
+            description: "The memory context the plugin injected when the session started",
+            handler(_params, context) {
+                const row = store.injectedContext(project, context.sessionId);
+                if (!row)
+                    return { context: null };
+                const body = clip(row.content, TEXT_CAP);
+                return {
+                    context: { content: body.text, injectedAt: row.injectedAt, truncated: body.truncated },
+                };
+            },
+        },
+    ];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alisio/plugin-memory",
-  "version": "0.1.0-alpha.9",
+  "version": "0.1.0",
   "description": "Engram-style persistent memory for Alisio: SQLite FTS5 observations with topic-key upserts, memory-aware compaction, session summaries and recall tools. Built-in, disableable plugin.",
   "author": "Gustavo Gutiérrez",
   "license": "MIT",
@@ -46,10 +46,10 @@
     "zod": "4.6.5"
   },
   "peerDependencies": {
-    "@alisio/sdk": "^0.1.0-alpha.11"
+    "@alisio/sdk": "^0.1.0"
   },
   "devDependencies": {
-    "@alisio/sdk": "0.1.0-alpha.11"
+    "@alisio/sdk": "0.1.0"
   },
   "publishConfig": {
     "access": "public",