notes-to-strapi-export-article-ai 3.0.2 → 3.0.5

package/README.md

@@ -5,6 +5,7 @@
 [![Sponsor](https://img.shields.io/badge/sponsor-CinquinAndy-purple)](https://github.com/sponsors/CinquinAndy)
 
 Strapi Exporter is a game-changing Obsidian plugin that streamlines your content creation process by seamlessly exporting your notes to Strapi CMS. With its AI-powered image handling and SEO optimization features, you can take your content to the next level with just a few clicks.
+! This plugin was totally refactored, since the 3.0.0 version ! Restart your configuration !
 
 ## ✨ Key Features
 

package/manifest.json

@@ -1,7 +1,7 @@
 {
 	"id": "notes-to-strapi-export-article-ai",
 	"name": "Strapi Exporter AI",
-	"version": "3.0.2",
+	"version": "3.0.5",
 	"minAppVersion": "1.7.0",
 	"description": "Effortlessly export your notes to Strapi CMS with AI-powered handling and SEO optimization.",
 	"author": "Cinquin Andy",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "notes-to-strapi-export-article-ai",
-  "version": "3.0.2",
+  "version": "3.0.5",
   "description": "Effortlessly export your Obsidian notes to Strapi CMS with AI-powered image handling and SEO optimization. Replace all the images in your notes by uploaded images in Strapi, and add SEO metadata to uploaded images.",
   "main": "main.js",
   "scripts": {
@@ -25,7 +25,7 @@
     "@ai-sdk/openai": "0.0.72",
     "ai": "3.4.33",
     "js-yaml": "4.1.0",
-    "openai": "4.71.1",
+    "openai": "4.72.0",
     "process": "0.11.10"
   }
 }

package/src/services/frontmatter.ts

@@ -1,8 +1,11 @@
 import { generateText } from 'ai'
 import { createOpenAI } from '@ai-sdk/openai'
-import { App, TFile } from 'obsidian'
+import { App, Notice, TFile } from 'obsidian'
 import { RouteConfig } from '../types'
 import StrapiExporterPlugin from '../main'
+import { processContentLinks } from '../utils/process-file'
+import { extractFrontMatterAndContent } from '../utils/analyse-file'
+import yaml from 'js-yaml'
 
 /**
  * Interface defining the structure of a field in the schema
@@ -55,11 +58,72 @@ export class FrontmatterGenerator {
 	 * @returns Promise<string> Updated content with new frontmatter
 	 */
 	async updateContentFrontmatter(file: TFile, app: App): Promise<string> {
-		const content = await app.vault.read(file)
-		const newFrontmatter = await this.generateFrontmatter(file, app)
-		const updatedContent = this.replaceFrontmatter(content, newFrontmatter)
+		try {
+			// Read original content
+			const originalContent = await app.vault.read(file)
+
+			// Process images in the content first
+			const processedContent = await this.processContentWithImages(
+				originalContent,
+				app
+			)
+
+			// Generate new frontmatter
+			const newFrontmatter = await this.generateFrontmatter(
+				file,
+				app,
+				processedContent
+			)
+
+			// Replace or add frontmatter to the processed content
+			const updatedContent = this.replaceFrontmatter(
+				processedContent,
+				newFrontmatter
+			)
+
+			return updatedContent
+		} catch (error) {
+			new Notice(`Error processing content: ${error.message}`)
+			throw error
+		}
+	}
+
+	/**
+	 * Process content including images
+	 * @param content - Original content
+	 * @param app - The Obsidian app instance
+	 * @returns Promise<string> Processed content with updated image links
+	 */
+	private async processContentWithImages(
+		content: string,
+		app: App
+	): Promise<string> {
+		try {
+			const { frontmatter, body } = extractFrontMatterAndContent(content)
+
+			// Process only the images in the content, leaving regular links unchanged
+			const processedContent = await processContentLinks(
+				body,
+				app,
+				this.plugin.settings
+			)
+
+			// If frontmatter exists, reconstruct the content with it
+			if (Object.keys(frontmatter).length > 0) {
+				return [
+					'---',
+					yaml.dump(frontmatter),
+					'---',
+					'',
+					processedContent,
+				].join('\n')
+			}
 
-		return updatedContent
+			return processedContent
+		} catch (error) {
+			new Notice(`Error processing images: ${error.message}`)
+			throw error
+		}
 	}
 
 	/**
@@ -105,10 +169,8 @@ export class FrontmatterGenerator {
 			return ['example1', 'example2']
 		}
 
-		// Analyze transform string to determine array structure
 		const transform = field.transform
 
-		// Handle different array structures based on transform content
 		if (transform.includes('name:')) {
 			return [
 				{ name: 'example1', id: 1 },
@@ -144,7 +206,7 @@ export class FrontmatterGenerator {
 			.map(([field]) => field)
 			.join(', ')
 
-		const prompt = `Generate YAML frontmatter that follows this exact schema and format:
+		return `Generate YAML frontmatter that follows this exact schema and format:
 
 Schema Definition:
 ${JSON.stringify(config.fieldMappings, null, 2)}
@@ -169,8 +231,6 @@ DO NOT include the content IN the generated frontmatter. Just use the content to
 the content field is ${config.contentField}. Please delete the content field from the frontmatter.
 
 Return complete YAML frontmatter with opening and closing "---" markers.`
-
-		return prompt
 	}
 
 	/**
@@ -233,13 +293,18 @@ Return complete YAML frontmatter with opening and closing "---" markers.`
 	}
 
 	/**
-	 * Main method to generate frontmatter based on file content and schema
+	 * Generates frontmatter based on file content and schema
 	 * @param file - The file to process
 	 * @param app - The Obsidian app instance
+	 * @param processedContent - Optional pre-processed content
 	 * @returns Promise<string> Generated frontmatter
 	 */
-	async generateFrontmatter(file: TFile, app: App): Promise<string> {
-		const content = await app.vault.read(file)
+	async generateFrontmatter(
+		file: TFile,
+		app: App,
+		processedContent?: string
+	): Promise<string> {
+		const content = processedContent || (await app.vault.read(file))
 		const currentRoute = this.getCurrentRoute()
 
 		if (!currentRoute?.generatedConfig) {

package/src/services/strapi-export.ts

@@ -1,16 +1,25 @@
 import { RouteConfig, AnalyzedContent } from '../types'
 import { StrapiExporterSettings } from '../types/settings'
 import { extractFrontMatterAndContent } from '../utils/analyse-file'
-import { App, TFile } from 'obsidian'
+import { App, Notice, TFile } from 'obsidian'
 import { uploadImageToStrapi } from '../utils/strapi-uploader'
 import * as yaml from 'js-yaml'
+import { createOpenAI } from '@ai-sdk/openai'
+import { generateText } from 'ai'
 
 export class StrapiExportService {
+	private model
+
 	constructor(
 		private settings: StrapiExporterSettings,
 		private app: App,
 		private file: TFile
-	) {}
+	) {
+		const openai = createOpenAI({
+			apiKey: this.settings.openaiApiKey,
+		})
+		this.model = openai('gpt-4o-mini')
+	}
 
 	private async sendToStrapi(data: any, route: RouteConfig): Promise<void> {
 		const url = `${this.settings.strapiUrl}${route.url}`
@@ -390,18 +399,247 @@ export class StrapiExportService {
 		this.validateSettings()
 		this.validateRoute(route)
 
-		const exportData = await this.prepareExportData(this.app, this.file, route)
+		try {
+			let exportData = await this.prepareExportData(this.app, this.file, route)
 
-		if (exportData.data[route.contentField]) {
-			const { content: processedContent } = await this.processContentImages(
-				exportData.data[route.contentField]
-			)
-			exportData.data[route.contentField] = processedContent
+			if (exportData.data[route.contentField]) {
+				const { content: processedContent } = await this.processContentImages(
+					exportData.data[route.contentField]
+				)
+				exportData.data[route.contentField] = processedContent
+			}
+
+			exportData.data = await this.convertImageUrlsToIds(exportData.data)
+
+			try {
+				await this.sendToStrapi(exportData, route)
+			} catch (strapiError) {
+				new Notice(`Failed to upload, retrying with simplified data...`)
+				// Parse and analyze the error
+				const errorDetails = await this.parseAndAnalyzeError(strapiError)
+
+				// Regenerate data with error details
+				exportData = await this.regenerateDataWithError(
+					exportData,
+					errorDetails,
+					route
+				)
+
+				// Retry sending to Strapi
+				await this.sendToStrapi(exportData, route)
+			}
+		} catch (error) {
+			throw new Error(`Export failed: ${error.message}`)
+		}
+	}
+
+	/**
+	 * Process individual error messages from Strapi response
+	 */
+	private async parseAndAnalyzeError(error: any): Promise<any> {
+		try {
+			// If we already have JSON data in the error response
+			if (error.response?.data) {
+				return {
+					statusCode: error.response.status,
+					error: error.response.data.error,
+					details: error.response.data.error?.details || {},
+					message: error.response.data.error?.message || 'Unknown error',
+				}
+			}
+
+			// Handle string error message
+			if (typeof error === 'string') {
+				return {
+					statusCode: 500,
+					error: { message: error },
+					details: {},
+					message: error,
+				}
+			}
+
+			// Extract detailed error info
+			const errorInfo = error.toString().split(': ').pop()
+			let parsedError
+
+			try {
+				parsedError = JSON.parse(errorInfo)
+			} catch {
+				parsedError = { message: errorInfo }
+			}
+
+			return {
+				statusCode: error.response?.status || 500,
+				error: parsedError,
+				details: parsedError.details || {},
+				message: parsedError.message || 'Unknown error',
+			}
+		} catch (e) {
+			console.error('Error parsing Strapi response:', e)
+			return {
+				statusCode: error.response?.status || 500,
+				error: { message: 'Failed to parse error response' },
+				details: {},
+				message: error.message || 'Unknown error',
+			}
 		}
+	}
 
-		exportData.data = await this.convertImageUrlsToIds(exportData.data)
+	/**
+	 * Regenerate data based on Strapi error feedback
+	 */
+	private async regenerateDataWithError(
+		originalData: any,
+		errorDetails: any,
+		route: RouteConfig
+	): Promise<any> {
+		const { text } = await generateText({
+			model: this.model,
+			system: `You are an API expert specializing in Strapi CMS. You MUST return only valid JSON data.
+                Do not include any explanations or text outside of the JSON structure.
+                The response must be parseable by JSON.parse().`,
+			prompt: `
+            Fix this failed Strapi API request.
+
+            Error Information:
+            Status Code: ${errorDetails.statusCode}
+            Message: ${errorDetails.message}
+            Details: ${JSON.stringify(errorDetails.details, null, 2)}
+
+            Original Request Data:
+            ${JSON.stringify(originalData, null, 2)}
+
+            Route Configuration and Schema:
+            ${route.generatedConfig}
+
+            IMPORTANT: Return ONLY valid JSON in the exact format:
+            {
+              "data": {
+                // corrected fields here
+              }
+            }
+            
+            If the error is something similar with an Unknown error, try to delete the complexe fields, galleries, lists, etc. and keep only the simple fields.
+
+            Do not include any text explanations - use the "__comment" field inside the JSON if needed.
+            The entire response must be valid JSON that can be parsed with JSON.parse().
+        `,
+		})
+
+		try {
+			// First, try to clean the response if needed
+			const cleanedText = this.cleanAIResponse(text)
+
+			let correctedData: any
+			try {
+				correctedData = JSON.parse(cleanedText)
+				// eslint-disable-next-line @typescript-eslint/no-unused-vars
+			} catch (e) {
+				// If parsing fails, attempt to extract JSON from the response
+				const extractedJson = this.extractJsonFromText(cleanedText)
+				if (!extractedJson) {
+					console.error('Original AI response:', text)
+					console.error('Cleaned response:', cleanedText)
+					throw new Error('Could not extract valid JSON from AI response')
+				}
+				correctedData = JSON.parse(extractedJson)
+			}
+
+			// Validate basic structure
+			if (!correctedData.data) {
+				correctedData = { data: correctedData }
+			}
+
+			// Log for debugging
+			console.log('Original data:', originalData)
+			console.log('Error details:', errorDetails)
+			console.log('Corrected data:', correctedData)
+
+			if (correctedData.__comment) {
+				console.log('Correction comment:', correctedData.__comment)
+				new Notice(`Changes made: ${correctedData.__comment}`)
+				delete correctedData.__comment
+			}
+
+			return correctedData
+		} catch (e) {
+			console.error('AI Response:', text)
+			console.error('Generation error:', e)
+
+			// Fallback: return a sanitized version of the original data
+			return this.createFallbackData(originalData, errorDetails)
+		}
+	}
+
+	/**
+	 * Clean AI response text to ensure valid JSON
+	 */
+	private cleanAIResponse(text: string): string {
+		// Remove markdown code blocks if present
+		// eslint-disable-next-line no-useless-escape
+		text = text.replace(/```json\n?|\```\n?/g, '')
+
+		// Remove any leading/trailing whitespace
+		text = text.trim()
+
+		// Remove any text before the first {
+		const firstBrace = text.indexOf('{')
+		if (firstBrace > 0) {
+			text = text.substring(firstBrace)
+		}
+
+		// Remove any text after the last }
+		const lastBrace = text.lastIndexOf('}')
+		if (lastBrace !== -1 && lastBrace < text.length - 1) {
+			text = text.substring(0, lastBrace + 1)
+		}
+
+		return text
+	}
+
+	/**
+	 * Extract JSON from text that might contain other content
+	 */
+	private extractJsonFromText(text: string): string | null {
+		const jsonRegex = /{[\s\S]*}/
+		const match = text.match(jsonRegex)
+		return match ? match[0] : null
+	}
+
+	/**
+	 * Create fallback data when regeneration fails
+	 */
+	private createFallbackData(originalData: any, errorDetails: any): any {
+		console.log('Using fallback data generation')
+
+		// Start with the original data
+		const fallbackData = { ...originalData }
+
+		// Remove fields mentioned in error details
+		if (errorDetails.details?.errors) {
+			errorDetails.details.errors.forEach((error: any) => {
+				if (error.path) {
+					const path = Array.isArray(error.path) ? error.path : [error.path]
+					let current = fallbackData.data
+					for (let i = 0; i < path.length - 1; i++) {
+						if (current[path[i]]) {
+							current = current[path[i]]
+						}
+					}
+					const lastKey = path[path.length - 1]
+					if (current[lastKey]) {
+						delete current[lastKey]
+					}
+				}
+			})
+		}
+
+		// Ensure the data property exists
+		if (!fallbackData.data) {
+			fallbackData.data = {}
+		}
 
-		await this.sendToStrapi(exportData, route)
+		return fallbackData
 	}
 
 	/**

package/src/utils/process-file.ts

@@ -2,76 +2,127 @@ import { App, TFile } from 'obsidian'
 import { StrapiExporterSettings, AnalyzedContent } from '../types'
 import { uploadImageToStrapi } from './strapi-uploader'
 
+/**
+ * Types for link detection and processing
+ */
+interface LinkMatch {
+	type: 'link'
+	fullMatch: string
+	text: string
+	url: string
+}
+
 interface ImageMatch {
+	type: 'image'
 	fullMatch: string
 	altText: string
-	imagePath: string
+	path: string
+	isWikiLink: boolean
 }
 
-/**
- * Process images in content fields and upload them to Strapi
- */
-export async function processImages(
-	content: AnalyzedContent,
-	app: App,
-	settings: StrapiExporterSettings
-): Promise<AnalyzedContent> {
-	const processedContent = { ...content }
+export function extractLinks(content: string): (LinkMatch | ImageMatch)[] {
+	const matches: (LinkMatch | ImageMatch)[] = []
 
-	for (const [key, value] of Object.entries(processedContent)) {
-		if (typeof value === 'string') {
-			processedContent[key] = await processImageLinks(value, app, settings)
-		}
+	// Regular expressions for different link types
+	const patterns = {
+		wikiImage: /!\[\[([^\]]+\.(png|jpe?g|gif|svg|bmp|webp))\]\]/gi,
+		markdownImage: /!\[([^\]]*)\]\(([^)]+\.(png|jpe?g|gif|svg|bmp|webp))\)/gi,
+		standardLink: /(?<!!)\[([^\]]+)\]\(([^)]+)\)/gi, // Negative lookbehind to exclude image links
+		pastedImage: /\[\[Pasted image [0-9-]+\.png\]\]/gi,
 	}
 
-	return processedContent
+	// Process Wiki-style image links
+	let match
+	while ((match = patterns.wikiImage.exec(content)) !== null) {
+		matches.push({
+			type: 'image',
+			fullMatch: match[0],
+			altText: match[1].split('|')[1] || match[1].split('/').pop() || '',
+			path: match[1].split('|')[0],
+			isWikiLink: true,
+		})
+	}
+
+	// Process Markdown-style image links
+	while ((match = patterns.markdownImage.exec(content)) !== null) {
+		matches.push({
+			type: 'image',
+			fullMatch: match[0],
+			altText: match[1],
+			path: match[2],
+			isWikiLink: false,
+		})
+	}
+
+	// Process pasted images
+	while ((match = patterns.pastedImage.exec(content)) !== null) {
+		matches.push({
+			type: 'image',
+			fullMatch: match[0],
+			altText: 'Pasted image',
+			path: match[0].slice(2, -2), // Remove [[ and ]]
+			isWikiLink: true,
+		})
+	}
+
+	// Process standard links (non-image)
+	while ((match = patterns.standardLink.exec(content)) !== null) {
+		matches.push({
+			type: 'link',
+			fullMatch: match[0],
+			text: match[1],
+			url: match[2],
+		})
+	}
+
+	return matches
 }
 
 /**
- * Process image links in content string
+ * Process identified links and images
  */
-async function processImageLinks(
+export async function processContentLinks(
 	content: string,
 	app: App,
 	settings: StrapiExporterSettings
 ): Promise<string> {
-	const imageMatches = extractImageMatches(content)
-
 	let processedContent = content
-
-	for (const match of imageMatches) {
-		const replacedContent = await processImageMatch(
-			match,
-			processedContent,
-			app,
-			settings
-		)
-
-		if (replacedContent !== processedContent) {
-			processedContent = replacedContent
+	const matches = extractLinks(content)
+
+	for (const match of matches) {
+		if (match.type === 'image') {
+			const processedImage = await processImageMatch(match, app, settings)
+			if (processedImage) {
+				processedContent = processedContent.replace(
+					match.fullMatch,
+					processedImage
+				)
+			}
 		}
+		// Standard links are left unchanged
 	}
 
 	return processedContent
 }
 
 /**
- * Extract image matches from content
+ * Process images in content fields and upload them to Strapi
  */
-function extractImageMatches(content: string): ImageMatch[] {
-	const matches: ImageMatch[] = []
-	const imageRegex = /!\[([^\]]*)\]\(([^)]+)\)/g
-	let match
+export async function processImages(
+	content: AnalyzedContent,
+	app: App,
+	settings: StrapiExporterSettings
+): Promise<AnalyzedContent> {
+	const processedContent = { ...content }
 
-	while ((match = imageRegex.exec(content)) !== null) {
-		matches.push({
-			fullMatch: match[0],
-			altText: match[1],
-			imagePath: match[2],
-		})
+	for (const [key, value] of Object.entries(processedContent)) {
+		if (typeof value === 'string') {
+			// Process all links and images in the content
+			processedContent[key] = await processContentLinks(value, app, settings)
+		}
 	}
 
-	return matches
+	return processedContent
 }
 
 /**
@@ -79,44 +130,41 @@ function extractImageMatches(content: string): ImageMatch[] {
  */
 async function processImageMatch(
 	match: ImageMatch,
-	content: string,
 	app: App,
 	settings: StrapiExporterSettings
-): Promise<string> {
-	if (isExternalUrl(match.imagePath)) {
-		return content
+): Promise<string | null> {
+	// Skip external URLs
+	if (isExternalUrl(match.path)) {
+		return null
 	}
 
-	const file = app.vault.getAbstractFileByPath(match.imagePath)
+	const file = app.vault.getAbstractFileByPath(match.path)
 	if (!(file instanceof TFile)) {
-		return content
+		return null
 	}
 
-	const uploadedImage = await uploadImageToStrapi(
-		file,
-		file.name,
-		settings,
-		app,
-		{
-			alternativeText: match.altText || file.basename,
-			caption: match.altText || file.basename,
-		}
-	)
-
-	if (uploadedImage?.url) {
-		const newContent = content.replace(
-			match.fullMatch,
-			`![${match.altText}](${uploadedImage.url})`
+	try {
+		const uploadedImage = await uploadImageToStrapi(
+			file,
+			file.name,
+			settings,
+			app,
+			{
+				alternativeText: match.altText || file.basename,
+				caption: match.altText || file.basename,
+			}
 		)
-		return newContent
+
+		if (uploadedImage?.url) {
+			return `![${match.altText}](${uploadedImage.url})`
+		}
+	} catch (error) {
+		console.error(`Failed to process image ${match.path}:`, error)
 	}
 
-	return content
+	return null
 }
 
-/**
- * Check if URL is external
- */
 function isExternalUrl(url: string): boolean {
 	return url.startsWith('http://') || url.startsWith('https://')
 }