From e3f6f74b1bff75e73b5cf5e184c87139d9b08ea2 Mon Sep 17 00:00:00 2001 From: babayaga Date: Mon, 7 Apr 2025 17:41:05 +0200 Subject: [PATCH] kbot iterator example: md-ast transformer --- .../core/iterator-markdown-example.d.ts | 2 +- .../core/iterator-markdown-example.js | 298 ++++++++------- packages/kbot/logs/params.json | 2 +- .../core/iterator-markdown-example.ts | 340 ++++++++++-------- 4 files changed, 361 insertions(+), 281 deletions(-) diff --git a/packages/kbot/dist-in/examples/core/iterator-markdown-example.d.ts b/packages/kbot/dist-in/examples/core/iterator-markdown-example.d.ts index cb228352..b1805c1e 100644 --- a/packages/kbot/dist-in/examples/core/iterator-markdown-example.d.ts +++ b/packages/kbot/dist-in/examples/core/iterator-markdown-example.d.ts @@ -1 +1 @@ -export declare function markdownTransformExample(useCache?: boolean): Promise; +export declare function markdownTransformExample(useCache?: boolean): Promise; diff --git a/packages/kbot/dist-in/examples/core/iterator-markdown-example.js b/packages/kbot/dist-in/examples/core/iterator-markdown-example.js index bb6f3461..8ed761e1 100644 --- a/packages/kbot/dist-in/examples/core/iterator-markdown-example.js +++ b/packages/kbot/dist-in/examples/core/iterator-markdown-example.js @@ -8,6 +8,8 @@ import { sync as write } from "@polymech/fs/write"; import { E_OPENROUTER_MODEL } from '../../models/cache/openrouter-models.js'; import { E_Mode } from '../../zod_schema.js'; import { transform, createLLMTransformer } from '../../iterator.js'; +import { deepClone } from '@polymech/core/objects'; +import { run } from '../../commands/run.js'; /** * Notes for LLM modifications * @@ -21,6 +23,7 @@ const MODEL = E_OPENROUTER_MODEL.MODEL_OPENAI_GPT_4O_MINI; // Corrected model na const ROUTER = 'openrouter'; const INPUT_MD_PATH = path.resolve('./tests/test-data/core/md-test.md'); const OUTPUT_MD_PATH = path.resolve('./tests/test-data/core/md-test-out.md'); +const OUTPUT_JSON_PATH = path.resolve('./tests/test-data/core/md-test-out.json'); // Basic logger const logger = { info: (message) => console.log(`INFO: ${message}`), @@ -41,56 +44,22 @@ function getLLMTransformerForMdast(options, baseLogger = logger, cacheConfig) { return llmTransformer; } // Define field mappings for the mdast structure -const fieldMappings = [ +// Mappings for standard transforms (targetPath: null) +const standardMappings = [ { - // Target text value within H1-H5 headings' children jsonPath: '$.children[?(@.type=="heading" && @.depth <= 5)].children[?(@.type=="text")].value', - targetPath: null, // Modify in place (NOTE: This likely won't work due to iterator limitations) - options: { - prompt: 'Rewrite this heading to be more concise and impactful (max 5 words).' - } + targetPath: null, + options: { prompt: 'Rewrite this heading to be more concise and impactful (max 5 words).' } }, { - // Target the specific paragraph NODE in Chapter 4 for structured analysis. - // The transformer will extract text from the node passed to it. - // Using targetPath='analysisResult' stores the LLM output on the node itself. - jsonPath: '$.children[?(@.type=="paragraph" && @.children[0].value.includes("results"))]', - targetPath: 'analysisResult', // Store result in a new property on the paragraph node - options: { - prompt: 'Extract keywords and sentiment from this text.', - format: { - type: "object", - properties: { - sentiment: { - type: "string", - enum: ["positive", "neutral", "negative"], - description: "Overall sentiment" - }, - keywords: { - type: "array", - items: { type: "string" }, - description: "Main keywords (max 5)" - } - }, - required: ["sentiment", "keywords"] - } - } - }, - { - // Target text value within paragraphs' children jsonPath: '$.children[?(@.type=="paragraph")].children[?(@.type=="text")].value', - targetPath: null, // Modify in place (NOTE: This likely won't work due to iterator limitations) - options: { - prompt: 'Summarize this paragraph in one short sentence (max 15 words).' - } + targetPath: null, + options: { prompt: 'Summarize this paragraph in one short sentence (max 15 words).' } }, { - // Target text value within table cells' children jsonPath: '$.children[?(@.type=="table")].children[*].children[*].children[?(@.type=="text")].value', - targetPath: null, // Modify in place (NOTE: This likely won't work due to iterator limitations) - options: { - prompt: 'Rephrase this table cell content slightly.' - } + targetPath: null, + options: { prompt: 'Rephrase this table cell content slightly.' } } ]; // Example onTransform callback for Markdown @@ -113,8 +82,25 @@ export async function markdownTransformExample(useCache = true) { const ast = processor.parse(markdownInput); // Make a deep copy to avoid modifying the original AST if transform fails // Note: Standard deepClone might not work perfectly with complex AST nodes (position, data fields). - // For this example, JSON stringify/parse is a common workaround, but beware of data loss. - let astToTransform = JSON.parse(JSON.stringify(ast)); + // Using deepClone instead of JSON.parse/stringify + let astToTransform = deepClone(ast); + // --- Pre-processing: Add temporary ID to the target node --- + const analysisTargetText = "results"; // Text to identify the node + const tempIdValue = 'analyze-me'; + let identifiedNodeForAnalysis = null; // Store reference to the node + try { + visit(astToTransform, 'paragraph', (node) => { + if (node.children?.[0]?.value?.includes(analysisTargetText)) { + node.tempId = tempIdValue; + identifiedNodeForAnalysis = node; // Store the reference + logger.info(`[Pre-process] Added tempId='${tempIdValue}' and stored reference to node containing '${analysisTargetText}'`); + } + }); + } + catch (e) { + logger.error("[Pre-process] Error adding temporary ID:", e); + identifiedNodeForAnalysis = null; // Ensure we don't proceed if tagging failed + } // 3. Define global options and iterator options const globalOptionsMixin = { model: MODEL, @@ -122,40 +108,23 @@ export async function markdownTransformExample(useCache = true) { mode: E_Mode.COMPLETION, }; const iteratorOptions = { - // We provide our custom transformer factory transformerFactory: (opts) => getLLMTransformerForMdast(opts, logger, { enabled: useCache }), logger: logger, cacheConfig: { enabled: useCache, namespace: 'markdown-transforms' }, - // onTransform receives the value matched by jsonPath (can be string or node). - // It must return the STRING to be transformed by the LLM. onTransform: async (jsonPath, value, kbotOptions) => { let textContent = ''; - // Check if the value is a node object or just a string if (typeof value === 'string') { textContent = value; console.log(` -> onTransform String Value: Path='${jsonPath}', Value='${textContent.substring(0, 50)}...'`); } else if (typeof value === 'object' && value !== null) { - // Attempt to extract text if it's a node (e.g., for the analysisResult mapping) - const node = value; // Basic type assertion - if ((node.type === 'heading' || node.type === 'paragraph' || node.type === 'tableCell') && node.children?.length === 1 && node.children[0].type === 'text') { - textContent = node.children[0].value || ''; - } - else if (node.type === 'text') { - textContent = node.value || ''; - } - else if (Array.isArray(node.children)) { // Handle complex children - textContent = node.children - .filter((child) => child.type === 'text' || child.type === 'inlineCode') - .map((child) => child.value) - .join(''); - } + const node = value; + textContent = node.children?.[0]?.value || node.value || ''; console.log(` -> onTransform AST Node: Path='${jsonPath}', Node Type='${node?.type}', Extracted Text='${textContent.substring(0, 50)}...'`); } else { console.log(` -> onTransform Unexpected Value Type: Path='${jsonPath}', Type='${typeof value}'`); } - // Return the extracted string for the LLM transformer return textContent; }, errorCallback: (path, value, error) => { @@ -167,93 +136,176 @@ export async function markdownTransformExample(useCache = true) { } }, filterCallback: async (value, jsonPath) => { - // Allow transformation if the value is an object (likely an AST node targeted directly) if (typeof value === 'object' && value !== null) { return true; } - // If it's a string, apply the default string filter logic if (typeof value === 'string') { - // Reuse the default isValidString filter logic for strings const allow = value.trim() !== ''; if (!allow) { logger.info(`Filter: Skipping empty string at ${jsonPath}`); } return allow; } - // Skip other types (numbers, booleans, null, undefined) logger.warn(`Filter: Skipping non-string/non-object value type (${typeof value}) at ${jsonPath}`); return false; } }; - // 4. Use the transform function - console.log("Applying transformations to AST..."); - // The 'transform' function iterates based on JSONPath and applies the transformerFactory's result - // It modifies the 'astToTransform' object in place. - await transform(astToTransform, // Pass the AST object - fieldMappings, globalOptionsMixin, iteratorOptions); - // *** Add logging before visit *** - console.log("\n[DEBUG] Inspecting AST before visit call:"); + // 4. Run standard transformations + console.log("Applying standard transformations to AST..."); + await transform(astToTransform, standardMappings, globalOptionsMixin, iteratorOptions); + // 5. Perform Analysis Manually (if node was identified) + console.log("\nPerforming manual analysis..."); + let analysisData = null; // Store successfully parsed result here + let rawAnalysisResult = null; // Store raw LLM result + if (identifiedNodeForAnalysis) { + try { + let nodeText = ''; + // Extract text from the (now potentially modified) node + if (identifiedNodeForAnalysis.children?.[0]?.type === 'text') { + nodeText = identifiedNodeForAnalysis.children[0].value || ''; + } + logger.info(`[Manual Analysis] Found node with tempId. Extracted text: "${nodeText.substring(0, 50)}..."`); + if (nodeText) { + // Define analysis task options + const analysisTaskOptions = { + ...globalOptionsMixin, + // Explicitly request ONLY JSON matching the schema + prompt: `Analyze the following text and extract keywords and sentiment. Respond ONLY with a valid JSON object matching the schema provided in the 'format' field. Do not include any other text, explanations, or markdown formatting.\n\nText to analyze:\n"${nodeText}"`, + format: { + type: "object", + properties: { + sentiment: { type: "string", enum: ["positive", "neutral", "negative"] }, + keywords: { type: "array", items: { type: "string" }, maxItems: 5 } + }, + required: ["sentiment", "keywords"] + }, + mode: E_Mode.COMPLETION + }; + // Call the run command + logger.info(`[Manual Analysis] Calling run command with format option...`); + const results = await run(analysisTaskOptions); + // Process the result (run should return the parsed object) + if (results && results.length > 0) { + const rawResult = results[0]; + logger.info(`[Manual Analysis] Raw result from run: ${JSON.stringify(rawResult)}`); + if (typeof rawResult === 'object') { + // If it's already an object, use it directly + analysisData = rawResult; + logger.info(`[Manual Analysis] 'run' returned an object.`); + } + else if (typeof rawResult === 'string') { + // If it's a string, try to parse it as JSON + logger.info(`[Manual Analysis] 'run' returned a string, attempting JSON parse...`); + try { + // Basic cleanup: Remove potential markdown like ```json ... ``` wrapper + const cleanedString = rawResult.replace(/^```json\s*|```$/g, '').trim(); + analysisData = JSON.parse(cleanedString); + logger.info(`[Manual Analysis] Successfully parsed string result.`); + } + catch (parseError) { + // Corrected logger calls + logger.error(`[Manual Analysis] Failed to parse string result from 'run': ${parseError instanceof Error ? parseError.message : parseError}`); + logger.error(`[Manual Analysis] Raw string was: ${rawResult}`); + identifiedNodeForAnalysis.manualAnalysisResult = { error: 'parse failed', raw: rawResult }; // Store error/raw + } + } + else { + // Unexpected type + logger.warn(`[Manual Analysis] 'run' returned unexpected type: ${typeof rawResult}`); + identifiedNodeForAnalysis.manualAnalysisResult = { error: 'unexpected result type', raw: rawResult }; + } + // If parsing succeeded and we have data, attach it + if (analysisData) { + identifiedNodeForAnalysis.manualAnalysisResult = analysisData; // Attach parsed data + logger.info(`[Manual Analysis] Successfully attached analysis result object.`); + logger.info(`[Manual Analysis] Result Content: ${JSON.stringify(analysisData, null, 2)}`); + } + else { + logger.warn(`[Manual Analysis] 'run' command returned empty or unexpected result: ${JSON.stringify(results)}`); + identifiedNodeForAnalysis.manualAnalysisResult = { error: 'empty or unexpected result', raw: results }; + } + } + // Clean up tempId after processing + if (identifiedNodeForAnalysis && identifiedNodeForAnalysis.tempId) { + delete identifiedNodeForAnalysis.tempId; + logger.info(`[Manual Analysis] Removed tempId.`); + } + } + else { + logger.warn("[Manual Analysis] Node text was empty, skipping analysis LLM call."); + identifiedNodeForAnalysis.manualAnalysisResult = { error: 'empty source text' }; + } + } + catch (manualAnalysisError) { + logger.error("Error during manual analysis step:", manualAnalysisError); + // Attempt to clean up tempId even if analysis failed + if (identifiedNodeForAnalysis && identifiedNodeForAnalysis.tempId) { + delete identifiedNodeForAnalysis.tempId; + } + } + } + else { + logger.warn("[Manual Analysis] Target node for analysis was not identified in pre-processing. Skipping analysis."); + } + // --- Debug log checks for manualAnalysisResult --- + console.log("\n[DEBUG] Inspecting AST after all transforms, before visit call:"); try { - // Attempt to find the specific paragraph node expected to have analysisResult - // NOTE: This relies on index/structure and might be brittle - const potentialNode = astToTransform.children?.find((node) => node.type === 'paragraph' && - node.children?.[0]?.value?.includes("results")); - if (potentialNode) { - console.log("[DEBUG] Found potential node:", JSON.stringify(potentialNode, null, 2)); - console.log(`[DEBUG] Does potential node have analysisResult? ${potentialNode.hasOwnProperty('analysisResult')}`); + const potentialNode = astToTransform.children?.[16]; + if (potentialNode && potentialNode.type === 'paragraph') { + const hasManualProp = potentialNode.hasOwnProperty('manualAnalysisResult'); + console.log(`[DEBUG] Does potential node have manualAnalysisResult? ${hasManualProp}`); + if (hasManualProp) { + console.log("[DEBUG] manualAnalysisResult Content:", potentialNode.manualAnalysisResult); + } } else { - console.log("[DEBUG] Could not find the target paragraph node directly before visit."); + console.log("[DEBUG] Could not find the target paragraph node at index 16."); } console.log("---------------------------------------"); } catch (e) { console.error("[DEBUG] Error during pre-visit inspection:", e); } - // Retrieve the structured analysis result (if any) - // Note: The 'analysisResult' was added as a new property to the AST node by the mapping. - // We need to find that node again to see the result. This is clumsy. - let analysisData = null; + // Log the manually obtained result (if parsed successfully) + if (analysisData) { + console.log("\nStructured Analysis Result (Manually Obtained):"); + console.log(JSON.stringify(analysisData, null, 2)); + } + else { + console.log("\nStructured Analysis Result was not successfully obtained."); + // Raw result might be in the error object attached to the node now + } + // 6. Save the transformed AST to JSON (will include manualAnalysisResult) + console.log(`\nWriting transformed AST to JSON: ${OUTPUT_JSON_PATH}`); try { - visit(astToTransform, 'paragraph', (node) => { - if (node.analysisResult) { - analysisData = node.analysisResult; - // Optional: Remove the temporary property from the AST before stringifying - // delete node.analysisResult; - } - }); - if (analysisData) { - console.log("\nStructured Analysis Result:"); - // The LLM might return a stringified JSON, try parsing it - try { - const parsedResult = typeof analysisData === 'string' ? JSON.parse(analysisData) : analysisData; - console.log(JSON.stringify(parsedResult, null, 2)); - } - catch (e) { - console.log("Analysis result (raw):", analysisData); - } + const outputJsonDir = path.dirname(OUTPUT_JSON_PATH); + if (!fs.existsSync(outputJsonDir)) { + fs.mkdirSync(outputJsonDir, { recursive: true }); } - else { - console.log("\nStructured Analysis Result not found on AST (check targetPath logic and LLM response)."); + fs.writeFileSync(OUTPUT_JSON_PATH, JSON.stringify(astToTransform, null, 2)); + console.log("AST JSON saved successfully."); + } + catch (error) { + logger.error("Failed to write AST JSON:", error); + } + // 7. Stringify the modified AST back to Markdown + console.log("\nStringifying transformed AST to Markdown..."); + try { + const processorStringify = unified().use(remarkStringify); + const outputMarkdown = processorStringify.stringify(astToTransform); + // 8. Write the Markdown output file + console.log(`Writing output Markdown to: ${OUTPUT_MD_PATH}`); + const outputMdDir = path.dirname(OUTPUT_MD_PATH); + if (!fs.existsSync(outputMdDir)) { + fs.mkdirSync(outputMdDir, { recursive: true }); } + write(OUTPUT_MD_PATH, outputMarkdown); + console.log("Markdown file saved successfully."); } - catch (e) { - logger.error("Error visiting AST for analysis result retrieval:", e); + catch (stringifyError) { + logger.error("Failed to stringify or write Markdown output:", stringifyError); } - // 5. Stringify the modified AST back to Markdown - console.log("\nStringifying transformed AST..."); - const processorStringify = unified().use(remarkStringify); - // Stringify might fail if the AST structure became invalid during transformation - const outputMarkdown = processorStringify.stringify(astToTransform); - // 6. Write the output file - console.log(`Writing output to: ${OUTPUT_MD_PATH}`); - const outputDir = path.dirname(OUTPUT_MD_PATH); - if (!fs.existsSync(outputDir)) { - fs.mkdirSync(outputDir, { recursive: true }); - } - write(OUTPUT_MD_PATH, outputMarkdown); - console.log("Markdown transformation complete."); - return astToTransform; // Return the transformed AST + return astToTransform; } catch (error) { logger.error("ERROR during Markdown transformation:", error); @@ -272,4 +324,4 @@ if (process.argv[1] && process.argv[1].includes('iterator-markdown-example')) { process.exit(1); // Exit with error code }); } -//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"iterator-markdown-example.js","sourceRoot":"","sources":["../../../src/examples/core/iterator-markdown-example.ts"],"names":[],"mappings":"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"} \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"iterator-markdown-example.js","sourceRoot":"","sources":["../../../src/examples/core/iterator-markdown-example.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/packages/kbot/logs/params.json b/packages/kbot/logs/params.json index 041bc522..8a6a3af5 100644 --- a/packages/kbot/logs/params.json +++ b/packages/kbot/logs/params.json @@ -3,7 +3,7 @@ "messages": [ { "role": "user", - "content": "Summarize this paragraph in one short sentence (max 15 words).\n\nText to transform: \"A concluding paragraph summarizing the key findings.\"" + "content": "Analyze the following text and extract keywords and sentiment. Respond ONLY with a valid JSON object matching the schema provided in the 'format' field. Do not include any other text, explanations, or markdown formatting.\n\nText to analyze:\n\"The text mentions sunny weather, making it ideal for a park walk.\"" }, { "role": "user", diff --git a/packages/kbot/src/examples/core/iterator-markdown-example.ts b/packages/kbot/src/examples/core/iterator-markdown-example.ts index a369f4f9..fc80d439 100644 --- a/packages/kbot/src/examples/core/iterator-markdown-example.ts +++ b/packages/kbot/src/examples/core/iterator-markdown-example.ts @@ -10,6 +10,8 @@ import { E_OPENROUTER_MODEL } from '../../models/cache/openrouter-models.js'; import { E_Mode } from '../../zod_schema.js'; import { FieldMapping, transform, IOptions, createLLMTransformer, CacheConfig, ILogger } from '../../iterator.js'; import { OnTransformCallback } from '../../async-iterator.js'; +import { deepClone } from '@polymech/core/objects'; +import { run } from '../../commands/run.js'; /** * Notes for LLM modifications @@ -25,6 +27,7 @@ const MODEL = E_OPENROUTER_MODEL.MODEL_OPENAI_GPT_4O_MINI; // Corrected model na const ROUTER = 'openrouter'; const INPUT_MD_PATH = path.resolve('./tests/test-data/core/md-test.md'); const OUTPUT_MD_PATH = path.resolve('./tests/test-data/core/md-test-out.md'); +const OUTPUT_JSON_PATH = path.resolve('./tests/test-data/core/md-test-out.json'); // Basic logger const logger: ILogger = { @@ -52,56 +55,22 @@ function getLLMTransformerForMdast( } // Define field mappings for the mdast structure -const fieldMappings: FieldMapping[] = [ +// Mappings for standard transforms (targetPath: null) +const standardMappings: FieldMapping[] = [ { - // Target text value within H1-H5 headings' children jsonPath: '$.children[?(@.type=="heading" && @.depth <= 5)].children[?(@.type=="text")].value', - targetPath: null, // Modify in place (NOTE: This likely won't work due to iterator limitations) - options: { - prompt: 'Rewrite this heading to be more concise and impactful (max 5 words).' - } + targetPath: null, + options: { prompt: 'Rewrite this heading to be more concise and impactful (max 5 words).' } }, { - // Target the specific paragraph NODE in Chapter 4 for structured analysis. - // The transformer will extract text from the node passed to it. - // Using targetPath='analysisResult' stores the LLM output on the node itself. - jsonPath: '$.children[?(@.type=="paragraph" && @.children[0].value.includes("results"))]', - targetPath: 'analysisResult', // Store result in a new property on the paragraph node - options: { - prompt: 'Extract keywords and sentiment from this text.', - format: { - type: "object", - properties: { - sentiment: { - type: "string", - enum: ["positive", "neutral", "negative"], - description: "Overall sentiment" - }, - keywords: { - type: "array", - items: { type: "string" }, - description: "Main keywords (max 5)" - } - }, - required: ["sentiment", "keywords"] - } - } - }, - { - // Target text value within paragraphs' children jsonPath: '$.children[?(@.type=="paragraph")].children[?(@.type=="text")].value', - targetPath: null, // Modify in place (NOTE: This likely won't work due to iterator limitations) - options: { - prompt: 'Summarize this paragraph in one short sentence (max 15 words).' - } + targetPath: null, + options: { prompt: 'Summarize this paragraph in one short sentence (max 15 words).' } }, { - // Target text value within table cells' children jsonPath: '$.children[?(@.type=="table")].children[*].children[*].children[?(@.type=="text")].value', - targetPath: null, // Modify in place (NOTE: This likely won't work due to iterator limitations) - options: { - prompt: 'Rephrase this table cell content slightly.' - } + targetPath: null, + options: { prompt: 'Rephrase this table cell content slightly.' } } ]; @@ -129,9 +98,25 @@ export async function markdownTransformExample(useCache = true) { // Make a deep copy to avoid modifying the original AST if transform fails // Note: Standard deepClone might not work perfectly with complex AST nodes (position, data fields). - // For this example, JSON stringify/parse is a common workaround, but beware of data loss. - let astToTransform = JSON.parse(JSON.stringify(ast)); + // Using deepClone instead of JSON.parse/stringify + let astToTransform = deepClone(ast); + // --- Pre-processing: Add temporary ID to the target node --- + const analysisTargetText = "results"; // Text to identify the node + const tempIdValue = 'analyze-me'; + let identifiedNodeForAnalysis: any = null; // Store reference to the node + try { + visit(astToTransform, 'paragraph', (node: any) => { + if (node.children?.[0]?.value?.includes(analysisTargetText)) { + node.tempId = tempIdValue; + identifiedNodeForAnalysis = node; // Store the reference + logger.info(`[Pre-process] Added tempId='${tempIdValue}' and stored reference to node containing '${analysisTargetText}'`); + } + }); + } catch(e) { + logger.error("[Pre-process] Error adding temporary ID:", e); + identifiedNodeForAnalysis = null; // Ensure we don't proceed if tagging failed + } // 3. Define global options and iterator options const globalOptionsMixin: Partial = { @@ -141,142 +126,185 @@ export async function markdownTransformExample(useCache = true) { }; const iteratorOptions: IOptions = { - // We provide our custom transformer factory transformerFactory: (opts) => getLLMTransformerForMdast(opts, logger, { enabled: useCache }), logger: logger, cacheConfig: { enabled: useCache, namespace: 'markdown-transforms' }, - // onTransform receives the value matched by jsonPath (can be string or node). - // It must return the STRING to be transformed by the LLM. onTransform: async (jsonPath, value, kbotOptions) => { let textContent = ''; - // Check if the value is a node object or just a string - if (typeof value === 'string') { - textContent = value; - console.log(` -> onTransform String Value: Path='${jsonPath}', Value='${textContent.substring(0, 50)}...'`); - } else if (typeof value === 'object' && value !== null) { - // Attempt to extract text if it's a node (e.g., for the analysisResult mapping) - const node = value as any; // Basic type assertion - if ((node.type === 'heading' || node.type === 'paragraph' || node.type === 'tableCell') && node.children?.length === 1 && node.children[0].type === 'text') { - textContent = node.children[0].value || ''; - } else if (node.type === 'text') { - textContent = node.value || ''; - } else if (Array.isArray(node.children)) { // Handle complex children - textContent = node.children - .filter((child: any) => child.type === 'text' || child.type === 'inlineCode') - .map((child: any) => child.value) - .join(''); - } - console.log(` -> onTransform AST Node: Path='${jsonPath}', Node Type='${node?.type}', Extracted Text='${textContent.substring(0, 50)}...'`); - } else { - console.log(` -> onTransform Unexpected Value Type: Path='${jsonPath}', Type='${typeof value}'`); - } - - // Return the extracted string for the LLM transformer - return textContent; + if (typeof value === 'string') { textContent = value; console.log(` -> onTransform String Value: Path='${jsonPath}', Value='${textContent.substring(0, 50)}...'`); } + else if (typeof value === 'object' && value !== null) { const node = value as any; textContent = node.children?.[0]?.value || node.value || ''; console.log(` -> onTransform AST Node: Path='${jsonPath}', Node Type='${node?.type}', Extracted Text='${textContent.substring(0, 50)}...'`); } + else { console.log(` -> onTransform Unexpected Value Type: Path='${jsonPath}', Type='${typeof value}'`); } + return textContent; }, - errorCallback: (path, value, error) => { - if (error instanceof Error) { - logger.error(`Error processing path ${path}: ${error.message}`, error); - } else { - logger.error(`Error processing path ${path}: ${error}`, error); - } - }, - filterCallback: async (value, jsonPath) => { - // Allow transformation if the value is an object (likely an AST node targeted directly) - if (typeof value === 'object' && value !== null) { - return true; - } - // If it's a string, apply the default string filter logic - if (typeof value === 'string') { - // Reuse the default isValidString filter logic for strings - const allow = value.trim() !== ''; - if (!allow) { - logger.info(`Filter: Skipping empty string at ${jsonPath}`); - } - return allow; - } - // Skip other types (numbers, booleans, null, undefined) - logger.warn(`Filter: Skipping non-string/non-object value type (${typeof value}) at ${jsonPath}`); - return false; - } + errorCallback: (path, value, error) => { + if (error instanceof Error) { logger.error(`Error processing path ${path}: ${error.message}`, error); } else { logger.error(`Error processing path ${path}: ${error}`, error); } + }, + filterCallback: async (value, jsonPath) => { + if (typeof value === 'object' && value !== null) { return true; } if (typeof value === 'string') { const allow = value.trim() !== ''; if (!allow) { logger.info(`Filter: Skipping empty string at ${jsonPath}`); } return allow; } logger.warn(`Filter: Skipping non-string/non-object value type (${typeof value}) at ${jsonPath}`); return false; + } }; - // 4. Use the transform function - console.log("Applying transformations to AST..."); - // The 'transform' function iterates based on JSONPath and applies the transformerFactory's result - // It modifies the 'astToTransform' object in place. + // 4. Run standard transformations + console.log("Applying standard transformations to AST..."); await transform( - astToTransform, // Pass the AST object - fieldMappings, + astToTransform, + standardMappings, globalOptionsMixin, iteratorOptions ); - // *** Add logging before visit *** - console.log("\n[DEBUG] Inspecting AST before visit call:"); - try { - // Attempt to find the specific paragraph node expected to have analysisResult - // NOTE: This relies on index/structure and might be brittle - const potentialNode = astToTransform.children?.find((node: any) => - node.type === 'paragraph' && - node.children?.[0]?.value?.includes("results") - ); - if (potentialNode) { - console.log("[DEBUG] Found potential node:", JSON.stringify(potentialNode, null, 2)); - console.log(`[DEBUG] Does potential node have analysisResult? ${potentialNode.hasOwnProperty('analysisResult')}`); - } else { - console.log("[DEBUG] Could not find the target paragraph node directly before visit."); + // 5. Perform Analysis Manually (if node was identified) + console.log("\nPerforming manual analysis..."); + let analysisData: any = null; // Store successfully parsed result here + let rawAnalysisResult: string | null = null; // Store raw LLM result + + if (identifiedNodeForAnalysis) { + try { + let nodeText: string = ''; + // Extract text from the (now potentially modified) node + if (identifiedNodeForAnalysis.children?.[0]?.type === 'text') { + nodeText = identifiedNodeForAnalysis.children[0].value || ''; + } + logger.info(`[Manual Analysis] Found node with tempId. Extracted text: "${nodeText.substring(0, 50)}..."`); + + if (nodeText) { + // Define analysis task options + const analysisTaskOptions: IKBotTask = { + ...globalOptionsMixin, + // Explicitly request ONLY JSON matching the schema + prompt: `Analyze the following text and extract keywords and sentiment. Respond ONLY with a valid JSON object matching the schema provided in the 'format' field. Do not include any other text, explanations, or markdown formatting.\n\nText to analyze:\n"${nodeText}"`, + format: { + type: "object", + properties: { + sentiment: { type: "string", enum: ["positive", "neutral", "negative"] }, + keywords: { type: "array", items: { type: "string" }, maxItems: 5 } + }, + required: ["sentiment", "keywords"] + }, + mode: E_Mode.COMPLETION + }; + + // Call the run command + logger.info(`[Manual Analysis] Calling run command with format option...`); + const results = await run(analysisTaskOptions); + + // Process the result (run should return the parsed object) + if (results && results.length > 0) { + const rawResult = results[0]; + logger.info(`[Manual Analysis] Raw result from run: ${JSON.stringify(rawResult)}`); + + if (typeof rawResult === 'object') { + // If it's already an object, use it directly + analysisData = rawResult; + logger.info(`[Manual Analysis] 'run' returned an object.`); + } else if (typeof rawResult === 'string') { + // If it's a string, try to parse it as JSON + logger.info(`[Manual Analysis] 'run' returned a string, attempting JSON parse...`); + try { + // Basic cleanup: Remove potential markdown like ```json ... ``` wrapper + const cleanedString = rawResult.replace(/^```json\s*|```$/g, '').trim(); + analysisData = JSON.parse(cleanedString); + logger.info(`[Manual Analysis] Successfully parsed string result.`); + } catch (parseError) { + // Corrected logger calls + logger.error(`[Manual Analysis] Failed to parse string result from 'run': ${parseError instanceof Error ? parseError.message : parseError}`); + logger.error(`[Manual Analysis] Raw string was: ${rawResult}`); + identifiedNodeForAnalysis.manualAnalysisResult = { error: 'parse failed', raw: rawResult }; // Store error/raw + } + } else { + // Unexpected type + logger.warn(`[Manual Analysis] 'run' returned unexpected type: ${typeof rawResult}`); + identifiedNodeForAnalysis.manualAnalysisResult = { error: 'unexpected result type', raw: rawResult }; + } + + // If parsing succeeded and we have data, attach it + if (analysisData) { + identifiedNodeForAnalysis.manualAnalysisResult = analysisData; // Attach parsed data + logger.info(`[Manual Analysis] Successfully attached analysis result object.`); + logger.info(`[Manual Analysis] Result Content: ${JSON.stringify(analysisData, null, 2)}`); + } else { + logger.warn(`[Manual Analysis] 'run' command returned empty or unexpected result: ${JSON.stringify(results)}`); + identifiedNodeForAnalysis.manualAnalysisResult = { error: 'empty or unexpected result', raw: results }; + } + } + + // Clean up tempId after processing + if (identifiedNodeForAnalysis && identifiedNodeForAnalysis.tempId) { + delete identifiedNodeForAnalysis.tempId; + logger.info(`[Manual Analysis] Removed tempId.`); + } + + } else { + logger.warn("[Manual Analysis] Node text was empty, skipping analysis LLM call."); + identifiedNodeForAnalysis.manualAnalysisResult = { error: 'empty source text' }; + } + + } catch (manualAnalysisError) { + logger.error("Error during manual analysis step:", manualAnalysisError); + // Attempt to clean up tempId even if analysis failed + if (identifiedNodeForAnalysis && identifiedNodeForAnalysis.tempId) { + delete identifiedNodeForAnalysis.tempId; + } } - console.log("---------------------------------------"); + } else { + logger.warn("[Manual Analysis] Target node for analysis was not identified in pre-processing. Skipping analysis."); + } + + // --- Debug log checks for manualAnalysisResult --- + console.log("\n[DEBUG] Inspecting AST after all transforms, before visit call:"); + try { + const potentialNode = astToTransform.children?.[16]; + if (potentialNode && potentialNode.type === 'paragraph') { + const hasManualProp = potentialNode.hasOwnProperty('manualAnalysisResult'); + console.log(`[DEBUG] Does potential node have manualAnalysisResult? ${hasManualProp}`); + if (hasManualProp) { + console.log("[DEBUG] manualAnalysisResult Content:", (potentialNode as any).manualAnalysisResult); + } + } else { + console.log("[DEBUG] Could not find the target paragraph node at index 16."); + } + console.log("---------------------------------------"); } catch (e) { console.error("[DEBUG] Error during pre-visit inspection:", e); } + + // Log the manually obtained result (if parsed successfully) + if (analysisData) { + console.log("\nStructured Analysis Result (Manually Obtained):"); + console.log(JSON.stringify(analysisData, null, 2)); + } else { + console.log("\nStructured Analysis Result was not successfully obtained."); + // Raw result might be in the error object attached to the node now + } - // Retrieve the structured analysis result (if any) - // Note: The 'analysisResult' was added as a new property to the AST node by the mapping. - // We need to find that node again to see the result. This is clumsy. - let analysisData: any = null; + // 6. Save the transformed AST to JSON (will include manualAnalysisResult) + console.log(`\nWriting transformed AST to JSON: ${OUTPUT_JSON_PATH}`); try { - visit(astToTransform, 'paragraph', (node: any) => { - if (node.analysisResult) { - analysisData = node.analysisResult; - // Optional: Remove the temporary property from the AST before stringifying - // delete node.analysisResult; - } - }); - if (analysisData) { - console.log("\nStructured Analysis Result:"); - // The LLM might return a stringified JSON, try parsing it - try { - const parsedResult = typeof analysisData === 'string' ? JSON.parse(analysisData) : analysisData; - console.log(JSON.stringify(parsedResult, null, 2)); - } catch (e) { - console.log("Analysis result (raw):", analysisData); - } - } else { - console.log("\nStructured Analysis Result not found on AST (check targetPath logic and LLM response)."); - } - } catch (e) { - logger.error("Error visiting AST for analysis result retrieval:", e) + const outputJsonDir = path.dirname(OUTPUT_JSON_PATH); + if (!fs.existsSync(outputJsonDir)) { fs.mkdirSync(outputJsonDir, { recursive: true }); } + fs.writeFileSync(OUTPUT_JSON_PATH, JSON.stringify(astToTransform, null, 2)); + console.log("AST JSON saved successfully."); + } catch (error) { + logger.error("Failed to write AST JSON:", error); } + // 7. Stringify the modified AST back to Markdown + console.log("\nStringifying transformed AST to Markdown..."); + try { + const processorStringify = unified().use(remarkStringify); + const outputMarkdown = processorStringify.stringify(astToTransform as any); - // 5. Stringify the modified AST back to Markdown - console.log("\nStringifying transformed AST..."); - const processorStringify = unified().use(remarkStringify); - // Stringify might fail if the AST structure became invalid during transformation - const outputMarkdown = processorStringify.stringify(astToTransform as any); - - // 6. Write the output file - console.log(`Writing output to: ${OUTPUT_MD_PATH}`); - const outputDir = path.dirname(OUTPUT_MD_PATH); - if (!fs.existsSync(outputDir)) { - fs.mkdirSync(outputDir, { recursive: true }); + // 8. Write the Markdown output file + console.log(`Writing output Markdown to: ${OUTPUT_MD_PATH}`); + const outputMdDir = path.dirname(OUTPUT_MD_PATH); + if (!fs.existsSync(outputMdDir)) { fs.mkdirSync(outputMdDir, { recursive: true }); } + write(OUTPUT_MD_PATH, outputMarkdown); + console.log("Markdown file saved successfully."); + } catch (stringifyError) { + logger.error("Failed to stringify or write Markdown output:", stringifyError); } - write(OUTPUT_MD_PATH, outputMarkdown); - console.log("Markdown transformation complete."); - return astToTransform; // Return the transformed AST + return astToTransform; } catch (error) { logger.error("ERROR during Markdown transformation:", error);