om-memory-system 4.31.1 → 4.32.0

package/dist/services/skill-learning/turn-summaries.d.ts

@@ -13,12 +13,18 @@ export interface SkillTurnSummary {
     failedToolCalls: number;
 }
 /**
- * The newest turns that used one skill. `path` is null for a skill that no
- * watched folder holds. A missing `skills.db` gives no turns and stays missing.
+ * Turns that used one skill, newest first, `limit` of them after skipping
+ * `offset`. `path` is null for a skill that no watched folder holds. A missing
+ * `skills.db` gives no turns and stays missing.
  */
 export declare function recentSkillTurns(store: SkillStore, skill: {
     name: string;
     path: string | null;
-}, index: SkillIndex, limit?: number): Promise<SkillTurnSummary[]>;
+}, index: SkillIndex, limit?: number, offset?: number): Promise<SkillTurnSummary[]>;
+/** How many recorded turns used this skill. */
+export declare function countSkillTurns(store: SkillStore, skill: {
+    name: string;
+    path: string | null;
+}, index: SkillIndex): Promise<number>;
 /** The turns with these ids, newest first; ids of deleted turns are left out. */
 export declare function skillTurnsByIds(store: SkillStore, ids: readonly number[]): Promise<SkillTurnSummary[]>;

package/dist/services/skill-learning/turn-summaries.js

@@ -17,42 +17,54 @@ function toSummary(row) {
 // The same use-to-skill rule as the ranking: a recorded path counts while the
 // index lists it; a use with no path belongs to the one watched skill with its name.
 const BY_PATH = `
-SELECT ${COLUMNS} FROM turns t WHERE t.id IN (
-  SELECT su.turn_id FROM skill_uses su
-  WHERE su.skill_path = ? OR (su.skill_path IS NULL AND su.skill_name = ? AND ? = 1)
-) ORDER BY t.created_at DESC, t.id DESC LIMIT ?`;
+SELECT su.turn_id FROM skill_uses su
+WHERE su.skill_path = ? OR (su.skill_path IS NULL AND su.skill_name = ? AND ? = 1)`;
 const BY_NAME = `
-SELECT ${COLUMNS} FROM turns t WHERE t.id IN (
-  SELECT su.turn_id FROM skill_uses su
-  WHERE su.skill_name = ? AND (
-    (su.skill_path IS NOT NULL AND su.skill_path NOT IN (SELECT value FROM json_each(?)))
-    OR (su.skill_path IS NULL AND ? = 0)
-  )
-) ORDER BY t.created_at DESC, t.id DESC LIMIT ?`;
+SELECT su.turn_id FROM skill_uses su
+WHERE su.skill_name = ? AND (
+  (su.skill_path IS NOT NULL AND su.skill_path NOT IN (SELECT value FROM json_each(?)))
+  OR (su.skill_path IS NULL AND ? = 0)
+)`;
+/** The SQL that selects a skill's turn ids, and its parameters. */
+function turnIdsFor(skill, index) {
+    const named = index.entries.filter((e) => e.name === skill.name);
+    return skill.path
+        ? {
+            sql: BY_PATH,
+            args: [skill.path, skill.name, named.length === 1 && named[0].path === skill.path ? 1 : 0],
+        }
+        : {
+            sql: BY_NAME,
+            args: [
+                skill.name,
+                JSON.stringify(index.entries.map((e) => e.path)),
+                named.length === 1 ? 1 : 0,
+            ],
+        };
+}
 /**
- * The newest turns that used one skill. `path` is null for a skill that no
- * watched folder holds. A missing `skills.db` gives no turns and stays missing.
+ * Turns that used one skill, newest first, `limit` of them after skipping
+ * `offset`. `path` is null for a skill that no watched folder holds. A missing
+ * `skills.db` gives no turns and stays missing.
  */
-export async function recentSkillTurns(store, skill, index, limit = RECENT_TURN_LIMIT) {
+export async function recentSkillTurns(store, skill, index, limit = RECENT_TURN_LIMIT, offset = 0) {
     const db = await store.existingDb();
     if (!db)
         return [];
-    const named = index.entries.filter((e) => e.name === skill.name);
-    const rows = skill.path
-        ? await db.all(BY_PATH, [
-            skill.path,
-            skill.name,
-            named.length === 1 && named[0].path === skill.path ? 1 : 0,
-            limit,
-        ])
-        : await db.all(BY_NAME, [
-            skill.name,
-            JSON.stringify(index.entries.map((e) => e.path)),
-            named.length === 1 ? 1 : 0,
-            limit,
-        ]);
+    const ids = turnIdsFor(skill, index);
+    const rows = await db.all(`SELECT ${COLUMNS} FROM turns t WHERE t.id IN (${ids.sql})
+     ORDER BY t.created_at DESC, t.id DESC LIMIT ? OFFSET ?`, [...ids.args, limit, offset]);
     return rows.map(toSummary);
 }
+/** How many recorded turns used this skill. */
+export async function countSkillTurns(store, skill, index) {
+    const db = await store.existingDb();
+    if (!db)
+        return 0;
+    const ids = turnIdsFor(skill, index);
+    const row = await db.get(`SELECT COUNT(*) AS n FROM turns t WHERE t.id IN (${ids.sql})`, ids.args);
+    return Number(row?.n ?? 0);
+}
 /** The turns with these ids, newest first; ids of deleted turns are left out. */
 export async function skillTurnsByIds(store, ids) {
     const db = await store.existingDb();

package/dist/services/skill-routes.js

@@ -1,14 +1,20 @@
 import { existsSync } from "node:fs";
 import { RECORDING_OFF_TEXT, runSkillOperation, } from "../core/skill-operations.js";
 import { log } from "./logger.js";
+import { skillActivity, skillDaily } from "./skill-learning/activity.js";
+import { parseActivityQuery, topParam } from "./skill-learning/activity-range.js";
 import { undoProposal } from "./skill-learning/apply.js";
+import { skillHistory, withCanUndo } from "./skill-learning/history.js";
 import { skillOperationsDeps } from "./skill-learning/operations-deps.js";
 import { getProposal, listProposals, setSkillMode, } from "./skill-learning/proposal-store.js";
+import { intParam } from "./skill-learning/query-params.js";
 import { SKILL_ORDERS, rankSkills } from "./skill-learning/ranking.js";
 import { skillTurnSettingsFor } from "./skill-learning/settings-for.js";
 import { getSkillIndex } from "./skill-learning/skill-index.js";
 import { SkillStore, SkillStoreError, skillsDbPath } from "./skill-learning/store.js";
-import { recentSkillTurns, skillTurnsByIds } from "./skill-learning/turn-summaries.js";
+import { RECENT_TURN_LIMIT, countSkillTurns, recentSkillTurns, skillTurnsByIds, } from "./skill-learning/turn-summaries.js";
+const MAX_PAGE = 200;
+const DEFAULT_PAGE = 20;
 const PROPOSAL_STATES = [
     "pending",
     "applied",
@@ -123,10 +129,19 @@ async function dispatch(path, method, url, readBody, ctx) {
                 redact: settings.redact,
             });
         }
-        if (path === "/api/skills/skill")
-            return showSkill(url, store, index(), now);
+        if (path === "/api/skills/skill") {
+            return showSkill(url, { store, folders: settings.folders }, index(), now);
+        }
+        if (path === "/api/skills/activity") {
+            const query = parseActivityQuery(url, now);
+            if ("error" in query)
+                return fail("invalid-args", query.error);
+            return ok("ok", await skillActivity(store, index(), now, query, topParam(url)));
+        }
+        if (path === "/api/skills/history")
+            return history(url, store, settings.folders);
         if (path === "/api/skills/proposals")
-            return proposals(url, store);
+            return proposals(url, store, settings.folders);
         const one = /^\/api\/skills\/proposals\/([^/]+)$/.exec(path);
         if (one) {
             const proposal = await getProposal(store, decodeURIComponent(one[1]));
@@ -168,7 +183,8 @@ async function dispatch(path, method, url, readBody, ctx) {
     }
     return undefined;
 }
-async function showSkill(url, store, index, now) {
+async function showSkill(url, deps, index, now) {
+    const { store } = deps;
     const path = text(url.searchParams.get("path"));
     const name = text(url.searchParams.get("name"));
     if (!path && !name)
@@ -176,13 +192,19 @@ async function showSkill(url, store, index, now) {
     const skill = (await rankSkills(store, index, now)).find((s) => path ? s.path === path : s.path === null && s.name === name);
     if (!skill)
         return fail("not-found", "No such skill");
+    const limit = intParam(url, "turnLimit", 1, MAX_PAGE, RECENT_TURN_LIMIT);
+    const offset = intParam(url, "turnOffset", 0, Number.MAX_SAFE_INTEGER, 0);
     return ok("ok", {
         skill,
-        recentTurns: await recentSkillTurns(store, skill, index),
-        proposals: skill.path ? await listProposals(store, { skillPath: skill.path }) : [],
+        recentTurns: await recentSkillTurns(store, skill, index, limit, offset),
+        turnTotal: await countSkillTurns(store, skill, index),
+        daily: await skillDaily(store, index, skill, now),
+        proposals: skill.path
+            ? await withCanUndo(deps, await listProposals(store, { skillPath: skill.path }))
+            : [],
     });
 }
-async function proposals(url, store) {
+async function proposals(url, store, folders) {
     const state = text(url.searchParams.get("state"));
     const skill = text(url.searchParams.get("skill"));
     if (state && !PROPOSAL_STATES.includes(state)) {
@@ -196,7 +218,22 @@ async function proposals(url, store) {
         filter.skillPath = skill;
     else if (skill)
         filter.skillName = skill;
-    return ok("ok", { proposals: await listProposals(store, filter) });
+    const all = await listProposals(store, filter);
+    // Without limit or offset the whole list comes back, as before.
+    const offset = intParam(url, "offset", 0, Number.MAX_SAFE_INTEGER, 0);
+    const limit = intParam(url, "limit", 1, MAX_PAGE, all.length || 1);
+    const paged = url.searchParams.has("limit") || url.searchParams.has("offset");
+    const shown = paged ? all.slice(offset, offset + limit) : all;
+    return ok("ok", { proposals: await withCanUndo({ store, folders }, shown), total: all.length });
+}
+async function history(url, store, folders) {
+    const path = text(url.searchParams.get("path"));
+    const name = text(url.searchParams.get("name"));
+    if (!path && !name)
+        return fail("invalid-args", "Give path or name");
+    const limit = intParam(url, "limit", 1, MAX_PAGE, DEFAULT_PAGE);
+    const offset = intParam(url, "offset", 0, Number.MAX_SAFE_INTEGER, 0);
+    return ok("ok", await skillHistory({ store, folders }, { path, name }, limit, offset));
 }
 async function undo(id, store, folders) {
     if (!id)