@memberjunction/content-autotagging 6.2.0-edge.0 → 6.2.0-edge.1

package/dist/Engine/generic/AutotagBaseEngine.js

@@ -55,8 +55,8 @@ let AutotagBaseEngine = class AutotagBaseEngine extends BaseEngine {
     constructor() {
         super(...arguments);
         // Cached metadata unique to this engine — loaded by BaseEngine.Config()
-        this._ContentTypeAttributes = [];
-        this._ContentSourceTypeParams = [];
+        this._contentTypeAttributes = [];
+        this._contentSourceTypeParams = [];
         /**
          * Optional taxonomy JSON string to inject into the autotagging prompt.
          * Set by the caller (e.g., AutotagEntity) before calling ExtractTextAndProcessWithLLM.
@@ -120,9 +120,9 @@ let AutotagBaseEngine = class AutotagBaseEngine extends BaseEngine {
     /** All content file types — delegated to KnowledgeHubMetadataEngine */
     get ContentFileTypes() { return this.khEngine.ContentFileTypes; }
     /** All content type attributes, cached at startup */
-    get ContentTypeAttributes() { return this._ContentTypeAttributes; }
+    get ContentTypeAttributes() { return this._contentTypeAttributes; }
     /** All content source type params, cached at startup */
-    get ContentSourceTypeParams() { return this._ContentSourceTypeParams; }
+    get ContentSourceTypeParams() { return this._contentSourceTypeParams; }
     async Config(forceRefresh, contextUser, provider) {
         // Content Types, Content Source Types, and Content File Types are delegated to
         // KnowledgeHubMetadataEngine (avoid redundant loading). Only cache entities unique to this engine.
@@ -131,12 +131,12 @@ let AutotagBaseEngine = class AutotagBaseEngine extends BaseEngine {
             {
                 Type: 'entity',
                 EntityName: 'MJ: Content Type Attributes',
-                PropertyName: '_ContentTypeAttributes',
+                PropertyName: '_contentTypeAttributes',
             },
             {
                 Type: 'entity',
                 EntityName: 'MJ: Content Source Type Params',
-                PropertyName: '_ContentSourceTypeParams',
+                PropertyName: '_contentSourceTypeParams',
             },
         ];
         await this.Load(configs, provider, forceRefresh, contextUser);
@@ -317,7 +317,7 @@ let AutotagBaseEngine = class AutotagBaseEngine extends BaseEngine {
             processRunParams.startTime = new Date();
             processRunParams.endTime = new Date();
             processRunParams.numItemsProcessed = totalProcessed - resumeOffset;
-            await this.saveProcessRun(processRunParams, contextUser);
+            await this.SaveProcessRun(processRunParams, contextUser);
         }
     }
     /**
@@ -345,8 +345,8 @@ let AutotagBaseEngine = class AutotagBaseEngine extends BaseEngine {
         // A8: Update tagging status to Processing
         await this.updateContentItemTaggingStatus(params.contentItemID, 'Processing', contextUser);
         try {
-            const LLMResults = await this.promptAndRetrieveResultsFromLLM(params, contextUser);
-            await this.saveLLMResults(LLMResults, contextUser);
+            const LLMResults = await this.PromptAndRetrieveResultsFromLLM(params, contextUser);
+            await this.SaveLLMResults(LLMResults, contextUser);
             // A8: Update tagging status to Complete
             await this.updateContentItemTaggingStatus(params.contentItemID, 'Complete', contextUser);
         }
@@ -445,7 +445,7 @@ let AutotagBaseEngine = class AutotagBaseEngine extends BaseEngine {
             }
             // Set up the bridge callback — fires after each ContentItemTag is saved
             this.OnContentItemTagSaved = async (contentItemTag, parentTagName, ctxUser) => {
-                await this.BridgeContentItemTagToTaxonomy(contentItemTag, parentTagName, ctxUser);
+                await this.bridgeContentItemTagToTaxonomy(contentItemTag, parentTagName, ctxUser);
             };
             LogStatus(`[TaxonomyBridge] Bridge callback installed`);
         }
@@ -509,7 +509,7 @@ let AutotagBaseEngine = class AutotagBaseEngine extends BaseEngine {
      * - For Entity sources: tags the original entity record (e.g., Products row)
      * - For non-Entity sources (RSS, Website, etc.): tags the ContentItem itself
      */
-    async BridgeContentItemTagToTaxonomy(contentItemTag, parentTagName, contextUser) {
+    async bridgeContentItemTagToTaxonomy(contentItemTag, parentTagName, contextUser) {
         try {
             // If the LLM suggested a parent tag, resolve it first (through the same
             // mutex, to prevent duplicate parents under concurrent batch processing)
@@ -673,14 +673,14 @@ let AutotagBaseEngine = class AutotagBaseEngine extends BaseEngine {
         // extension keys ride along in the same JSON and are surfaced via the extended interface.
         return source.ConfigurationObject ?? null;
     }
-    async promptAndRetrieveResultsFromLLM(params, contextUser) {
+    async PromptAndRetrieveResultsFromLLM(params, contextUser) {
         await AIEngine.Instance.Config(false, contextUser);
         // Resolve the effective classification context once per item (async lookup);
         // buildPromptData reads it from params for each chunk.
         params.classificationContext = await this.resolveClassificationContext(params, contextUser);
         const prompt = this.getAutotagPrompt();
         const tokenLimit = this.resolveTokenLimit(params.modelID);
-        const chunks = await this.chunkExtractedText(params.text, tokenLimit);
+        const chunks = await this.ChunkExtractedText(params.text, tokenLimit);
         if (chunks.length === 0 || (chunks.length === 1 && (!chunks[0] || chunks[0].trim().length === 0))) {
             LogError(`[Autotag] No text to process for item ${params.contentItemID}`);
             return {};
@@ -689,7 +689,7 @@ let AutotagBaseEngine = class AutotagBaseEngine extends BaseEngine {
         const startTime = new Date();
         for (let ci = 0; ci < chunks.length; ci++) {
             try {
-                LLMResults = await this.processChunkWithPromptRunner(prompt, params, chunks[ci], LLMResults, contextUser);
+                LLMResults = await this.ProcessChunkWithPromptRunner(prompt, params, chunks[ci], LLMResults, contextUser);
             }
             catch (chunkError) {
                 LogError(`[Autotag] Chunk ${ci + 1}/${chunks.length} failed for item ${params.contentItemID}: ${chunkError instanceof Error ? chunkError.message : String(chunkError)}`);
@@ -700,6 +700,10 @@ let AutotagBaseEngine = class AutotagBaseEngine extends BaseEngine {
         LLMResults.contentItemID = params.contentItemID;
         return LLMResults;
     }
+    /** @deprecated Use {@link PromptAndRetrieveResultsFromLLM}. */
+    async promptAndRetrieveResultsFromLLM(params, contextUser) {
+        return this.PromptAndRetrieveResultsFromLLM(params, contextUser);
+    }
     /**
      * Resolves the input token limit for chunking. Uses the model specified by modelID if available,
      * otherwise falls back to a conservative default.
@@ -719,7 +723,7 @@ let AutotagBaseEngine = class AutotagBaseEngine extends BaseEngine {
      * Uses the prompt's configured model by default. If ContentType.AIModelID is set,
      * it is passed as a runtime model override via AIPromptParams.override.
      */
-    async processChunkWithPromptRunner(prompt, params, chunk, LLMResults, contextUser) {
+    async ProcessChunkWithPromptRunner(prompt, params, chunk, LLMResults, contextUser) {
         const promptParams = new AIPromptParams();
         promptParams.prompt = prompt;
         promptParams.contextUser = contextUser;
@@ -770,25 +774,37 @@ let AutotagBaseEngine = class AutotagBaseEngine extends BaseEngine {
         }
         return LLMResults;
     }
-    async saveLLMResults(LLMResults, contextUser) {
+    /** @deprecated Use {@link ProcessChunkWithPromptRunner}. */
+    async processChunkWithPromptRunner(prompt, params, chunk, LLMResults, contextUser) {
+        return this.ProcessChunkWithPromptRunner(prompt, params, chunk, LLMResults, contextUser);
+    }
+    async SaveLLMResults(LLMResults, contextUser) {
         if (LLMResults.isValidContent === true) {
-            await this.saveResultsToContentItemAttribute(LLMResults, contextUser);
-            await this.saveContentItemTags(LLMResults.contentItemID, LLMResults, contextUser);
+            await this.SaveResultsToContentItemAttribute(LLMResults, contextUser);
+            await this.SaveContentItemTags(LLMResults.contentItemID, LLMResults, contextUser);
         }
         else if (LLMResults.isValidContent === false) {
             LogStatus(`[Autotag] LLM judged content item ${LLMResults.contentItemID} INVALID — deleting it. Title: ${String(LLMResults.title ?? '')} | Reason/description: ${String(LLMResults.description ?? LLMResults.reason ?? '')}`.slice(0, 600));
-            await this.deleteInvalidContentItem(LLMResults.contentItemID, contextUser);
+            await this.DeleteInvalidContentItem(LLMResults.contentItemID, contextUser);
         }
         else {
             LogError(`[Autotag] Unexpected LLM format for item ${LLMResults.contentItemID} — isValidContent missing. Keys: ${Object.keys(LLMResults).join(', ')}`);
         }
     }
-    async deleteInvalidContentItem(contentItemID, contextUser) {
+    /** @deprecated Use {@link SaveLLMResults}. */
+    async saveLLMResults(LLMResults, contextUser) {
+        return this.SaveLLMResults(LLMResults, contextUser);
+    }
+    async DeleteInvalidContentItem(contentItemID, contextUser) {
         const md = this.ProviderToUse;
         const contentItem = await md.GetEntityObject('MJ: Content Items', contextUser);
         await contentItem.Load(contentItemID);
         await contentItem.Delete();
     }
+    /** @deprecated Use {@link DeleteInvalidContentItem}. */
+    async deleteInvalidContentItem(contentItemID, contextUser) {
+        return this.DeleteInvalidContentItem(contentItemID, contextUser);
+    }
     /**
      * Registration key of the segmentation strategy this engine uses.
      *
@@ -827,7 +843,7 @@ let AutotagBaseEngine = class AutotagBaseEngine extends BaseEngine {
      * ({@link MAX_EMBEDDING_TOKENS}) — these two chunk sites feed different consumers and
      * must not be collapsed into one call. Tagging chunks are transient and never persisted.
      */
-    async chunkExtractedText(text, tokenLimit) {
+    async ChunkExtractedText(text, tokenLimit) {
         try {
             const maxChunkTokens = Math.ceil(tokenLimit / 1.5);
             // Short-circuit: text that already fits is passed through verbatim, preserving its
@@ -847,6 +863,10 @@ let AutotagBaseEngine = class AutotagBaseEngine extends BaseEngine {
             return [text];
         }
     }
+    /** @deprecated Use {@link ChunkExtractedText}. */
+    async chunkExtractedText(text, tokenLimit) {
+        return this.ChunkExtractedText(text, tokenLimit);
+    }
     /**
      * Simple character-based chunking as fallback
      */
@@ -867,7 +887,7 @@ let AutotagBaseEngine = class AutotagBaseEngine extends BaseEngine {
      * After each tag is saved, invokes the OnContentItemTagSaved callback (if set)
      * for taxonomy bridge processing.
      */
-    async saveContentItemTags(contentItemID, LLMResults, contextUser) {
+    async SaveContentItemTags(contentItemID, LLMResults, contextUser) {
         const md = this.ProviderToUse;
         const keywords = LLMResults.keywords;
         if (!keywords || !Array.isArray(keywords))
@@ -926,11 +946,15 @@ let AutotagBaseEngine = class AutotagBaseEngine extends BaseEngine {
             }));
         }
     }
+    /** @deprecated Use {@link SaveContentItemTags}. */
+    async saveContentItemTags(contentItemID, LLMResults, contextUser) {
+        return this.SaveContentItemTags(contentItemID, LLMResults, contextUser);
+    }
     /**
      * Saves LLM-extracted attributes to the database.
      * Updates content item name/description, then creates attribute records for other fields.
      */
-    async saveResultsToContentItemAttribute(LLMResults, contextUser) {
+    async SaveResultsToContentItemAttribute(LLMResults, contextUser) {
         const md = this.ProviderToUse;
         const contentItemID = LLMResults.contentItemID;
         const skipKeys = new Set(['keywords', 'processStartTime', 'processEndTime', 'contentItemID', 'isValidContent', AutotagBaseEngine_1.AI_PROMPT_RUN_ID_KEY]);
@@ -964,17 +988,25 @@ let AutotagBaseEngine = class AutotagBaseEngine extends BaseEngine {
             }));
         }
     }
+    /** @deprecated Use {@link SaveResultsToContentItemAttribute}. */
+    async saveResultsToContentItemAttribute(LLMResults, contextUser) {
+        return this.SaveResultsToContentItemAttribute(LLMResults, contextUser);
+    }
     /**
      * Retrieves all content sources for a given content source type.
      * Throws if no sources are found.
      */
-    async getAllContentSources(contextUser, contentSourceTypeID) {
+    async GetAllContentSources(contextUser, contentSourceTypeID) {
         const sources = await this.GetAllContentSourcesSafe(contextUser, contentSourceTypeID);
         if (sources.length === 0) {
             throw new Error(`No content sources found for content source type with ID '${contentSourceTypeID}'`);
         }
         return sources;
     }
+    /** @deprecated Use {@link GetAllContentSources}. */
+    async getAllContentSources(contextUser, contentSourceTypeID) {
+        return this.GetAllContentSources(contextUser, contentSourceTypeID);
+    }
     /**
      * Retrieves all content sources for a given content source type.
      * Returns an empty array (instead of throwing) when no sources are configured.
@@ -989,7 +1021,7 @@ let AutotagBaseEngine = class AutotagBaseEngine extends BaseEngine {
         }
         return sourceType.ID;
     }
-    async getContentSourceParams(contentSource, contextUser) {
+    async GetContentSourceParams(contentSource, contextUser) {
         const contentSourceParams = new Map();
         const rv = new RunView();
         const results = await rv.RunView({
@@ -1002,7 +1034,7 @@ let AutotagBaseEngine = class AutotagBaseEngine extends BaseEngine {
                 const params = this.GetDefaultContentSourceTypeParams(contentSourceParam.ContentSourceTypeParamID);
                 params.contentSourceID = contentSource.ID;
                 if (contentSourceParam.Value) {
-                    params.value = this.castValueAsCorrectType(contentSourceParam.Value, params.type);
+                    params.value = this.CastValueAsCorrectType(contentSourceParam.Value, params.type);
                 }
                 contentSourceParams.set(params.name, params.value);
             }
@@ -1012,50 +1044,70 @@ let AutotagBaseEngine = class AutotagBaseEngine extends BaseEngine {
         }
         return contentSourceParams;
     }
+    /** @deprecated Use {@link GetContentSourceParams}. */
+    async getContentSourceParams(contentSource, contextUser) {
+        return this.GetContentSourceParams(contentSource, contextUser);
+    }
     GetDefaultContentSourceTypeParams(contentSourceTypeParamID) {
-        const result = this._ContentSourceTypeParams.find(p => UUIDsEqual(p.ID, contentSourceTypeParamID));
+        const result = this._contentSourceTypeParams.find(p => UUIDsEqual(p.ID, contentSourceTypeParamID));
         if (!result) {
             throw new Error(`Content Source Type Param with ID '${contentSourceTypeParamID}' not found in cached metadata`);
         }
         const params = new ContentSourceTypeParams();
         params.name = result.Name;
         params.type = result.Type.toLowerCase();
-        params.value = this.castValueAsCorrectType(result.DefaultValue ?? '', params.type);
+        params.value = this.CastValueAsCorrectType(result.DefaultValue ?? '', params.type);
         return params;
     }
-    castValueAsCorrectType(value, type) {
+    CastValueAsCorrectType(value, type) {
         switch (type) {
             case 'number':
                 return parseInt(value, 10);
             case 'boolean':
-                return this.stringToBoolean(value);
+                return this.StringToBoolean(value);
             case 'string':
                 return value;
             case 'string[]':
-                return this.parseStringArray(value);
+                return this.ParseStringArray(value);
             case 'regexp':
                 return new RegExp(value.replace(/\\\\/g, '\\'));
             default:
                 return value;
         }
     }
-    stringToBoolean(str) {
+    /** @deprecated Use {@link CastValueAsCorrectType}. */
+    castValueAsCorrectType(value, type) {
+        return this.CastValueAsCorrectType(value, type);
+    }
+    StringToBoolean(str) {
         return str === 'true';
     }
-    parseStringArray(value) {
+    /** @deprecated Use {@link StringToBoolean}. */
+    stringToBoolean(str) {
+        return this.StringToBoolean(str);
+    }
+    ParseStringArray(value) {
         return JSON.parse(value);
     }
+    /** @deprecated Use {@link ParseStringArray}. */
+    parseStringArray(value) {
+        return this.ParseStringArray(value);
+    }
     /**
      * Converts a run date to the user's local timezone.
      */
-    async convertLastRunDateToTimezone(lastRunDate) {
+    async ConvertLastRunDateToTimezone(lastRunDate) {
         const userTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
         return toZonedTime(lastRunDate, userTimeZone);
     }
+    /** @deprecated Use {@link ConvertLastRunDateToTimezone}. */
+    async convertLastRunDateToTimezone(lastRunDate) {
+        return this.ConvertLastRunDateToTimezone(lastRunDate);
+    }
     /**
      * Retrieves the last run date for a content source. Returns epoch date if no runs exist.
      */
-    async getContentSourceLastRunDate(contentSourceID, contextUser) {
+    async GetContentSourceLastRunDate(contentSourceID, contextUser) {
         const rv = new RunView();
         // Exclude 'Running' status to avoid using the current in-progress run's
         // start time as the cutoff — that would cause the provider to skip all records.
@@ -1067,13 +1119,17 @@ let AutotagBaseEngine = class AutotagBaseEngine extends BaseEngine {
         }, contextUser);
         if (results.Success && results.Results.length) {
             const lastRunDate = results.Results[0].__mj_CreatedAt;
-            return this.convertLastRunDateToTimezone(lastRunDate);
+            return this.ConvertLastRunDateToTimezone(lastRunDate);
         }
         if (results.Success) {
             return new Date(0);
         }
         throw new Error(`Failed to retrieve last run date for content source with ID ${contentSourceID}`);
     }
+    /** @deprecated Use {@link GetContentSourceLastRunDate}. */
+    async getContentSourceLastRunDate(contentSourceID, contextUser) {
+        return this.GetContentSourceLastRunDate(contentSourceID, contextUser);
+    }
     GetContentItemParams(contentTypeID) {
         const contentType = this.khEngine.GetContentTypeByID(contentTypeID);
         if (!contentType) {
@@ -1107,7 +1163,7 @@ let AutotagBaseEngine = class AutotagBaseEngine extends BaseEngine {
         return fileType.Name;
     }
     GetAdditionalContentTypePrompt(contentTypeID) {
-        const attrs = this._ContentTypeAttributes.filter(a => UUIDsEqual(a.ContentTypeID, contentTypeID));
+        const attrs = this._contentTypeAttributes.filter(a => UUIDsEqual(a.ContentTypeID, contentTypeID));
         if (attrs.length === 0)
             return '';
         return attrs.map(attr => `${attr.Prompt}. The data must be included in the above described JSON file in this key-value format:     { "${attr.Name}": (value of ${attr.Name} here)}`).join('\n');
@@ -1118,15 +1174,23 @@ let AutotagBaseEngine = class AutotagBaseEngine extends BaseEngine {
         const sourceTypeName = this.GetContentSourceTypeName(contentSourceParams.ContentSourceTypeID);
         return `${contentTypeName} in ${fileTypeName} format obtained from a ${sourceTypeName} source`;
     }
-    async getChecksumFromURL(url) {
+    async GetChecksumFromURL(url) {
         const response = await HttpGet(url, { ResponseType: 'text' });
         const content = String(response.Data);
         return crypto.createHash('sha256').update(content).digest('hex');
     }
-    async getChecksumFromText(text) {
+    /** @deprecated Use {@link GetChecksumFromURL}. */
+    async getChecksumFromURL(url) {
+        return this.GetChecksumFromURL(url);
+    }
+    async GetChecksumFromText(text) {
         return crypto.createHash('sha256').update(text).digest('hex');
     }
-    async getContentItemIDFromURL(contentSourceParams, contextUser) {
+    /** @deprecated Use {@link GetChecksumFromText}. */
+    async getChecksumFromText(text) {
+        return this.GetChecksumFromText(text);
+    }
+    async GetContentItemIDFromURL(contentSourceParams, contextUser) {
         const url = contentSourceParams.URL;
         const rv = new RunView();
         const results = await rv.RunView({
@@ -1139,10 +1203,14 @@ let AutotagBaseEngine = class AutotagBaseEngine extends BaseEngine {
         }
         throw new Error(`Content item with URL ${url} not found`);
     }
+    /** @deprecated Use {@link GetContentItemIDFromURL}. */
+    async getContentItemIDFromURL(contentSourceParams, contextUser) {
+        return this.GetContentItemIDFromURL(contentSourceParams, contextUser);
+    }
     /**
      * Saves process run metadata to the database (backward-compatible simple version).
      */
-    async saveProcessRun(processRunParams, contextUser) {
+    async SaveProcessRun(processRunParams, contextUser) {
         const md = this.ProviderToUse;
         const processRun = await md.GetEntityObject('MJ: Content Process Runs', contextUser);
         processRun.NewRecord();
@@ -1154,6 +1222,10 @@ let AutotagBaseEngine = class AutotagBaseEngine extends BaseEngine {
         processRun.StartedByUserID = contextUser.ID;
         await processRun.Save();
     }
+    /** @deprecated Use {@link SaveProcessRun}. */
+    async saveProcessRun(processRunParams, contextUser) {
+        return this.SaveProcessRun(processRunParams, contextUser);
+    }
     /**
      * Create a new ContentProcessRun record for batched pipeline execution.
      * Returns the entity so the caller can update cursor/status as batches complete.
@@ -1235,15 +1307,23 @@ let AutotagBaseEngine = class AutotagBaseEngine extends BaseEngine {
             }),
         };
     }
-    async parsePDF(dataBuffer) {
+    async ParsePDF(dataBuffer) {
         const dataPDF = await pdfParse(dataBuffer);
         return dataPDF.text;
     }
-    async parseDOCX(dataBuffer) {
+    /** @deprecated Use {@link ParsePDF}. */
+    async parsePDF(dataBuffer) {
+        return this.ParsePDF(dataBuffer);
+    }
+    async ParseDOCX(dataBuffer) {
         const dataDOCX = await officeparser.parseOffice(dataBuffer);
         return dataDOCX.toText();
     }
-    async parseHTML(data) {
+    /** @deprecated Use {@link ParseDOCX}. */
+    async parseDOCX(dataBuffer) {
+        return this.ParseDOCX(dataBuffer);
+    }
+    async ParseHTML(data) {
         try {
             const $ = cheerio.load(data);
             $('script, style, nav, footer, header, .hidden').remove();
@@ -1254,18 +1334,26 @@ let AutotagBaseEngine = class AutotagBaseEngine extends BaseEngine {
             throw e;
         }
     }
-    async parseFileFromPath(filePath) {
+    /** @deprecated Use {@link ParseHTML}. */
+    async parseHTML(data) {
+        return this.ParseHTML(data);
+    }
+    async ParseFileFromPath(filePath) {
         const dataBuffer = await fs.promises.readFile(filePath);
         const fileExtension = filePath.split('.').pop()?.toLowerCase();
         switch (fileExtension) {
             case 'pdf':
-                return this.parsePDF(dataBuffer);
+                return this.ParsePDF(dataBuffer);
             case 'docx':
-                return this.parseDOCX(dataBuffer);
+                return this.ParseDOCX(dataBuffer);
             default:
                 throw new Error(`File type '${fileExtension}' not supported`);
         }
     }
+    /** @deprecated Use {@link ParseFileFromPath}. */
+    async parseFileFromPath(filePath) {
+        return this.ParseFileFromPath(filePath);
+    }
     // ---- Direct Vectorization ----
     /**
      * Embeds content items and upserts them to the appropriate vector index.