@redplanethq/sdk 0.1.2 → 0.1.4

package/dist/index.d.ts

@@ -53,9 +53,25 @@ declare const LLMModelType: {
 };
 type LLMModelType = (typeof LLMModelType)[keyof typeof LLMModelType];
 
-declare enum EpisodeType {
-    Conversation = "CONVERSATION",
-    Text = "TEXT"
+/**
+ * Interface for document node in the reified knowledge graph
+ * Documents are parent containers for episodic chunks
+ */
+interface DocumentNode {
+    uuid: string;
+    title: string;
+    originalContent: string;
+    metadata: Record<string, any>;
+    source: string;
+    userId: string;
+    createdAt: Date;
+    validAt: Date;
+    totalChunks: number;
+    sessionId?: string;
+    version: number;
+    contentHash: string;
+    previousVersionUuid?: string;
+    chunkHashes?: string[];
 }
 /**
  * Interface for episodic node in the reified knowledge graph
@@ -74,7 +90,23 @@ interface EpisodicNode {
     userId: string;
     space?: string;
     sessionId?: string;
+    recallCount?: number;
+    chunkIndex?: number;
+    labelIds?: string[];
 }
+/**
+ * Episodic node without embeddings for query responses
+ * Use this type when returning episodes from Cypher queries to avoid loading large embedding arrays
+ */
+type EpisodicNodeWithoutEmbeddings = Omit<EpisodicNode, "contentEmbedding">;
+/**
+ * Helper to get episodic node properties for Cypher RETURN clause (excludes embeddings)
+ * Usage in Cypher: RETURN ${EPISODIC_NODE_PROPERTIES} as episode
+ */
+declare const EPISODIC_NODE_PROPERTIES = "{\n  uuid: e.uuid,\n  content: e.content,\n  originalContent: e.originalContent,\n  createdAt: e.createdAt,\n  userId: e.userId,\n  sessionId: e.sessionId,\n  labelIds: e.labelIds,\n  validAt: e.validAt,\n  recallCount: e.recallCount,\n  chunkIndex: e.chunkIndex\n}";
+declare const STATEMENT_NODE_PROPERTIES = "{\n  uuid: s.uuid,\n  fact: s.fact,\n  createdAt: s.createdAt,\n  userId: s.userId,\n  validAt: s.validAt,\n  invalidAt: s.invalidAt,\n  invalidatedBy: s.invalidatedBy,\n  attributes: s.attributes,\n  recallCount: s.recallCount,\n  provenanceCount: s.provenanceCount\n}";
+declare const ENTITY_NODE_PROPERTIES = "{\n  uuid: ent.uuid,\n  name: ent.name,\n  createdAt: ent.createdAt,\n  userId: ent.userId,\n  attributes: ent.attributes\n}";
+declare const COMPACTED_SESSION_NODE_PROPERTIES = "{\n  uuid: cs.uuid,\n  sessionId: cs.sessionId,\n  summary: cs.summary,\n  episodeCount: cs.episodeCount,\n  startTime: cs.startTime,\n  endTime: cs.endTime,\n  createdAt: cs.createdAt,\n  updatedAt: cs.updatedAt,\n  confidence: cs.confidence,\n  userId: cs.userId,\n  source: cs.source,\n  compressionRatio: cs.compressionRatio,\n  metadata: cs.metadata\n}";
 /**
  * Interface for entity node in the reified knowledge graph
  * Entities represent subjects, objects, or predicates in statements
@@ -82,13 +114,11 @@ interface EpisodicNode {
 interface EntityNode {
     uuid: string;
     name: string;
-    type: string;
-    attributes: Record<string, any>;
-    nameEmbedding: number[];
-    typeEmbedding: number[];
+    type?: string;
+    nameEmbedding?: number[];
+    attributes?: Record<string, any>;
     createdAt: Date;
     userId: string;
-    space?: string;
 }
 /**
  * Interface for statement node in the reified knowledge graph
@@ -101,9 +131,16 @@ interface StatementNode {
     createdAt: Date;
     validAt: Date;
     invalidAt: Date | null;
+    invalidatedBy?: string;
     attributes: Record<string, any>;
     userId: string;
     space?: string;
+    labelIds?: string[];
+    recallCount?: {
+        low: number;
+        high: number;
+    };
+    provenanceCount?: number;
 }
 /**
  * Interface for a triple in the reified knowledge graph
@@ -117,14 +154,25 @@ interface Triple {
     object: EntityNode;
     provenance: EpisodicNode;
 }
+declare enum EpisodeTypeEnum {
+    CONVERSATION = "CONVERSATION",
+    DOCUMENT = "DOCUMENT"
+}
+declare const EpisodeType: {
+    CONVERSATION: string;
+    DOCUMENT: string;
+    IMAGE: string;
+};
+type EpisodeType = (typeof EpisodeType)[keyof typeof EpisodeType];
 type AddEpisodeParams = {
     episodeBody: string;
     referenceTime: Date;
-    metadata: Record<string, any>;
+    metadata?: Record<string, any>;
     source: string;
     userId: string;
     spaceId?: string;
     sessionId?: string;
+    type?: EpisodeType;
 };
 type AddEpisodeResult = {
     episodeUuid: string;
@@ -134,13 +182,29 @@ type AddEpisodeResult = {
 };
 interface ExtractedTripleData {
     source: string;
-    sourceType: string;
+    sourceType?: string;
     predicate: string;
     target: string;
-    targetType: string;
+    targetType?: string;
     fact: string;
     attributes?: Record<string, any>;
 }
+interface CompactedSessionNode {
+    uuid: string;
+    sessionId: string;
+    summary: string;
+    summaryEmbedding?: number[];
+    episodeCount: number;
+    startTime: Date;
+    endTime: Date;
+    createdAt: Date;
+    updatedAt?: Date;
+    confidence: number;
+    userId: string;
+    source: string;
+    compressionRatio?: number;
+    metadata?: Record<string, any>;
+}
 
 declare enum ActionStatusEnum {
     ACCEPT = "ACCEPT",
@@ -199,10 +263,23 @@ declare enum IntegrationEventType {
     /**
      * For returning integration metadata/config
      */
-    SPEC = "spec"
+    SPEC = "spec",
+    /**
+     * For to start mcp
+     */
+    MCP = "mcp"
+}
+interface IntegrationDefinition {
+    name: string;
+    version: string;
+    description: string;
 }
 interface IntegrationEventPayload {
     event: IntegrationEventType;
+    integrationDefinition?: IntegrationDefinition;
+    eventBody: any;
+    config?: Config;
+    state?: Record<string, string>;
     [x: string]: any;
 }
 declare class Spec {
@@ -220,7 +297,7 @@ declare class Spec {
 }
 interface Config {
     access_token: string;
-    [key: string]: any;
+    [key: string]: string;
 }
 interface Identifier {
     id: string;
@@ -238,6 +315,235 @@ declare enum UserTypeEnum {
     System = "System"
 }
 
+interface SpaceNode {
+    uuid: string;
+    name: string;
+    description?: string;
+    userId: string;
+    createdAt: Date;
+    updatedAt: Date;
+    isActive: boolean;
+    contextCount?: number;
+    embedding?: number[];
+}
+interface CreateSpaceParams {
+    name: string;
+    description?: string;
+    userId: string;
+    workspaceId: string;
+}
+interface UpdateSpaceParams {
+    name?: string;
+    description?: string;
+    icon?: string;
+    status?: string;
+}
+interface SpaceWithStatements extends SpaceNode {
+    statements: any[];
+}
+interface AssignStatementsParams {
+    statementIds: string[];
+    spaceId: string;
+    userId: string;
+}
+interface SpaceAssignmentResult {
+    success: boolean;
+    statementsUpdated: number;
+    error?: string;
+}
+interface SpaceDeletionResult {
+    deleted: boolean;
+    statementsUpdated: number;
+    error?: string;
+}
+
+type UserConfirmationStatus = "pending" | "accepted" | "rejected" | "edited";
+interface SpacePattern {
+    id: string;
+    name: string;
+    source: "explicit" | "implicit";
+    type: string;
+    summary: string;
+    editedSummary?: string;
+    evidence: string[];
+    confidence: number;
+    userConfirmed: UserConfirmationStatus;
+    spaceId: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface CreatePatternParams {
+    name: string;
+    source: "explicit" | "implicit";
+    type: string;
+    summary: string;
+    editedSummary?: string;
+    evidence: string[];
+    confidence: number;
+    userConfirmed?: UserConfirmationStatus;
+    spaceId: string;
+}
+interface PatternDetectionResult {
+    explicitPatterns: Omit<SpacePattern, "id" | "createdAt" | "updatedAt" | "spaceId">[];
+    implicitPatterns: Omit<SpacePattern, "id" | "createdAt" | "updatedAt" | "spaceId">[];
+    totalPatternsFound: number;
+    processingStats: {
+        statementsAnalyzed: number;
+        themesProcessed: number;
+        implicitPatternsExtracted: number;
+    };
+}
+interface PatternConfirmationParams {
+    patternId: string;
+    confirmed: boolean;
+}
+declare const EXPLICIT_PATTERN_TYPES: {
+    readonly THEME: "theme";
+    readonly TOPIC: "topic";
+    readonly DOMAIN: "domain";
+    readonly INTEREST_AREA: "interest_area";
+};
+declare const IMPLICIT_PATTERN_TYPES: {
+    readonly PREFERENCE: "preference";
+    readonly HABIT: "habit";
+    readonly WORKFLOW: "workflow";
+    readonly COMMUNICATION_STYLE: "communication_style";
+    readonly DECISION_PATTERN: "decision_pattern";
+    readonly TEMPORAL_PATTERN: "temporal_pattern";
+    readonly BEHAVIORAL_PATTERN: "behavioral_pattern";
+    readonly LEARNING_STYLE: "learning_style";
+    readonly COLLABORATION_STYLE: "collaboration_style";
+};
+declare const PATTERN_TYPES: {
+    readonly PREFERENCE: "preference";
+    readonly HABIT: "habit";
+    readonly WORKFLOW: "workflow";
+    readonly COMMUNICATION_STYLE: "communication_style";
+    readonly DECISION_PATTERN: "decision_pattern";
+    readonly TEMPORAL_PATTERN: "temporal_pattern";
+    readonly BEHAVIORAL_PATTERN: "behavioral_pattern";
+    readonly LEARNING_STYLE: "learning_style";
+    readonly COLLABORATION_STYLE: "collaboration_style";
+    readonly THEME: "theme";
+    readonly TOPIC: "topic";
+    readonly DOMAIN: "domain";
+    readonly INTEREST_AREA: "interest_area";
+};
+type ExplicitPatternType = (typeof EXPLICIT_PATTERN_TYPES)[keyof typeof EXPLICIT_PATTERN_TYPES];
+type ImplicitPatternType = (typeof IMPLICIT_PATTERN_TYPES)[keyof typeof IMPLICIT_PATTERN_TYPES];
+type PatternType = (typeof PATTERN_TYPES)[keyof typeof PATTERN_TYPES];
+
+/**
+ * Search options interface
+ */
+interface SearchOptions {
+    limit?: number;
+    maxBfsDepth?: number;
+    validAt?: Date;
+    startTime?: Date | null;
+    endTime?: Date;
+    includeInvalidated?: boolean;
+    entityTypes?: string[];
+    predicateTypes?: string[];
+    scoreThreshold?: number;
+    minResults?: number;
+    labelIds?: string[];
+    adaptiveFiltering?: boolean;
+    structured?: boolean;
+    useLLMValidation?: boolean;
+    qualityThreshold?: number;
+    maxEpisodesForLLM?: number;
+    sortBy?: "relevance" | "recency";
+}
+/**
+ * Statement with source provenance tracking
+ */
+interface StatementWithSource {
+    statement: StatementNode;
+    sources: {
+        episodeGraph?: {
+            score: number;
+            entityMatches: number;
+        };
+        bfs?: {
+            score: number;
+            hopDistance: number;
+            relevance: number;
+        };
+        vector?: {
+            score: number;
+            similarity: number;
+        };
+        bm25?: {
+            score: number;
+            rank: number;
+        };
+    };
+    primarySource: "episodeGraph" | "bfs" | "vector" | "bm25";
+}
+/**
+ * Episode with provenance tracking from multiple sources
+ */
+interface EpisodeWithProvenance {
+    episode: EpisodicNode;
+    statements: StatementWithSource[];
+    episodeGraphScore: number;
+    bfsScore: number;
+    vectorScore: number;
+    bm25Score: number;
+    sourceBreakdown: {
+        fromEpisodeGraph: number;
+        fromBFS: number;
+        fromVector: number;
+        fromBM25: number;
+    };
+    entityMatchCount?: number;
+    firstLevelScore?: number;
+}
+/**
+ * Quality filtering result
+ */
+interface QualityFilterResult {
+    episodes: EpisodeWithProvenance[];
+    confidence: number;
+    message: string;
+}
+/**
+ * Quality thresholds for filtering
+ */
+declare const QUALITY_THRESHOLDS: {
+    HIGH_QUALITY_EPISODE: number;
+    MEDIUM_QUALITY_EPISODE: number;
+    LOW_QUALITY_EPISODE: number;
+    CONFIDENT_RESULT: number;
+    UNCERTAIN_RESULT: number;
+    NO_RESULT: number;
+    MINIMUM_GAP_RATIO: number;
+};
+/**
+ * Episode search result with aggregated scores and sample statements
+ * Returned by BM25, Vector, and BFS searches
+ */
+interface EpisodeSearchResult {
+    episode: EpisodicNode;
+    score: number;
+    statementCount: number;
+    topStatements: StatementNode[];
+    invalidatedStatements: StatementNode[];
+}
+/**
+ * Configuration for reranking
+ */
+interface RerankConfig {
+    provider: "cohere" | "ollama" | "none";
+    limit?: number;
+    threshold: number;
+    cohereApiKey?: string;
+    cohereModel?: string;
+    ollamaUrl?: string;
+    ollamaModel?: string;
+}
+
 declare abstract class IntegrationCLI {
     protected program: Command;
     protected integrationName: string;
@@ -248,10 +554,11 @@ declare abstract class IntegrationCLI {
     private setupDataCommands;
     private setupSpecCommand;
     private setupSyncCommand;
+    private setupMCPCommand;
     protected abstract handleEvent(eventPayload: IntegrationEventPayload): Promise<Message[]>;
     protected abstract getSpec(): Promise<Spec>;
     parse(): void;
     getProgram(): Command;
 }
 
-export { APIKeyParams, ActionStatus, ActionStatusEnum, type AddEpisodeParams, type AddEpisodeResult, type AuthType, ClaudeModels, type Config, type EntityNode, EpisodeType, type EpisodicNode, type ExtractedTripleData, GeminiModels, type Identifier, IntegrationCLI, type IntegrationEventPayload, IntegrationEventType, LLMMappings, LLMModelEnum, LLMModelType, type Message, type MessageType, OAuth2Params, OpenAIModels, Spec, type StatementNode, type Triple, UserTypeEnum };
+export { APIKeyParams, ActionStatus, ActionStatusEnum, type AddEpisodeParams, type AddEpisodeResult, type AssignStatementsParams, type AuthType, COMPACTED_SESSION_NODE_PROPERTIES, ClaudeModels, type CompactedSessionNode, type Config, type CreatePatternParams, type CreateSpaceParams, type DocumentNode, ENTITY_NODE_PROPERTIES, EPISODIC_NODE_PROPERTIES, EXPLICIT_PATTERN_TYPES, type EntityNode, type EpisodeSearchResult, EpisodeType, EpisodeTypeEnum, type EpisodeWithProvenance, type EpisodicNode, type EpisodicNodeWithoutEmbeddings, type ExplicitPatternType, type ExtractedTripleData, GeminiModels, IMPLICIT_PATTERN_TYPES, type Identifier, type ImplicitPatternType, IntegrationCLI, type IntegrationEventPayload, IntegrationEventType, LLMMappings, LLMModelEnum, LLMModelType, type Message, type MessageType, OAuth2Params, OpenAIModels, PATTERN_TYPES, type PatternConfirmationParams, type PatternDetectionResult, type PatternType, QUALITY_THRESHOLDS, type QualityFilterResult, type RerankConfig, STATEMENT_NODE_PROPERTIES, type SearchOptions, type SpaceAssignmentResult, type SpaceDeletionResult, type SpaceNode, type SpacePattern, type SpaceWithStatements, Spec, type StatementNode, type StatementWithSource, type Triple, type UpdateSpaceParams, type UserConfirmationStatus, UserTypeEnum };

package/dist/index.js

@@ -77,11 +77,62 @@ var GeminiModels = [
 ];
 
 // ../types/dist/graph/graph.entity.js
-exports.EpisodeType = void 0;
-(function(EpisodeType2) {
-  EpisodeType2["Conversation"] = "CONVERSATION";
-  EpisodeType2["Text"] = "TEXT";
-})(exports.EpisodeType || (exports.EpisodeType = {}));
+var EPISODIC_NODE_PROPERTIES = `{
+  uuid: e.uuid,
+  content: e.content,
+  originalContent: e.originalContent,
+  createdAt: e.createdAt,
+  userId: e.userId,
+  sessionId: e.sessionId,
+  labelIds: e.labelIds,
+  validAt: e.validAt,
+  recallCount: e.recallCount,
+  chunkIndex: e.chunkIndex
+}`;
+var STATEMENT_NODE_PROPERTIES = `{
+  uuid: s.uuid,
+  fact: s.fact,
+  createdAt: s.createdAt,
+  userId: s.userId,
+  validAt: s.validAt,
+  invalidAt: s.invalidAt,
+  invalidatedBy: s.invalidatedBy,
+  attributes: s.attributes,
+  recallCount: s.recallCount,
+  provenanceCount: s.provenanceCount
+}`;
+var ENTITY_NODE_PROPERTIES = `{
+  uuid: ent.uuid,
+  name: ent.name,
+  createdAt: ent.createdAt,
+  userId: ent.userId,
+  attributes: ent.attributes
+}`;
+var COMPACTED_SESSION_NODE_PROPERTIES = `{
+  uuid: cs.uuid,
+  sessionId: cs.sessionId,
+  summary: cs.summary,
+  episodeCount: cs.episodeCount,
+  startTime: cs.startTime,
+  endTime: cs.endTime,
+  createdAt: cs.createdAt,
+  updatedAt: cs.updatedAt,
+  confidence: cs.confidence,
+  userId: cs.userId,
+  source: cs.source,
+  compressionRatio: cs.compressionRatio,
+  metadata: cs.metadata
+}`;
+exports.EpisodeTypeEnum = void 0;
+(function(EpisodeTypeEnum2) {
+  EpisodeTypeEnum2["CONVERSATION"] = "CONVERSATION";
+  EpisodeTypeEnum2["DOCUMENT"] = "DOCUMENT";
+})(exports.EpisodeTypeEnum || (exports.EpisodeTypeEnum = {}));
+var EpisodeType = {
+  CONVERSATION: "CONVERSATION",
+  DOCUMENT: "DOCUMENT",
+  IMAGE: "IMAGE"
+};
 
 // ../types/dist/conversation-execution-step/conversation-execution.entity.js
 exports.ActionStatusEnum = void 0;
@@ -122,6 +173,7 @@ exports.IntegrationEventType = void 0;
   IntegrationEventType2["IDENTIFY"] = "identify";
   IntegrationEventType2["SYNC"] = "sync";
   IntegrationEventType2["SPEC"] = "spec";
+  IntegrationEventType2["MCP"] = "mcp";
 })(exports.IntegrationEventType || (exports.IntegrationEventType = {}));
 var Spec = class {
   static {
@@ -136,6 +188,42 @@ exports.UserTypeEnum = void 0;
   UserTypeEnum2["User"] = "User";
   UserTypeEnum2["System"] = "System";
 })(exports.UserTypeEnum || (exports.UserTypeEnum = {}));
+
+// ../types/dist/pattern.js
+var EXPLICIT_PATTERN_TYPES = {
+  // Derived from space themes and explicit content
+  THEME: "theme",
+  TOPIC: "topic",
+  DOMAIN: "domain",
+  INTEREST_AREA: "interest_area"
+};
+var IMPLICIT_PATTERN_TYPES = {
+  // Discovered from behavioral analysis and content patterns
+  PREFERENCE: "preference",
+  HABIT: "habit",
+  WORKFLOW: "workflow",
+  COMMUNICATION_STYLE: "communication_style",
+  DECISION_PATTERN: "decision_pattern",
+  TEMPORAL_PATTERN: "temporal_pattern",
+  BEHAVIORAL_PATTERN: "behavioral_pattern",
+  LEARNING_STYLE: "learning_style",
+  COLLABORATION_STYLE: "collaboration_style"
+};
+var PATTERN_TYPES = Object.assign(Object.assign({}, EXPLICIT_PATTERN_TYPES), IMPLICIT_PATTERN_TYPES);
+
+// ../types/dist/search.js
+var QUALITY_THRESHOLDS = {
+  // Adaptive episode-level scoring (based on available sources)
+  HIGH_QUALITY_EPISODE: 5,
+  MEDIUM_QUALITY_EPISODE: 1,
+  LOW_QUALITY_EPISODE: 0.3,
+  // Overall result confidence
+  CONFIDENT_RESULT: 0.7,
+  UNCERTAIN_RESULT: 0.3,
+  NO_RESULT: 0.3,
+  // Score gap detection
+  MINIMUM_GAP_RATIO: 0.5
+};
 var IntegrationCLI = class {
   static {
     __name(this, "IntegrationCLI");
@@ -155,6 +243,7 @@ var IntegrationCLI = class {
     this.setupAccountCommands();
     this.setupDataCommands();
     this.setupSyncCommand();
+    this.setupMCPCommand();
   }
   setupAccountCommands() {
     this.program.command("setup").description(`Set up a new ${this.integrationName} integration account`).requiredOption("--event-body <body>", "Event body JSON (e.g. OAuth response or setup data)").requiredOption("--integration-definition <definition>", "Integration definition JSON").action(async (options) => {
@@ -244,6 +333,23 @@ var IntegrationCLI = class {
       }
     });
   }
+  setupMCPCommand() {
+    this.program.command("mcp").description("To start the mcp").requiredOption("--config <config>", "Integration configuration JSON").requiredOption("--integration-definition <definition>", "Integration definition JSON").action(async (options) => {
+      try {
+        const config = JSON.parse(options.config);
+        const integrationDefinition = JSON.parse(options.integrationDefinition);
+        await this.handleEvent({
+          event: exports.IntegrationEventType.MCP,
+          eventBody: {},
+          config,
+          integrationDefinition
+        });
+      } catch (error) {
+        console.error("Error during sync:", error);
+        process.exit(1);
+      }
+    });
+  }
   /**
   * Parse and execute the CLI commands
   */
@@ -260,12 +366,21 @@ var IntegrationCLI = class {
 
 exports.APIKeyParams = APIKeyParams;
 exports.ActionStatus = ActionStatus;
+exports.COMPACTED_SESSION_NODE_PROPERTIES = COMPACTED_SESSION_NODE_PROPERTIES;
 exports.ClaudeModels = ClaudeModels;
+exports.ENTITY_NODE_PROPERTIES = ENTITY_NODE_PROPERTIES;
+exports.EPISODIC_NODE_PROPERTIES = EPISODIC_NODE_PROPERTIES;
+exports.EXPLICIT_PATTERN_TYPES = EXPLICIT_PATTERN_TYPES;
+exports.EpisodeType = EpisodeType;
 exports.GeminiModels = GeminiModels;
+exports.IMPLICIT_PATTERN_TYPES = IMPLICIT_PATTERN_TYPES;
 exports.IntegrationCLI = IntegrationCLI;
 exports.LLMModelType = LLMModelType;
 exports.OAuth2Params = OAuth2Params;
 exports.OpenAIModels = OpenAIModels;
+exports.PATTERN_TYPES = PATTERN_TYPES;
+exports.QUALITY_THRESHOLDS = QUALITY_THRESHOLDS;
+exports.STATEMENT_NODE_PROPERTIES = STATEMENT_NODE_PROPERTIES;
 exports.Spec = Spec;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map