convex-supermemory 0.0.1

package/src/component/lib.ts

@@ -0,0 +1,224 @@
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server.js";
+
+const documentStatusValidator = v.union(
+  v.literal("unknown"),
+  v.literal("queued"),
+  v.literal("extracting"),
+  v.literal("chunking"),
+  v.literal("embedding"),
+  v.literal("indexing"),
+  v.literal("done"),
+  v.literal("failed"),
+);
+
+const memoryValidator = v.object({
+  _id: v.id("memories"),
+  _creationTime: v.number(),
+  memoryId: v.string(),
+  containerTag: v.string(),
+  content: v.string(),
+  isStatic: v.boolean(),
+  metadata: v.optional(v.string()),
+  forgetAfter: v.optional(v.number()),
+  forgetReason: v.optional(v.string()),
+  forgotten: v.boolean(),
+  createdAt: v.number(),
+  updatedAt: v.number(),
+});
+
+const documentValidator = v.object({
+  _id: v.id("documents"),
+  _creationTime: v.number(),
+  documentId: v.string(),
+  containerTag: v.string(),
+  content: v.optional(v.string()),
+  customId: v.optional(v.string()),
+  metadata: v.optional(v.string()),
+  status: documentStatusValidator,
+  title: v.optional(v.string()),
+  summary: v.optional(v.string()),
+  createdAt: v.number(),
+  updatedAt: v.number(),
+});
+
+// ─── Queries ────────────────────────────────────────────────────────────────
+
+export const getMemory = query({
+  args: { memoryId: v.string() },
+  returns: v.union(v.null(), memoryValidator),
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query("memories")
+      .withIndex("by_memoryId", (q) => q.eq("memoryId", args.memoryId))
+      .first();
+  },
+});
+
+export const listMemories = query({
+  args: { containerTag: v.string(), limit: v.optional(v.number()) },
+  returns: v.array(memoryValidator),
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query("memories")
+      .withIndex("by_containerTag", (q) => q.eq("containerTag", args.containerTag))
+      .order("desc")
+      .take(args.limit ?? 100);
+  },
+});
+
+export const getDocument = query({
+  args: { documentId: v.string() },
+  returns: v.union(v.null(), documentValidator),
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query("documents")
+      .withIndex("by_documentId", (q) => q.eq("documentId", args.documentId))
+      .first();
+  },
+});
+
+export const listDocuments = query({
+  args: { containerTag: v.string(), limit: v.optional(v.number()) },
+  returns: v.array(documentValidator),
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query("documents")
+      .withIndex("by_containerTag", (q) => q.eq("containerTag", args.containerTag))
+      .order("desc")
+      .take(args.limit ?? 50);
+  },
+});
+
+// ─── Mutations ──────────────────────────────────────────────────────────────
+
+export const recordMemory = mutation({
+  args: {
+    memoryId: v.string(),
+    containerTag: v.string(),
+    content: v.string(),
+    isStatic: v.boolean(),
+    metadata: v.optional(v.string()),
+    forgetAfter: v.optional(v.number()),
+    forgetReason: v.optional(v.string()),
+  },
+  returns: v.id("memories"),
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    const existing = await ctx.db
+      .query("memories")
+      .withIndex("by_memoryId", (q) => q.eq("memoryId", args.memoryId))
+      .first();
+
+    if (existing) {
+      await ctx.db.patch(existing._id, { ...args, updatedAt: now });
+      return existing._id;
+    }
+
+    return await ctx.db.insert("memories", {
+      ...args,
+      forgotten: false,
+      createdAt: now,
+      updatedAt: now,
+    });
+  },
+});
+
+export const markMemoryForgotten = mutation({
+  args: { memoryId: v.string() },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    const existing = await ctx.db
+      .query("memories")
+      .withIndex("by_memoryId", (q) => q.eq("memoryId", args.memoryId))
+      .first();
+    if (!existing) return null;
+    await ctx.db.patch(existing._id, { forgotten: true, updatedAt: Date.now() });
+    return null;
+  },
+});
+
+export const recordDocument = mutation({
+  args: {
+    documentId: v.string(),
+    containerTag: v.string(),
+    content: v.optional(v.string()),
+    customId: v.optional(v.string()),
+    metadata: v.optional(v.string()),
+    status: documentStatusValidator,
+    title: v.optional(v.string()),
+    summary: v.optional(v.string()),
+  },
+  returns: v.id("documents"),
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    const existing = await ctx.db
+      .query("documents")
+      .withIndex("by_documentId", (q) => q.eq("documentId", args.documentId))
+      .first();
+
+    if (existing) {
+      await ctx.db.patch(existing._id, { ...args, updatedAt: now });
+      return existing._id;
+    }
+
+    return await ctx.db.insert("documents", {
+      ...args,
+      createdAt: now,
+      updatedAt: now,
+    });
+  },
+});
+
+export const deleteDocument = mutation({
+  args: { documentId: v.string() },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    const existing = await ctx.db
+      .query("documents")
+      .withIndex("by_documentId", (q) => q.eq("documentId", args.documentId))
+      .first();
+    if (existing) {
+      await ctx.db.delete(existing._id);
+    }
+    return null;
+  },
+});
+
+// ─── Dashboard / history ────────────────────────────────────────────────────
+
+export const getStats = query({
+  args: {},
+  returns: v.object({ memories: v.number(), documents: v.number() }),
+  handler: async (ctx) => {
+    const [memories, documents] = await Promise.all([
+      ctx.db.query("memories").collect(),
+      ctx.db.query("documents").collect(),
+    ]);
+    return { memories: memories.length, documents: documents.length };
+  },
+});
+
+// Every memory, newest first, regardless of containerTag — for a history view
+// that doesn't require already knowing which container to look under.
+export const listRecentMemories = query({
+  args: { limit: v.optional(v.number()) },
+  returns: v.array(memoryValidator),
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query("memories")
+      .order("desc")
+      .take(args.limit ?? 30);
+  },
+});
+
+export const listRecentDocuments = query({
+  args: { limit: v.optional(v.number()) },
+  returns: v.array(documentValidator),
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query("documents")
+      .order("desc")
+      .take(args.limit ?? 30);
+  },
+});

package/src/component/schema.ts

@@ -0,0 +1,43 @@
+import { defineSchema, defineTable } from "convex/server";
+import { v } from "convex/values";
+
+export default defineSchema({
+  memories: defineTable({
+    memoryId: v.string(),
+    containerTag: v.string(),
+    content: v.string(),
+    isStatic: v.boolean(),
+    metadata: v.optional(v.string()),
+    forgetAfter: v.optional(v.number()),
+    forgetReason: v.optional(v.string()),
+    forgotten: v.boolean(),
+    createdAt: v.number(),
+    updatedAt: v.number(),
+  })
+    .index("by_memoryId", ["memoryId"])
+    .index("by_containerTag", ["containerTag"]),
+
+  documents: defineTable({
+    documentId: v.string(),
+    containerTag: v.string(),
+    content: v.optional(v.string()),
+    customId: v.optional(v.string()),
+    metadata: v.optional(v.string()),
+    status: v.union(
+      v.literal("unknown"),
+      v.literal("queued"),
+      v.literal("extracting"),
+      v.literal("chunking"),
+      v.literal("embedding"),
+      v.literal("indexing"),
+      v.literal("done"),
+      v.literal("failed"),
+    ),
+    title: v.optional(v.string()),
+    summary: v.optional(v.string()),
+    createdAt: v.number(),
+    updatedAt: v.number(),
+  })
+    .index("by_documentId", ["documentId"])
+    .index("by_containerTag", ["containerTag"]),
+});

package/src/component/setup.test.ts

@@ -0,0 +1,11 @@
+/// <reference types="vite/client" />
+import { test } from "vitest";
+import schema from "./schema.js";
+import { convexTest } from "convex-test";
+export const modules = import.meta.glob("./**/*.*s");
+
+export function initConvexTest() {
+  const t = convexTest(schema, modules);
+  return t;
+}
+test("setup", () => {});

package/src/test.ts

@@ -0,0 +1,18 @@
+/// <reference types="vite/client" />
+import type { TestConvex } from "convex-test";
+import type { GenericSchema, SchemaDefinition } from "convex/server";
+import schema from "./component/schema.js";
+const modules = import.meta.glob("./component/**/*.ts");
+
+/**
+ * Register the component with the test convex instance.
+ * @param t - The test convex instance, e.g. from calling `convexTest`.
+ * @param name - The name of the component, as registered in convex.config.ts.
+ */
+export function register(
+  t: TestConvex<SchemaDefinition<GenericSchema, boolean>>,
+  name: string = "convexSupermemory",
+) {
+  t.registerComponent(name, schema, modules);
+}
+export default { register, schema, modules };