notes-to-strapi-export-article-ai 1.0.118 → 3.0.0

package/src/main.ts

@@ -1,44 +1,89 @@
-import { Plugin } from 'obsidian'
-import { StrapiExporterSettingTab } from './settings'
+import { Notice, Plugin } from 'obsidian'
 import { DEFAULT_STRAPI_EXPORTER_SETTINGS } from './constants'
-import { processMarkdownContent } from './utils/image-processor'
-import { StrapiExporterSettings } from './types/settings'
+import { RouteConfig, StrapiExporterSettings, AnalyzedContent } from './types'
+import { UnifiedSettingsTab } from './settings/UnifiedSettingsTab'
+import { debounce } from './utils/debounce'
+import { analyzeFile } from './utils/analyse-file'
+import { showPreviewToUser } from './utils/preview-modal'
+import { processImages } from './utils/process-file'
+import { StrapiExportService } from './services/strapi-export'
 
 export default class StrapiExporterPlugin extends Plugin {
 	settings: StrapiExporterSettings
+	ribbonIcons: Map<string, HTMLElement> = new Map()
+	settingsTab: UnifiedSettingsTab
+	debouncedUpdateRibbonIcons: () => Promise<void>
 
-	async onload() {
-		await this.loadSettings()
-
-		// Add ribbon icons and event listeners
-		/**
-		 * Add a ribbon icon to the Markdown view (the little icon on the left side bar)
-		 */
-		this.addRibbonIcon(
-			'upload',
-			'Upload to Strapi and generate content with AI',
-			async () => {
-				await this.processMarkdownContent()
+	private loadStyles(): void {
+		const styleElement = document.createElement('style')
+		styleElement.id = 'strapi-exporter-styles'
+		document.head.appendChild(styleElement)
+
+		styleElement.textContent = `
+			.strapi-exporter-nav {
+				display: flex;
+				justify-content: center;
+				gap: 20px;
+				margin-bottom: 20px;
 			}
-		)
 
-		/**
-		 * Add a ribbon icon based on the settings (if enabled)
-		 */
-		if (this.settings.enableAdditionalApiCall) {
-			this.addRibbonIcon(
-				'link',
-				'Upload to Strapi and generate additional content with AI',
-				async () => {
-					await this.processMarkdownContent(true)
-				}
+			.strapi-exporter-nav-button {
+				padding: 10px 15px;
+				border: none;
+				background: none;
+				cursor: pointer;
+				font-size: 14px;
+				color: var(--text-muted);
+				transition: all 0.3s ease;
+			}
+
+			.strapi-exporter-nav-button:hover {
+				color: var(--text-normal);
+			}
+
+			.strapi-exporter-nav-button.is-active {
+				color: var(--text-accent);
+				border-bottom: 2px solid var(--text-accent);
+			}
+
+			.strapi-exporter-content {
+				padding: 20px;
+			}
+		`
+	}
+
+	async onload() {
+		try {
+			// Loading settings
+			await this.loadSettings()
+
+			// Loading styles
+			this.loadStyles()
+
+			// Configuring icon updates
+			this.debouncedUpdateRibbonIcons = debounce(
+				this.updateRibbonIcons.bind(this),
+				300
 			)
+
+			// Setting up UI
+			this.settingsTab = new UnifiedSettingsTab(this.app, this)
+			this.addSettingTab(this.settingsTab)
+
+			// Updating icons
+			await this.updateRibbonIcons()
+		} catch (error) {
+			new Notice('Error loading Strapi Exporter plugin' + error.message)
 		}
+	}
 
-		this.addSettingTab(new StrapiExporterSettingTab(this.app, this))
+	async saveSettings() {
+		await this.saveData(this.settings)
 	}
 
-	onunload() {}
+	onunload() {
+		this.removeAllIcons()
+	}
 
 	async loadSettings() {
 		this.settings = Object.assign(
@@ -48,12 +93,110 @@ export default class StrapiExporterPlugin extends Plugin {
 		)
 	}
 
-	async saveSettings() {
-		await this.saveData(this.settings)
+	updateRibbonIcons() {
+		this.removeAllIcons()
+
+		this.settings.routes.forEach(route => {
+			if (route.enabled) {
+				this.addIconForRoute(route)
+			}
+		})
+	}
+
+	removeAllIcons() {
+		this.ribbonIcons.forEach((icon, routeId) => {
+			if (icon && icon.parentNode) {
+				icon.parentNode.removeChild(icon)
+			}
+		})
+		this.ribbonIcons.clear()
 	}
 
-	async processMarkdownContent(useAdditionalCallAPI = false) {
-		// Call processMarkdownContent from image-processor.ts
-		await processMarkdownContent(this.app, this.settings, useAdditionalCallAPI)
+	addIconForRoute(route: RouteConfig) {
+		const existingIcon = this.ribbonIcons.get(route.id)
+		if (existingIcon && existingIcon.parentNode) {
+			existingIcon.parentNode.removeChild(existingIcon)
+		}
+
+		const ribbonIconEl = this.addRibbonIcon(route.icon, route.name, () => {
+			this.exportToStrapi(route.id)
+		})
+		this.ribbonIcons.set(route.id, ribbonIconEl)
+	}
+
+	async exportToStrapi(routeId: string) {
+		// Route validation
+		const route = this.settings.routes.find(r => r.id === routeId)
+		if (!route) {
+			new Notice('Export failed: Route not found')
+			return
+		}
+
+		// Active file check
+		const activeFile = this.app.workspace.getActiveFile()
+		if (!activeFile) {
+			new Notice('No active file')
+			return
+		}
+
+		try {
+			// File analysis
+			const analyzedContent = await analyzeFile(activeFile, this.app, route)
+
+			// Image processing
+			const processedContent = await processImages(
+				analyzedContent,
+				this.app,
+				this.settings
+			)
+
+			// User preview
+			const userConfirmed = await showPreviewToUser(
+				this.app,
+				processedContent,
+				this
+			)
+
+			if (!userConfirmed) {
+				new Notice('Export cancelled by user')
+				return
+			}
+
+			// Initialize Strapi export service
+			const strapiExport = new StrapiExportService(
+				this.settings,
+				this.app,
+				activeFile
+			)
+
+			// Export to Strapi
+			await strapiExport.exportContent(processedContent, route)
+
+			new Notice('Content successfully exported to Strapi!')
+		} catch (error) {
+			new Notice(`Export failed: ${error.message}`)
+		}
+	}
+
+	async sendToStrapi(content: AnalyzedContent, route: RouteConfig) {
+		const response = await fetch(
+			`${this.settings.strapiUrl}/api/${route.contentType}`,
+			{
+				method: 'POST',
+				headers: {
+					'Content-Type': 'application/json',
+					Authorization: `Bearer ${this.settings.strapiApiToken}`,
+				},
+				body: JSON.stringify({ data: content }),
+			}
+		)
+
+		if (!response.ok) {
+			const errorData = await response.json()
+			throw new Error(
+				errorData.error.message || 'Failed to send content to Strapi'
+			)
+		}
+		new Notice('Content successfully sent to Strapi!')
 	}
 }

package/src/services/configuration-generator.ts

@@ -0,0 +1,172 @@
+import { createOpenAI } from '@ai-sdk/openai'
+import { generateObject } from 'ai'
+
+export class ConfigurationGenerator {
+	private model
+
+	constructor(options: { openaiApiKey: string }) {
+		const openai = createOpenAI({
+			apiKey: options.openaiApiKey,
+		})
+
+		this.model = openai('gpt-4o-mini')
+	}
+
+	async generateConfiguration(params: {
+		schema: string
+		schemaDescription: string
+		language: string
+		additionalInstructions?: string
+	}) {
+		// Parse input schemas
+		const schema = JSON.parse(params.schema)
+		const descriptions = JSON.parse(params.schemaDescription)
+
+		// Generate field configurations
+		const { object } = await generateObject({
+			model: this.model,
+			output: 'no-schema',
+			prompt: this.buildPrompt(schema.data, descriptions.data, params.language),
+		})
+
+		// Transform to final configuration
+		return this.transformToConfiguration(object)
+	}
+
+	private buildPrompt(
+		schema: Record<string, any>,
+		descriptions: Record<string, any>,
+		language: string
+	): string {
+		return `Analyze this Strapi schema and create field configurations:
+
+SCHEMA:
+${JSON.stringify(schema, null, 2)}
+
+FIELD DESCRIPTIONS:
+${JSON.stringify(descriptions, null, 2)}
+
+Create a configuration where each field has:
+1. type: 
+   - "string" for text fields
+   - "media" for image fields (when type is "string or id")
+   - "array" for lists
+   - "object" for complex fields
+   - "number" for numeric fields
+
+2. source:
+   - "content" for the main content field
+   - "frontmatter" for frontmatter fields
+
+3. description:
+   - Use the provided descriptions
+   - Keep descriptions in ${language}
+   - Make them clear and concise
+
+4. required: 
+   - true for essential fields (title, content)
+   - false for optional fields
+
+5. format (when applicable):
+   - "url" for media fields
+   - "slug" for URL-friendly fields
+
+Example field configuration:
+{
+  "title": {
+    "type": "string",
+    "description": "The main title of the article",
+    "required": true,
+    "source": "frontmatter"
+  },
+  "image_presentation": {
+    "type": "media",
+    "description": "Main article image",
+    "required": true,
+    "source": "frontmatter",
+    "format": "url"
+  }, 
+  "content": {
+  		"type": "string",
+			"description": "The main content of the article",
+			"required": true,
+			"source": "content"
+		}
+}
+
+Generate field configurations maintaining the original schema structure.`
+	}
+
+	private transformToConfiguration(generated: any) {
+		// Transform the output to the expected format
+		let fieldMappings = {}
+		if (!generated.fields) {
+			fieldMappings = Object.entries(generated).reduce(
+				(acc, [key, field]: [string, any]) => ({
+					...acc,
+					[key]: {
+						obsidianSource: field.source,
+						type: field.type,
+						description: field.description,
+						required: field.required,
+						...(field.format && { format: field.format }),
+						...(field.type === 'media' && {
+							validation: {
+								type: 'string',
+								pattern: '^https?://.+',
+							},
+						}),
+						...(field.type === 'array' && {
+							transform: this.getArrayTransform(key),
+						}),
+					},
+				}),
+				{}
+			)
+		} else {
+			fieldMappings = Object.entries(generated.fields).reduce(
+				(acc, [key, field]: [string, any]) => ({
+					...acc,
+					[key]: {
+						obsidianSource: field.source,
+						type: field.type,
+						description: field.description,
+						required: field.required,
+						...(field.format && { format: field.format }),
+						...(field.type === 'media' && {
+							validation: {
+								type: 'string',
+								pattern: '^https?://.+',
+							},
+						}),
+						...(field.type === 'array' && {
+							transform: this.getArrayTransform(key),
+						}),
+					},
+				}),
+				{}
+			)
+		}
+
+		return {
+			fieldMappings,
+			contentField: 'content',
+		}
+	}
+
+	private getArrayTransform(fieldName: string): string {
+		const transforms = {
+			gallery:
+				'value => Array.isArray(value) ? value : value.split(",").map(url => url.trim())',
+			tags: 'value => Array.isArray(value) ? value : value.split(",").map(tag => ({ name: tag.trim() }))',
+			links: `value => Array.isArray(value) ? value : value.split(";").map(link => {
+        const [label, url] = link.split("|").map(s => s.trim());
+        return { label, url };
+      })`,
+		}
+
+		return (
+			transforms[fieldName] || 'value => Array.isArray(value) ? value : [value]'
+		)
+	}
+}

package/src/services/field-analyzer.ts

@@ -0,0 +1,84 @@
+import { z } from 'zod'
+import { generateObject } from 'ai'
+import { createOpenAI } from '@ai-sdk/openai'
+
+/**
+ * Schema for field analysis result
+ */
+const fieldAnalysisSchema = z.object({
+	imageFields: z.array(
+		z.object({
+			fieldName: z.string(),
+			fieldType: z.enum(['single-image', 'gallery', 'other']),
+			required: z.boolean(),
+			description: z.string(),
+		})
+	),
+	metadataFields: z.array(
+		z.object({
+			fieldName: z.string(),
+			valueType: z.string(),
+			description: z.string(),
+		})
+	),
+	contentFields: z.array(
+		z.object({
+			fieldName: z.string(),
+			contentType: z.string(),
+			format: z.string().optional(),
+		})
+	),
+})
+
+type FieldAnalysis = z.infer<typeof fieldAnalysisSchema>
+
+export interface FieldAnalyzerOptions {
+	openaiApiKey: string
+}
+
+export class StructuredFieldAnalyzer {
+	private model
+
+	constructor(options: FieldAnalyzerOptions) {
+		const openai = createOpenAI({
+			apiKey: options.openaiApiKey,
+		})
+		this.model = openai('gpt-4o-mini', {
+			structuredOutputs: true,
+		})
+	}
+
+	/**
+	 * Analyze JSON schema to identify field types and purposes
+	 */
+	async analyzeSchema(schema: string): Promise<FieldAnalysis> {
+		try {
+			const { object } = await generateObject({
+				model: this.model,
+				schema: fieldAnalysisSchema,
+				schemaName: 'SchemaAnalysis',
+				schemaDescription:
+					'Analysis of content schema fields to identify types and purposes',
+				prompt: this.buildAnalysisPrompt(schema),
+			})
+
+			return object as FieldAnalysis
+		} catch (error) {
+			throw new Error(`Schema analysis failed: ${error.message}`)
+		}
+	}
+
+	private buildAnalysisPrompt(schema: string): string {
+		return `Analyze the following JSON schema and identify:
+    - Image fields (single images and galleries)
+    - Metadata fields (SEO, tags, dates, etc.)
+    - Content fields (text, rich text, markdown)
+
+    Provide structured categorization of all fields with their purposes and data types.
+
+    Schema to analyze:
+    ${schema}
+
+    Focus on identifying field types, required status, and provide clear descriptions.`
+	}
+}