dsh-trivium 0.2.0

package/lib/tokens.js

@@ -0,0 +1,28 @@
+/** Cheap, checkable token estimate for injection budgets (CJK ≈ 1, ASCII ≈ 1/4). */
+
+export function estimateTokens(text) {
+  const s = String(text || "");
+  let tokens = 0;
+  for (const ch of s) {
+    const code = ch.codePointAt(0) ?? 0;
+    if (code <= 0x7f) tokens += 0.25;
+    else if (code <= 0x7ff) tokens += 0.5;
+    else tokens += 1;
+  }
+  return Math.ceil(tokens);
+}
+
+export function clipToTokenBudget(text, budget) {
+  const raw = String(text || "");
+  const cap = Math.max(1, Number(budget) || 400);
+  if (estimateTokens(raw) <= cap) return raw;
+  let lo = 0;
+  let hi = raw.length;
+  while (lo < hi) {
+    const mid = Math.ceil((lo + hi) / 2);
+    if (estimateTokens(raw.slice(0, mid)) <= cap) lo = mid;
+    else hi = mid - 1;
+  }
+  const cut = Math.max(0, lo - 1);
+  return `${raw.slice(0, cut)}…`;
+}

package/lib/tools.js

@@ -0,0 +1,216 @@
+import { defineTool } from "@deepseek-ai/dsh-tools";
+import { EDGE_LABELS, looksSecret } from "./schema.js";
+import {
+  dbPathFor,
+  embedQueryVector,
+  findMergeTarget,
+  formatHit,
+  insertNode,
+  listIncomingBusiness,
+  mergeInto,
+  openWorkspaceDb,
+  searchNodes,
+  ensureLink,
+} from "./store.js";
+
+const WRITE_TOOLS = new Set(["ctx_remember", "ctx_link"]);
+
+const TEXT_OUTPUT = {
+  schema: { type: "string" },
+  render: (_args, value) => [{ type: "text", text: value }],
+};
+
+function textTool(definition) {
+  const write = WRITE_TOOLS.has(definition.name);
+  return defineTool({
+    ...definition,
+    output: TEXT_OUTPUT,
+    isConcurrencySafe: write ? () => false : () => true,
+    presentCall: (args) => ({
+      card: "generic",
+      kind: write ? "edit" : definition.name === "ctx_find" ? "search" : "read",
+      title: definition.name,
+      rawInput: args,
+    }),
+  });
+}
+
+export function cwdOf(agentOrExec) {
+  const agent = agentOrExec?.agent ?? agentOrExec;
+  return (
+    agent?.session?.header?.cwd ||
+    process.env.DSH_CWD ||
+    process.cwd()
+  );
+}
+
+async function dbOf(exec) {
+  return openWorkspaceDb(cwdOf(exec));
+}
+
+export function registerTools(ctx, optionsOrFn) {
+  const optionsOf = typeof optionsOrFn === "function" ? optionsOrFn : () => optionsOrFn || {};
+  const writeApprovalOf = () => optionsOf().writeApproval === true;
+
+  ctx.effect(
+    () =>
+      ctx.tools.register(
+        textTool({
+          name: "ctx_find",
+          description:
+            "Search local Trivium graph memory. If the query names a known entity, also returns its unexpired about/decided/broke/fixed neighbors. Returns L0 summaries plus edge paths (incoming as <-label-id). Call ctx_read for full text. Do not paste find results verbatim into later thinking.",
+          parameters: {
+            query: { type: "string", required: true, description: "Search query." },
+            top_k: { type: "integer", description: "Max hits, 1-20." },
+          },
+          async execute(args, exec) {
+            try {
+              const options = optionsOf();
+              const db = await dbOf(exec);
+              const k = Math.max(1, Math.min(20, args.top_k || options.topK || 8));
+              const queryVector = await embedQueryVector(args.query);
+              const hits = searchNodes(db, args.query, {
+                topK: k,
+                expandDepth: options.expandDepth ?? 1,
+                queryVector: queryVector || undefined,
+              });
+              if (!hits.length) return "No memory hits.";
+              const grouped = [];
+              let lastType = "";
+              for (const hit of hits) {
+                const row = formatHit(db, hit);
+                if (row.type !== lastType) {
+                  grouped.push(`## ${row.type}`);
+                  lastType = row.type;
+                }
+                grouped.push(
+                  `[${row.score.toFixed(3)}] id=${row.id} type=${row.type}${row.until ? ` until=${row.until}` : ""}${row.stale ? " stale" : ""}\n${row.l0}\npath: ${row.path.join(" | ") || "(none)"}`,
+                );
+              }
+              return grouped.join("\n\n");
+            } catch (err) {
+              return `ctx_find unavailable: ${err.message}`;
+            }
+          },
+        }),
+      ),
+    "dsh-trivium.ctx_find",
+  );
+
+  ctx.effect(
+    () =>
+      ctx.tools.register(
+        textTool({
+          name: "ctx_read",
+          description: "Read one memory node by numeric id returned from ctx_find. Includes incoming about/decided/broke/fixed edges.",
+          parameters: {
+            id: { type: "integer", required: true, description: "Node id." },
+          },
+          async execute(args, exec) {
+            try {
+              const db = await dbOf(exec);
+              const node = db.get(Number(args.id));
+              if (!node) return `Not found: ${args.id}`;
+              return JSON.stringify(
+                {
+                  id: node.id,
+                  payload: node.payload,
+                  edges: node.edges,
+                  incoming: listIncomingBusiness(db, node.id),
+                },
+                null,
+                2,
+              );
+            } catch (err) {
+              return `ctx_read unavailable: ${err.message}`;
+            }
+          },
+        }),
+      ),
+    "dsh-trivium.ctx_read",
+  );
+
+  ctx.effect(
+    () =>
+      ctx.tools.register(
+        textTool({
+          name: "ctx_remember",
+          description:
+            "Store a durable fact as an entity, preference, decision, or experience. Do not store secrets or one-off task instructions.",
+          parameters: {
+            text: { type: "string", required: true, description: "Fact to store." },
+            type: {
+              type: "string",
+              description: "entity | preference | decision | experience",
+            },
+            name: { type: "string", description: "Short name for entities." },
+            link_to: { type: "integer", description: "Optional existing node id to link." },
+            link_label: { type: "string", description: "Edge label when link_to is set." },
+          },
+          async execute(args, exec) {
+            try {
+              if (looksSecret(args.text)) return "Refused: looks like a secret.";
+              const type = ["entity", "preference", "decision", "experience"].includes(
+                args.type,
+              )
+                ? args.type
+                : "preference";
+              const db = await dbOf(exec);
+              const incoming = {
+                type,
+                name: args.name || undefined,
+                text: args.text,
+                uri: `ctx://${type}/${Date.now()}`,
+                source: { sessionId: String(exec?.agent?.session?.header?.id || exec?.agent?.id || "") },
+              };
+              const existing = findMergeTarget(db, incoming);
+              const id =
+                existing != null ? mergeInto(db, existing, incoming) : insertNode(db, incoming);
+              if (args.link_to) {
+                const label = args.link_label || EDGE_LABELS.about;
+                ensureLink(db, id, Number(args.link_to), label);
+              }
+              return `Remembered id=${id} type=${type} db=${dbPathFor(cwdOf(exec))}`;
+            } catch (err) {
+              return `ctx_remember failed: ${err.message}`;
+            }
+          },
+        }),
+      ),
+    "dsh-trivium.ctx_remember",
+  );
+
+  ctx.effect(
+    () =>
+      ctx.tools.register(
+        textTool({
+          name: "ctx_link",
+          description: "Create a directed edge between two memory node ids.",
+          parameters: {
+            from: { type: "integer", required: true, description: "Source node id." },
+            to: { type: "integer", required: true, description: "Target node id." },
+            label: { type: "string", description: "Edge label, default about." },
+          },
+          async execute(args, exec) {
+            try {
+              const db = await dbOf(exec);
+              const label = args.label || EDGE_LABELS.about;
+              ensureLink(db, Number(args.from), Number(args.to), label);
+              return `Linked ${args.from} -[${label}]-> ${args.to}`;
+            } catch (err) {
+              return `ctx_link failed: ${err.message}`;
+            }
+          },
+        }),
+      ),
+    "dsh-trivium.ctx_link",
+  );
+
+  ctx.on("tools/pre-execute", async (exec, next) => {
+    if (!writeApprovalOf() || !WRITE_TOOLS.has(exec.name)) return next();
+    return {
+      kind: "ask",
+      reason: `dsh-trivium wants to persist ${exec.name}`,
+    };
+  });
+}

package/lib/until.js

@@ -0,0 +1,85 @@
+/** Display `until` is a label; `untilAt` is an absolute instant we can filter on. */
+
+const WEEKDAYS = {
+  sunday: 0,
+  monday: 1,
+  tuesday: 2,
+  wednesday: 3,
+  thursday: 4,
+  friday: 5,
+  saturday: 6,
+};
+
+/** Pull a display `until` label out of a fact sentence. */
+export function parseUntilFromText(text) {
+  const s = String(text || "");
+  if (/下周/.test(s)) return "下周";
+  const day = s.match(/\buntil\s+(Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday)\b/i);
+  if (day) return day[1];
+  const iso = s.match(/\b(\d{4}-\d{2}-\d{2})\b/);
+  if (iso) return iso[1];
+  const cn = s.match(/到?(\d{1,2}\s*月\d{1,2}\s*日|周五|周末)/);
+  if (cn) return cn[1];
+  return undefined;
+}
+
+export function resolveUntilAt(until, from = new Date()) {
+  const raw = String(until || "").trim();
+  if (!raw) return undefined;
+  const iso = raw.match(/^(\d{4}-\d{2}-\d{2})(?:[T\s]|$)/);
+  if (iso) {
+    const ms = Date.parse(`${iso[1]}T23:59:59.000Z`);
+    return Number.isFinite(ms) ? new Date(ms).toISOString() : undefined;
+  }
+  const fromDate = from instanceof Date ? from : new Date(from);
+  if (Number.isNaN(fromDate.getTime())) return undefined;
+  if (raw === "下周") {
+    return endOfDayUtc(addDays(fromDate, 7)).toISOString();
+  }
+  if (raw === "周五" || raw === "周末") {
+    const want = raw === "周末" ? 6 : 5;
+    return endOfDayUtc(nextWeekday(fromDate, want)).toISOString();
+  }
+  const day = raw.match(/^(Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday)$/i);
+  if (day) {
+    const want = WEEKDAYS[day[1].toLowerCase()];
+    return endOfDayUtc(nextWeekday(fromDate, want)).toISOString();
+  }
+  return undefined;
+}
+
+export function isStalePayload(payload, now = new Date()) {
+  const at = payload?.untilAt || resolveUntilAt(payload?.until, payload?.createdAt || now);
+  if (!at) return false;
+  const ms = Date.parse(at);
+  return Number.isFinite(ms) && ms < now.getTime();
+}
+
+export function queryMentionsUntil(query, payload) {
+  const q = String(query || "").trim().toLowerCase();
+  if (!q) return false;
+  if (/下周|until|周五|周末|过期|到期|postpone|defer|friday|monday|tuesday|wednesday|thursday|saturday|sunday/.test(q)) {
+    return true;
+  }
+  const until = String(payload?.until || "").trim().toLowerCase();
+  return until.length >= 2 && q.includes(until);
+}
+
+function addDays(date, n) {
+  const next = new Date(date.getTime());
+  next.setUTCDate(next.getUTCDate() + n);
+  return next;
+}
+
+function endOfDayUtc(date) {
+  const next = new Date(date.getTime());
+  next.setUTCHours(23, 59, 59, 0);
+  return next;
+}
+
+function nextWeekday(from, weekday) {
+  const next = new Date(from.getTime());
+  const delta = (weekday - next.getUTCDay() + 7) % 7 || 7;
+  next.setUTCDate(next.getUTCDate() + delta);
+  return next;
+}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "dsh-trivium",
+  "version": "0.2.0",
+  "description": "In-process graph memory kernel for DeepSeek Harness, backed by TriviumDB.",
+  "license": "MIT",
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./lib/client.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "cordis.patch.yml",
+    "README.md",
+    "LICENSE"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-ui-settings"
+      ],
+      "platform": "web"
+    }
+  },
+  "scripts": {
+    "link-dsh": "node scripts/link-dsh.mjs",
+    "smoke-p0": "node scripts/smoke-p0.mjs",
+    "smoke-p1": "node scripts/smoke-p1.mjs",
+    "smoke-p2": "node scripts/p2-cases.mjs",
+    "smoke-p3": "node scripts/smoke-p3.mjs",
+    "smoke-p4": "node scripts/smoke-p4.mjs",
+    "smoke-p5": "node scripts/smoke-p5.mjs",
+    "verify-live-p2": "node scripts/verify-live-p2.mjs"
+  },
+  "engines": {
+    "node": "^22.19.0 || >=24"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/dsh-llm": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-tools": "0.1.0-rc.6"
+  },
+  "dependencies": {
+    "triviumdb": "^0.7.4"
+  },
+  "keywords": [
+    "dsh-plugin",
+    "deepseek-harness",
+    "dsh",
+    "triviumdb",
+    "memory",
+    "graph",
+    "context"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/QWQcool/dsh-trivium.git"
+  },
+  "bugs": {
+    "url": "https://github.com/QWQcool/dsh-trivium/issues"
+  },
+  "homepage": "https://github.com/QWQcool/dsh-trivium#readme"
+}