@memnexus-ai/typescript-sdk 1.45.0 → 1.47.0

package/dist/index.cjs

@@ -49,6 +49,14 @@ __export(index_exports, {
   batchGetMemoriesRequest: () => batchGetMemoriesRequest,
   batchGetMemoriesResponse: () => batchGetMemoriesResponse,
   billingOverview: () => billingOverview,
+  buildContextActiveWork: () => buildContextActiveWork,
+  buildContextActivity: () => buildContextActivity,
+  buildContextFact: () => buildContextFact,
+  buildContextGotcha: () => buildContextGotcha,
+  buildContextMeta: () => buildContextMeta,
+  buildContextPattern: () => buildContextPattern,
+  buildContextRequest: () => buildContextRequest,
+  buildContextResponse: () => buildContextResponse,
   checkoutSessionResponse: () => checkoutSessionResponse,
   community: () => community,
   conversation: () => conversation,
@@ -63,11 +71,14 @@ __export(index_exports, {
   createNarrativeRequest: () => createNarrativeRequest,
   createPortalSessionRequest: () => createPortalSessionRequest,
   default: () => index_default,
+  digestEntity: () => digestEntity,
+  digestKeyFact: () => digestKeyFact,
   digestMetadata: () => digestMetadata,
   digestRequest: () => digestRequest,
   digestResponse: () => digestResponse,
   digestSource: () => digestSource,
   digestTimeRange: () => digestTimeRange,
+  effectiveStateBreakdown: () => effectiveStateBreakdown,
   entity: () => entity,
   entityNode: () => entityNode,
   error: () => error,
@@ -2628,6 +2639,34 @@ var MemoriesService = class extends BaseService {
     }
     return this.client.call(request);
   }
+  /**
+     * Build a context briefing
+     * Answers "What should I know before working on X?" by combining active work
+  detection, fact retrieval, gotcha detection, recent activity, and pattern
+  matching into a single call. Eliminates the 5+ round-trip pattern agents
+  use today.
+  
+     * @param body - Request body
+     */
+  async buildContext(body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/memories/build-context",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
   /**
      * Get version history for a named memory
      * Returns the full version chain for a named memory, ordered newest-first.
@@ -5854,13 +5893,124 @@ var digestSource = import_zod.z.object({
   /** Conversation ID this memory belongs to */
   conversation: import_zod.z.string().optional()
 });
+var digestKeyFact = import_zod.z.object({
+  /** Fact subject */
+  subject: import_zod.z.string(),
+  /** Relationship type */
+  predicate: import_zod.z.string(),
+  /** Fact value */
+  object: import_zod.z.string(),
+  /** Confidence score */
+  confidence: import_zod.z.number().min(0).max(1)
+});
+var digestEntity = import_zod.z.object({
+  /** Entity name */
+  name: import_zod.z.string(),
+  /** Entity type */
+  type: import_zod.z.string()
+});
+var effectiveStateBreakdown = import_zod.z.object({
+  /** Active memories used in synthesis */
+  current: import_zod.z.number().min(0),
+  /** Superseded memories (deprioritized in synthesis) */
+  superseded: import_zod.z.number().min(0),
+  /** Contradicted memories (deprioritized in synthesis) */
+  contradicted: import_zod.z.number().min(0)
+});
 var digestResponse = import_zod.z.lazy(() => import_zod.z.object({
   /** The generated digest content (markdown formatted) */
   digest: import_zod.z.string(),
   /** Generation metadata including source statistics */
   metadata: digestMetadata,
   /** Source memories used to generate the digest, for traceability */
-  sources: import_zod.z.array(digestSource)
+  sources: import_zod.z.array(digestSource),
+  /** Top extracted facts relevant to the digest, deduplicated and ranked by frequency */
+  keyFacts: import_zod.z.array(digestKeyFact).optional(),
+  /** Key entities mentioned across source memories */
+  entities: import_zod.z.array(digestEntity).optional(),
+  /** Breakdown of source memories by effective state (current/superseded/contradicted) */
+  effectiveStateBreakdown: effectiveStateBreakdown.optional()
+}));
+var buildContextRequest = import_zod.z.object({
+  /** What you are about to work on */
+  context: import_zod.z.string().min(1).max(2e3),
+  /** File paths you will be touching */
+  files: import_zod.z.array(import_zod.z.string()).optional(),
+  /** How far back to look for recent activity (hours, default 24) */
+  recentHours: import_zod.z.number().min(1).max(720).optional()
+});
+var buildContextActiveWork = import_zod.z.object({
+  /** Conversation ID */
+  conversationId: import_zod.z.string(),
+  /** Conversation title */
+  title: import_zod.z.string().nullable(),
+  /** ISO 8601 timestamp of last activity */
+  lastActivity: import_zod.z.string(),
+  /** Most recent memory in this conversation */
+  lastMemory: import_zod.z.object({
+    /** Memory ID */
+    id: import_zod.z.string(),
+    /** Truncated content summary */
+    summary: import_zod.z.string()
+  })
+}).nullable();
+var buildContextFact = import_zod.z.object({
+  /** Fact subject */
+  subject: import_zod.z.string(),
+  /** Fact predicate */
+  predicate: import_zod.z.string(),
+  /** Fact object */
+  object: import_zod.z.string(),
+  /** Confidence score (0-1) */
+  confidence: import_zod.z.number(),
+  /** Memory this fact was extracted from */
+  sourceMemoryId: import_zod.z.string()
+});
+var buildContextGotcha = import_zod.z.object({
+  /** The gotcha fact text */
+  fact: import_zod.z.string(),
+  /** Number of distinct source memories mentioning this */
+  sourceCount: import_zod.z.number(),
+  /** Source memory IDs */
+  sourceMemories: import_zod.z.array(import_zod.z.string()),
+  /** ISO 8601 timestamp of most recent source */
+  lastSeen: import_zod.z.string()
+});
+var buildContextActivity = import_zod.z.object({
+  /** Memory ID */
+  id: import_zod.z.string(),
+  /** Truncated content summary (max 200 chars) */
+  summary: import_zod.z.string(),
+  /** ISO 8601 timestamp */
+  date: import_zod.z.string(),
+  /** Conversation ID */
+  conversationId: import_zod.z.string().nullable()
+});
+var buildContextPattern = import_zod.z.object({
+  /** Pattern description */
+  pattern: import_zod.z.string(),
+  /** Confidence score (0-1) */
+  confidence: import_zod.z.number()
+});
+var buildContextMeta = import_zod.z.object({
+  /** Search terms extracted from the context and files */
+  contextTerms: import_zod.z.array(import_zod.z.string()),
+  /** Hours window used for recent activity */
+  recentHours: import_zod.z.number()
+});
+var buildContextResponse = import_zod.z.lazy(() => import_zod.z.object({
+  /** Most relevant active conversation, or null if none found */
+  activeWork: buildContextActiveWork,
+  /** Facts related to the context terms */
+  relevantFacts: import_zod.z.array(buildContextFact),
+  /** Gotchas — facts appearing in 2+ source memories */
+  gotchas: import_zod.z.array(buildContextGotcha),
+  /** Recent relevant memories within the time window */
+  recentActivity: import_zod.z.array(buildContextActivity),
+  /** Behavioral patterns related to the context */
+  relatedPatterns: import_zod.z.array(buildContextPattern),
+  /** Request metadata for transparency */
+  meta: buildContextMeta
 }));
 
 // src/index.ts
@@ -6038,6 +6188,14 @@ var index_default = Memnexus;
   batchGetMemoriesRequest,
   batchGetMemoriesResponse,
   billingOverview,
+  buildContextActiveWork,
+  buildContextActivity,
+  buildContextFact,
+  buildContextGotcha,
+  buildContextMeta,
+  buildContextPattern,
+  buildContextRequest,
+  buildContextResponse,
   checkoutSessionResponse,
   community,
   conversation,
@@ -6051,11 +6209,14 @@ var index_default = Memnexus;
   createMemoryResponseMeta,
   createNarrativeRequest,
   createPortalSessionRequest,
+  digestEntity,
+  digestKeyFact,
   digestMetadata,
   digestRequest,
   digestResponse,
   digestSource,
   digestTimeRange,
+  effectiveStateBreakdown,
   entity,
   entityNode,
   error,