om-memory-system 6.4.0 → 6.5.0

package/dist/core/memorisation-operations.d.ts

@@ -12,7 +12,7 @@ export interface RecallArgs {
     /** Also read as an ID or text when `query` is empty. */
     memoryId?: string;
     content?: string;
-    /** Comma-separated labels. Only memorisations that carry all of them match. */
+    /** Labels. A comma means AND and a bar means OR: `server | reactjs, api` needs api and either of the others. */
     tags?: string;
     limit?: number;
 }
@@ -24,7 +24,7 @@ interface MemorisationContext {
 export declare function runMemorise(args: MemoriseArgs, context: MemorisationContext, tags: ReturnType<typeof getTags>, settings: MemorisationSettings, linked: LinkedSearchSettings): Promise<Record<string, unknown>>;
 /**
  * Fetches memorisations by exact ID, or by text across memorisations only. `tags` keeps only
- * memorisations that carry every label. With `tags` and no text it returns the newest ones.
+ * memorisations that match every label group. With `tags` and no text it returns the newest ones.
  * An exact ID ignores `tags`. Every read covers the whole active space and its linked spaces,
  * so a memorisation is found from any folder. `rerank` (the `memorisationRerank` setting)
  * lets the reranker server reorder the text matches; each match keeps its content-only

package/dist/core/memorisation-operations.js

@@ -1,7 +1,7 @@
 import { memoryClient } from "../services/client.js";
 import { findSnapshotByHostSession, getMemorisationById, listMemorisationsByTags, memorisationIdTaken, } from "../services/memorisation-store.js";
 import { isFullyPrivate, stripPrivateContent } from "../services/privacy.js";
-import { hasAllTags, isMemorisationId, MEMORISATION_TAG, memorisationId, memorisationSizeError, parseTagList, pickRecallMatches, snapshotText, visibleTags, withProjectLabel, } from "./memorisation.js";
+import { matchesTagGroups, isMemorisationId, MEMORISATION_TAG, memorisationId, memorisationSizeError, parseTagGroups, parseTagList, pickRecallMatches, snapshotText, visibleTags, withProjectLabel, } from "./memorisation.js";
 const SNAPSHOT_FIELDS = ["topic", "done", "doing", "next"];
 const BLOCKED = { success: false, error: "Private content blocked" };
 /** Strips `<private>` text. A field that is fully private is dropped. */
@@ -97,7 +97,7 @@ const LABEL_RECALL_LIMIT = 10;
 const LABEL_SEARCH_POOL = 200;
 /**
  * Fetches memorisations by exact ID, or by text across memorisations only. `tags` keeps only
- * memorisations that carry every label. With `tags` and no text it returns the newest ones.
+ * memorisations that match every label group. With `tags` and no text it returns the newest ones.
  * An exact ID ignores `tags`. Every read covers the whole active space and its linked spaces,
  * so a memorisation is found from any folder. `rerank` (the `memorisationRerank` setting)
  * lets the reranker server reorder the text matches; each match keeps its content-only
@@ -105,7 +105,7 @@ const LABEL_SEARCH_POOL = 200;
  */
 export async function runRecall(args, linked, rerank = false) {
     const input = (args.query ?? args.memoryId ?? args.content)?.trim();
-    const wanted = parseTagList(args.tags);
+    const wanted = parseTagGroups(args.tags);
     if (!input && wanted.length === 0) {
         return { success: false, error: "query or tags required: a memorisation ID, text or labels" };
     }
@@ -128,7 +128,7 @@ export async function runRecall(args, linked, rerank = false) {
     if (!result.success)
         return { success: false, error: result.error };
     const mapped = (result.results ?? [])
-        .filter((hit) => hasAllTags(hit.tags, wanted))
+        .filter((hit) => matchesTagGroups(hit.tags, wanted))
         .map((hit) => ({
         id: hit.id,
         content: (hit.memory || hit.chunk),
@@ -149,7 +149,7 @@ export async function runRecall(args, linked, rerank = false) {
         ...(matches.length === 0 ? { message: "No memorisation matched" } : {}),
     };
 }
-/** The newest memorisations that carry every label. They are not ranked, so they have no confidence. */
+/** The newest memorisations that match every label group. They are not ranked, so they have no confidence. */
 async function recallByLabels(wanted, limit) {
     const listed = await listMemorisationsByTags("", wanted, "all-projects", Math.max(1, limit ?? LABEL_RECALL_LIMIT));
     if (!listed.success)

package/dist/core/memorisation.d.ts

@@ -40,8 +40,22 @@ export declare const MEMORISATION_TAG = "memorisation";
 export declare function parseTagList(text: string | undefined): string[];
 /** The labels of a record: its tags without the fixed memorisation tag, in stored order. */
 export declare function visibleTags(tags: string[] | undefined): string[];
-/** True when the record carries every wanted tag. Case and surrounding spaces do not matter. */
-export declare function hasAllTags(recordTags: string[] | undefined, wanted: string[]): boolean;
+/**
+ * The labels in use with the number of records that carry each. Labels that differ only in
+ * letter case or surrounding spaces count as one, shown in the spelling seen first. A record
+ * counts once per label. The fixed memorisation tag is left out. Most records come first, then name.
+ */
+export declare function countLabels(recordTags: ReadonlyArray<string[] | undefined>): {
+    label: string;
+    count: number;
+}[];
+/**
+ * A recall label filter as groups. A comma means AND and a bar means OR, so `server | reactjs, api`
+ * is `[["server", "reactjs"], ["api"]]`: a record needs api and one of server or reactjs.
+ */
+export declare function parseTagGroups(text: string | undefined): string[][];
+/** True when each group has at least one label the record carries. Case and surrounding spaces do not matter. */
+export declare function matchesTagGroups(recordTags: string[] | undefined, groups: string[][]): boolean;
 /**
  * The project name as one more label, after the fixed tag and the caller's labels. The root
  * folder name `/` is not a usable label, so a caller there gets no project label.

package/dist/core/memorisation.js

@@ -69,10 +69,48 @@ export function visibleTags(tags) {
         .map((tag) => tag.trim())
         .filter((tag) => tag && normaliseTag(tag) !== MEMORISATION_TAG);
 }
-/** True when the record carries every wanted tag. Case and surrounding spaces do not matter. */
-export function hasAllTags(recordTags, wanted) {
+/**
+ * The labels in use with the number of records that carry each. Labels that differ only in
+ * letter case or surrounding spaces count as one, shown in the spelling seen first. A record
+ * counts once per label. The fixed memorisation tag is left out. Most records come first, then name.
+ */
+export function countLabels(recordTags) {
+    const counts = new Map();
+    for (const tags of recordTags) {
+        const seen = new Set();
+        for (const label of visibleTags(tags)) {
+            const key = normaliseTag(label);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            const own = counts.get(key);
+            if (own)
+                own.count += 1;
+            else
+                counts.set(key, { label, count: 1 });
+        }
+    }
+    return [...counts.values()].sort((a, b) => b.count - a.count || a.label.localeCompare(b.label));
+}
+/**
+ * A recall label filter as groups. A comma means AND and a bar means OR, so `server | reactjs, api`
+ * is `[["server", "reactjs"], ["api"]]`: a record needs api and one of server or reactjs.
+ */
+export function parseTagGroups(text) {
+    const groups = (text ?? "")
+        .split(",")
+        .map((part) => [...new Set(part.split("|").map(normaliseTag).filter(Boolean))])
+        .filter((group) => group.length > 0);
+    const seen = new Set();
+    return groups.filter((group) => {
+        const key = [...group].sort().join("|");
+        return seen.has(key) ? false : (seen.add(key), true);
+    });
+}
+/** True when each group has at least one label the record carries. Case and surrounding spaces do not matter. */
+export function matchesTagGroups(recordTags, groups) {
     const have = new Set((recordTags ?? []).map(normaliseTag));
-    return wanted.every((tag) => have.has(normaliseTag(tag)));
+    return groups.every((group) => group.some((tag) => have.has(normaliseTag(tag))));
 }
 /**
  * The project name as one more label, after the fixed tag and the caller's labels. The root

package/dist/core/memory-operations.js

@@ -85,7 +85,7 @@ export async function executeMemoryOperation(args, context) {
                         },
                         {
                             command: "recall",
-                            description: "Fetch memorisations only: pass an ms- ID for the exact text, or text for ranked matches with a confidence score. Pass tags (the labels) to keep only memorisations that carry all of them; tags with no query lists the newest ones",
+                            description: "Fetch memorisations only: pass an ms- ID for the exact text, or text for ranked matches with a confidence score. Pass tags (the labels) to keep only memorisations that carry all of them (comma = AND); write a|b for either label (bar = OR), such as server|reactjs,api; tags with no query lists the newest ones",
                             args: ["query?", "tags?", "limit?"],
                         },
                         {

package/dist/services/memorisation-routes.d.ts

@@ -8,7 +8,7 @@ export interface MemorisationRouteConfig {
 }
 /**
  * Routes for the Memorisation page. Returns undefined for paths it does not own.
- * `GET /api/memorisations?tags=a,b` lists, `GET /api/memorisations/recall?q=&tags=` recalls
+ * `GET /api/memorisations?tags=a,b` lists, `GET /api/memorisations/labels` counts the labels, `GET /api/memorisations/recall?q=&tags=` recalls
  * and `POST /api/memorisations/bulk-delete` deletes. Every read covers the whole active
  * space and its linked spaces, so the page works from any folder. The general `/api/memories`
  * delete routes refuse memorisations by design, so this module owns the bulk delete.

package/dist/services/memorisation-routes.js

@@ -1,4 +1,4 @@
-import { isMemorisationId, parseTagList, visibleTags } from "../core/memorisation.js";
+import { isMemorisationId, parseTagGroups, visibleTags } from "../core/memorisation.js";
 /** Enough for any project: a memorisation is capped in size, and the user saves each on purpose. */
 const LIST_LIMIT = 200;
 /** The most IDs one bulk delete takes. */
@@ -10,16 +10,18 @@ const fail = (status, error) => ({
 });
 /**
  * Routes for the Memorisation page. Returns undefined for paths it does not own.
- * `GET /api/memorisations?tags=a,b` lists, `GET /api/memorisations/recall?q=&tags=` recalls
+ * `GET /api/memorisations?tags=a,b` lists, `GET /api/memorisations/labels` counts the labels, `GET /api/memorisations/recall?q=&tags=` recalls
  * and `POST /api/memorisations/bulk-delete` deletes. Every read covers the whole active
  * space and its linked spaces, so the page works from any folder. The general `/api/memories`
  * delete routes refuse memorisations by design, so this module owns the bulk delete.
  * Memorisation text is returned to the page and never written to the log.
  */
 export async function routeMemorisations(path, method, url, config, readBody) {
-    const wanted = parseTagList(url.searchParams.get("tags") ?? undefined);
+    const wanted = parseTagGroups(url.searchParams.get("tags") ?? undefined);
     if (method === "GET" && path === "/api/memorisations")
         return listMemorisations(wanted);
+    if (method === "GET" && path === "/api/memorisations/labels")
+        return listLabels();
     if (method === "GET" && path === "/api/memorisations/recall") {
         return recall(url.searchParams, wanted, config);
     }
@@ -44,6 +46,11 @@ async function listMemorisations(wanted) {
     }));
     return ok({ memorisations });
 }
+async function listLabels() {
+    const { listMemorisationLabels } = await import("./memorisation-store.js");
+    const result = await listMemorisationLabels();
+    return result.success ? ok({ labels: result.labels }) : fail(500, result.error);
+}
 async function recall(params, wanted, config) {
     const text = params.get("q")?.trim();
     if (!text && wanted.length === 0)
@@ -52,7 +59,7 @@ async function recall(params, wanted, config) {
     const { runRecall } = await import("../core/memorisation-operations.js");
     const result = await runRecall({
         query: text,
-        tags: wanted.join(","),
+        tags: wanted.map((group) => group.join("|")).join(","),
         ...(Number.isInteger(limit) && limit > 0 ? { limit } : {}),
     }, config.linked, config.rerank);
     if (result.success !== true) {

package/dist/services/memorisation-store.d.ts

@@ -26,17 +26,28 @@ export declare function findSnapshotByHostSession(hostSessionId: string, contain
     id: string;
 } | null>;
 /**
- * The project's memorisations that carry every tag in `tags`, newest first, in the active
+ * The project's memorisations that match every group in `tags` (a comma is AND, a bar is OR), newest first, in the active
  * space and its linked spaces. The tag filter runs before `limit`, so an old labelled
  * row is not pushed out by newer rows without the label.
  */
-export declare function listMemorisationsByTags(containerTag: string, tags: string[], scope: MemoryScope, limit: number): Promise<{
+export declare function listMemorisationsByTags(containerTag: string, tags: string[][], scope: MemoryScope, limit: number): Promise<{
     success: true;
     memories: ListedMemory[];
 } | {
     success: false;
     error: string;
 }>;
+/** Every label in use across the active space and its linked spaces, with its record count. */
+export declare function listMemorisationLabels(): Promise<{
+    success: true;
+    labels: {
+        label: string;
+        count: number;
+    }[];
+} | {
+    success: false;
+    error: string;
+}>;
 export type MemorisationDeleteOutcome = "deleted" | "not-found" | "linked" | "not-memorisation";
 /**
  * Deletes one memorisation from the active space. A project tag narrows the delete to that

package/dist/services/memorisation-store.js

@@ -1,4 +1,4 @@
-import { hasAllTags, visibleTags } from "../core/memorisation.js";
+import { countLabels, matchesTagGroups, visibleTags } from "../core/memorisation.js";
 import { activeOwner } from "./active-space-access.js";
 import { readLinkedMemory } from "./linked-search.js";
 import { extractScopeFromContainerTag } from "./memory-scope.js";
@@ -78,7 +78,7 @@ export async function findSnapshotByHostSession(hostSessionId, containerTag) {
 /** Far above any real project: a memorisation is capped in size and the user saves each on purpose. */
 const READ_CEILING = 10_000;
 /**
- * The project's memorisations that carry every tag in `tags`, newest first, in the active
+ * The project's memorisations that match every group in `tags` (a comma is AND, a bar is OR), newest first, in the active
  * space and its linked spaces. The tag filter runs before `limit`, so an old labelled
  * row is not pushed out by newer rows without the label.
  */
@@ -90,12 +90,22 @@ export async function listMemorisationsByTags(containerTag, tags, scope, limit)
     if (!result.success)
         return { success: false, error: result.error };
     const memories = result.memories
-        .filter((memory) => hasAllTags(memory.tags, tags))
+        .filter((memory) => matchesTagGroups(memory.tags, tags))
         // Own rows come first from the client, then linked rows. Callers want one timeline.
         .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())
         .slice(0, limit);
     return { success: true, memories };
 }
+/** Every label in use across the active space and its linked spaces, with its record count. */
+export async function listMemorisationLabels() {
+    const result = await memoryClient.listMemories("", READ_CEILING, "all-projects", {
+        includeLinked: true,
+        kind: "memorisation",
+    });
+    if (!result.success)
+        return { success: false, error: result.error };
+    return { success: true, labels: countLabels(result.memories.map((memory) => memory.tags)) };
+}
 /**
  * Deletes one memorisation from the active space. A project tag narrows the delete to that
  * project; `null` matches any project, the rule bulk delete uses. No row is "not-found".