@tuturuuu/ai 0.0.10

package/src/memory/scope.ts

@@ -0,0 +1,102 @@
+import { createHash } from 'node:crypto';
+import type {
+  AiMemoryMetadata,
+  AiMemoryScope,
+  AiMemoryScopeInput,
+} from './types';
+
+const MAX_SUPERMEMORY_ID_LENGTH = 100;
+const SAFE_ID_PATTERN = /[^a-zA-Z0-9._-]+/g;
+
+function safeId(value: string, fallback: string) {
+  const normalized = value.replace(SAFE_ID_PATTERN, '_').replace(/_+/g, '_');
+  const safe = normalized.replace(/^_+|_+$/g, '');
+  return safe || fallback;
+}
+
+function compactId(value: string, fallback: string) {
+  const safe = safeId(value, fallback);
+  if (safe.length <= MAX_SUPERMEMORY_ID_LENGTH) return safe;
+
+  const hash = createHash('sha256').update(safe).digest('hex').slice(0, 12);
+  const prefix = safe.slice(0, MAX_SUPERMEMORY_ID_LENGTH - hash.length - 1);
+  return `${prefix}.${hash}`;
+}
+
+function metadataValueToSafeValue(value: AiMemoryMetadata[string]) {
+  if (Array.isArray(value)) {
+    return value
+      .filter((entry) => typeof entry === 'string')
+      .map((entry) => entry.slice(0, 300));
+  }
+
+  if (typeof value === 'string') return value.slice(0, 1000);
+  return value;
+}
+
+function normalizeMetadata(metadata?: AiMemoryMetadata): AiMemoryMetadata {
+  const normalized: AiMemoryMetadata = {};
+  for (const [key, value] of Object.entries(metadata ?? {})) {
+    const safeKey = safeId(key, 'metadata').slice(0, 80);
+    normalized[safeKey] = metadataValueToSafeValue(value);
+  }
+  return normalized;
+}
+
+export function resolveAiMemoryScope(
+  input: AiMemoryScopeInput
+): AiMemoryScope | null {
+  const userId = input.userId?.trim();
+  const wsId = input.wsId?.trim();
+  if (!userId || !wsId) return null;
+
+  const containerTag = compactId(
+    `tuturuuu.user.${userId}.workspace.${wsId}`,
+    'tuturuuu.user.workspace'
+  );
+  const customId = compactId(
+    [
+      'tuturuuu',
+      input.product,
+      input.surface,
+      input.customId?.trim() || input.source?.trim() || 'request',
+    ].join('.'),
+    'tuturuuu.request'
+  );
+
+  const metadata = normalizeMetadata({
+    ...(input.metadata ?? {}),
+    product: input.product,
+    source: input.source ?? input.surface,
+    surface: input.surface,
+    userId,
+    wsId,
+  });
+
+  return {
+    containerTag,
+    customId,
+    metadata,
+    product: input.product,
+    source: input.source,
+    surface: input.surface,
+    userId,
+    wsId,
+  };
+}
+
+export function buildProductFilter(product: string) {
+  return {
+    filterType: 'metadata' as const,
+    key: 'product',
+    value: product,
+  };
+}
+
+export function buildKeyFilter(key: string) {
+  return {
+    filterType: 'metadata' as const,
+    key: 'memoryKey',
+    value: key,
+  };
+}

package/src/memory/settings.ts

@@ -0,0 +1,121 @@
+import type { AiMemoryProduct, AiMemorySettings } from './types';
+
+const DEFAULT_SETTINGS: AiMemorySettings = {
+  enabled: true,
+  productEnabled: true,
+  products: {},
+};
+
+type RpcSettingsRow = {
+  enabled?: boolean | null;
+  product_enabled?: boolean | null;
+  products?: Record<string, boolean> | null;
+};
+
+type SupabaseRpcClient = {
+  schema: (schema: string) => {
+    rpc: (
+      fn: string,
+      args: Record<string, unknown>
+    ) => Promise<{ data: unknown; error: { message?: string } | null }>;
+  };
+};
+
+async function createDefaultRpcClient() {
+  const { createAdminClient } = await import('@tuturuuu/supabase/next/server');
+  return (await createAdminClient()) as unknown as SupabaseRpcClient;
+}
+
+function normalizeSettings(
+  row: RpcSettingsRow | null | undefined,
+  product: AiMemoryProduct
+): AiMemorySettings {
+  const products = (row?.products ?? {}) as AiMemorySettings['products'];
+  const enabled = row?.enabled ?? DEFAULT_SETTINGS.enabled;
+  const productEnabled =
+    row?.product_enabled ??
+    products[product] ??
+    DEFAULT_SETTINGS.productEnabled;
+
+  return {
+    enabled,
+    productEnabled,
+    products,
+  };
+}
+
+export async function getAiMemorySettings({
+  db,
+  product,
+  userId,
+  wsId,
+}: {
+  db?: SupabaseRpcClient;
+  product: AiMemoryProduct;
+  userId: string;
+  wsId: string;
+}): Promise<AiMemorySettings> {
+  try {
+    const client = db ?? (await createDefaultRpcClient());
+    const { data, error } = await client
+      .schema('private')
+      .rpc('get_ai_memory_settings', {
+        p_product: product,
+        p_user_id: userId,
+        p_ws_id: wsId,
+      });
+
+    if (error) return DEFAULT_SETTINGS;
+
+    const row = Array.isArray(data) ? data[0] : data;
+    return normalizeSettings(row as RpcSettingsRow | null, product);
+  } catch {
+    return DEFAULT_SETTINGS;
+  }
+}
+
+export async function isAiMemoryEnabledForScope(args: {
+  db?: SupabaseRpcClient;
+  product: AiMemoryProduct;
+  userId: string;
+  wsId: string;
+}) {
+  const settings = await getAiMemorySettings(args);
+  return settings.enabled && settings.productEnabled;
+}
+
+export async function disableAiMemoryForMeteringFailure({
+  db,
+  reason,
+  userId,
+  wsId,
+}: {
+  db?: SupabaseRpcClient;
+  reason: string;
+  userId: string;
+  wsId: string;
+}) {
+  try {
+    const client = db ?? (await createDefaultRpcClient());
+    await client.schema('private').rpc('upsert_ai_memory_settings', {
+      p_actor_user_id: userId,
+      p_enabled: false,
+      p_product_settings: {},
+      p_user_id: userId,
+      p_ws_id: wsId,
+    });
+    await client.schema('private').rpc('record_ai_memory_audit', {
+      p_action: 'settings_update',
+      p_actor_user_id: userId,
+      p_metadata: {
+        disabledBy: 'metered_embedding',
+        reason,
+      },
+      p_product: null,
+      p_user_id: userId,
+      p_ws_id: wsId,
+    });
+  } catch {
+    // Memory settings are fail-open elsewhere; disabling is best effort.
+  }
+}

package/src/memory/types.ts

@@ -0,0 +1,101 @@
+import type { LanguageModel } from 'ai';
+
+export const AI_MEMORY_PRODUCTS = [
+  'ai_agents',
+  'ai_chat',
+  'calendar',
+  'education',
+  'finance',
+  'hive',
+  'live_assistant',
+  'meetings',
+  'memories',
+  'mind',
+  'mira',
+  'native_chat',
+  'object_generation',
+  'playground',
+  'rewise',
+  'tasks',
+  'teach',
+] as const;
+
+export type AiMemoryProduct = (typeof AI_MEMORY_PRODUCTS)[number];
+
+export type AiMemoryMetadataValue = string | number | boolean | Array<string>;
+
+export type AiMemoryMetadata = Record<string, AiMemoryMetadataValue>;
+
+export type AiMemoryScopeInput = {
+  customId?: string | null;
+  metadata?: AiMemoryMetadata;
+  product: AiMemoryProduct;
+  source?: string | null;
+  surface: string;
+  userId?: string | null;
+  wsId?: string | null;
+};
+
+export type AiMemoryScope = {
+  containerTag: string;
+  customId: string;
+  metadata: AiMemoryMetadata;
+  product: AiMemoryProduct;
+  source?: string | null;
+  surface: string;
+  userId: string;
+  wsId: string;
+};
+
+export type AiMemorySettings = {
+  enabled: boolean;
+  productEnabled: boolean;
+  products: Partial<Record<AiMemoryProduct, boolean>>;
+};
+
+export type AiMemoryConfig = {
+  apiKey: string;
+  baseUrl?: string;
+  enabled: boolean;
+  failOpen: boolean;
+  timeoutMs: number;
+};
+
+export type AiMemoryResult<T> =
+  | { ok: true; skipped?: false; value: T }
+  | { ok: true; reason: string; skipped: true; value?: T }
+  | { error: string; ok: false; skipped?: false };
+
+export type AiMemorySearchResult = {
+  id: string;
+  key?: string | null;
+  metadata: AiMemoryMetadata | null;
+  score: number;
+  updatedAt: string;
+  value: string;
+};
+
+export type AiMemoryDocument = {
+  category?: string | null;
+  content?: string | null;
+  id: string;
+  key?: string | null;
+  metadata: AiMemoryMetadata | null;
+  status: string;
+  summary?: string | null;
+  title?: string | null;
+  updatedAt: string;
+};
+
+export type AiMemoryModelOptions<TModel extends LanguageModel = LanguageModel> =
+  {
+    addMemory?: 'always' | 'never';
+    customId?: string | null;
+    mode?: 'profile' | 'query' | 'full';
+    model: TModel;
+    product: AiMemoryProduct;
+    source?: string | null;
+    surface: string;
+    userId?: string | null;
+    wsId?: string | null;
+  };

package/src/memory/workspace.ts

@@ -0,0 +1,36 @@
+import type { TypedSupabaseClient } from '@tuturuuu/supabase/types';
+import { ROOT_WORKSPACE_ID } from '@tuturuuu/utils/constants';
+
+export async function resolveAiMemoryWorkspaceIdForUser({
+  fallbackWsId = ROOT_WORKSPACE_ID,
+  supabase,
+  userId,
+}: {
+  fallbackWsId?: string;
+  supabase: TypedSupabaseClient;
+  userId: string;
+}) {
+  try {
+    const { data: userPrivateDetails } = await supabase
+      .from('user_private_details')
+      .select('default_workspace_id')
+      .eq('user_id', userId)
+      .maybeSingle();
+
+    if (userPrivateDetails?.default_workspace_id) {
+      return userPrivateDetails.default_workspace_id;
+    }
+
+    const { data: personalWorkspace } = await supabase
+      .from('workspaces')
+      .select('id, workspace_members!inner(user_id)')
+      .eq('personal', true)
+      .eq('workspace_members.user_id', userId)
+      .limit(1)
+      .maybeSingle();
+
+    return personalWorkspace?.id ?? fallbackWsId;
+  } catch {
+    return fallbackWsId;
+  }
+}

package/src/memory.ts

@@ -0,0 +1 @@
+export * from './memory/index';

package/src/mind/patch.ts

@@ -0,0 +1,146 @@
+import type {
+  MindAiPatch,
+  MindBoardSnapshot,
+  MindEdge,
+  MindNode,
+} from './types';
+
+const NOW = '1970-01-01T00:00:00.000Z';
+
+function createNode(node: Parameters<typeof normalizeNode>[0]) {
+  return normalizeNode(node);
+}
+
+function normalizeNode(
+  node: Partial<MindNode> &
+    Pick<MindNode, 'id' | 'positionX' | 'positionY' | 'title'>
+): MindNode {
+  return {
+    body: node.body ?? null,
+    color: node.color ?? null,
+    createdAt: node.createdAt ?? NOW,
+    height: node.height ?? 120,
+    horizon: node.horizon ?? 'year',
+    id: node.id,
+    metadata: node.metadata ?? {},
+    nodeType: node.nodeType ?? 'idea',
+    parentNodeId: node.parentNodeId ?? null,
+    positionX: node.positionX,
+    positionY: node.positionY,
+    status: node.status ?? 'planned',
+    title: node.title,
+    updatedAt: node.updatedAt ?? NOW,
+    width: node.width ?? 240,
+  };
+}
+
+function normalizeEdge(
+  edge: Partial<MindEdge> &
+    Pick<MindEdge, 'id' | 'sourceNodeId' | 'targetNodeId'>
+): MindEdge {
+  return {
+    color: edge.color ?? null,
+    createdAt: edge.createdAt ?? NOW,
+    edgeType: edge.edgeType ?? 'relates_to',
+    id: edge.id,
+    label: edge.label ?? null,
+    metadata: edge.metadata ?? {},
+    sourceNodeId: edge.sourceNodeId,
+    targetNodeId: edge.targetNodeId,
+    updatedAt: edge.updatedAt ?? NOW,
+    weight: edge.weight ?? 1,
+  };
+}
+
+export function applyMindPatchToSnapshot(
+  snapshot: MindBoardSnapshot,
+  patch: MindAiPatch
+): MindBoardSnapshot {
+  let nodes: MindNode[] = snapshot.nodes.map((node: MindNode) => ({ ...node }));
+  let edges: MindEdge[] = snapshot.edges.map((edge: MindEdge) => ({ ...edge }));
+
+  for (const operation of patch.operations) {
+    if (operation.kind === 'create_node') {
+      const nextNode = createNode(operation.node);
+      nodes = [
+        ...nodes.filter((node: MindNode) => node.id !== nextNode.id),
+        nextNode,
+      ];
+      continue;
+    }
+
+    if (operation.kind === 'update_node') {
+      nodes = nodes.map((node: MindNode) =>
+        node.id === operation.nodeId
+          ? {
+              ...node,
+              ...Object.fromEntries(
+                Object.entries(operation).filter(
+                  ([key, value]) =>
+                    key !== 'id' &&
+                    key !== 'kind' &&
+                    key !== 'nodeId' &&
+                    value !== undefined
+                )
+              ),
+            }
+          : node
+      );
+      continue;
+    }
+
+    if (operation.kind === 'delete_node') {
+      nodes = nodes.filter((node: MindNode) => node.id !== operation.nodeId);
+      edges = edges.filter(
+        (edge: MindEdge) =>
+          edge.sourceNodeId !== operation.nodeId &&
+          edge.targetNodeId !== operation.nodeId
+      );
+      continue;
+    }
+
+    if (operation.kind === 'create_edge') {
+      const nextEdge = normalizeEdge(operation.edge);
+      edges = [
+        ...edges.filter((edge: MindEdge) => edge.id !== nextEdge.id),
+        nextEdge,
+      ];
+      continue;
+    }
+
+    if (operation.kind === 'update_edge') {
+      edges = edges.map((edge: MindEdge) =>
+        edge.id === operation.edgeId
+          ? {
+              ...edge,
+              ...Object.fromEntries(
+                Object.entries(operation).filter(
+                  ([key, value]) =>
+                    key !== 'edgeId' &&
+                    key !== 'id' &&
+                    key !== 'kind' &&
+                    value !== undefined
+                )
+              ),
+            }
+          : edge
+      );
+      continue;
+    }
+
+    if (operation.kind === 'delete_edge') {
+      edges = edges.filter((edge: MindEdge) => edge.id !== operation.edgeId);
+    }
+  }
+
+  const nodeIds = new Set(nodes.map((node: MindNode) => node.id));
+
+  return {
+    ...snapshot,
+    edges: edges.filter(
+      (edge: MindEdge) =>
+        nodeIds.has(edge.sourceNodeId) && nodeIds.has(edge.targetNodeId)
+    ),
+    nodes,
+  };
+}