feat(embedding, web worker): add embedding pipeline with Web Worker and note reader

package.json

@@ -2,8 +2,9 @@
   "name": "joplin-note-categorization-plugin",
   "version": "1.0.0",
   "scripts": {
-    "dist": "webpack --env joplin-plugin-config=buildMain && webpack --env joplin-plugin-config=buildExtraScripts && webpack --env joplin-plugin-config=createArchive",
+    "dist": "webpack --env joplin-plugin-config=buildMain && webpack --env joplin-plugin-config=buildExtraScripts && npm run copyAssets && webpack --env joplin-plugin-config=createArchive",
     "prepare": "npm run dist",
+    "copyAssets": "node tools/copyAssets.js",
     "updateVersion": "webpack --env joplin-plugin-config=updateVersion",
     "update": "npm install -g generator-joplin && yo joplin --node-package-manager npm --update --force"
   },
@@ -25,5 +26,8 @@
     "typescript": "^4.8.2",
     "webpack": "^5.74.0",
     "webpack-cli": "^4.10.0"
+  },
+  "dependencies": {
+    "@huggingface/transformers": "^3.8.1"
   }
 }

plugin.config.json

@@ -1,3 +1,3 @@
 {
-	"extraScripts": []
+	"extraScripts": ["worker/embedWorker.ts"]
 }

src/commands/testEmbed.ts

@@ -0,0 +1,60 @@
+import { fetchAllNotes } from '../pipeline/noteReader';
+import { log, logErr } from '../utils/logger';
+
+export const runTestEmbed = async (installDir: string) => {
+	log('Test embed command triggered');
+
+	const notes = await fetchAllNotes();
+	log(`Fetched ${notes.length} notes`);
+
+	if (notes.length === 0) {
+		log('No notes found. Create some notes and try again.');
+		return;
+	}
+
+	const testNote = notes[0];
+	const textToEmbed = testNote.body.length > 0 ? testNote.body.slice(0, 2000) : testNote.title;
+	log(`Embedding note: "${testNote.title}" (${textToEmbed.length} chars)`);
+
+	const worker = new Worker(`${installDir}/worker/embedWorker.js`);
+
+	worker.onerror = (err) => {
+		logErr('Worker error:', err.message || err);
+	};
+
+	worker.onmessage = async (event) => {
+		const data = event.data;
+
+		if (data.type === 'load-result') {
+			if (data.success) {
+				log(`Model loaded in ${(data.loadTime / 1000).toFixed(1)}s, warmup: ${Math.round(data.warmupTime)}ms`);
+
+				worker.postMessage({
+					type: 'embed',
+					text: textToEmbed,
+					noteId: testNote.id,
+				});
+			} else {
+				logErr('Model load failed:', data.error);
+				worker.terminate();
+			}
+			return;
+		}
+
+		if (data.type === 'embed-result') {
+			if (data.success) {
+				log(`Embedding complete for "${testNote.title}"`);
+				log(`  Dimensions: ${data.dimensions}`);
+				log(`  Inference time: ${Math.round(data.inferenceTime)}ms`);
+				log(`  First 5 values: [${data.embedding.slice(0, 5).map((v: number) => v.toFixed(4)).join(', ')}]`);
+			} else {
+				logErr('Embed failed:', data.error);
+			}
+			worker.terminate();
+			log('Worker terminated. Test complete.');
+		}
+	};
+
+	log('Loading model...');
+	worker.postMessage({ type: 'load' });
+};

src/index.ts

@@ -1,8 +1,26 @@
 import joplin from 'api';
+import { MenuItemLocation } from 'api/types';
+import { runTestEmbed } from './commands/testEmbed';
+import { log } from './utils/logger';
 
 joplin.plugins.register({
-	onStart: async function() {
-		// eslint-disable-next-line no-console
-		console.info('Hello world. Test plugin started!');
+	onStart: async function () {
+		log('Plugin started');
+
+		const installDir = await joplin.plugins.installationDir();
+
+		await joplin.commands.register({
+			name: 'aiCategorise.testEmbed',
+			label: 'AI Categorise: Test Embedding',
+			execute: async () => runTestEmbed(installDir),
+		});
+
+		await joplin.views.menuItems.create(
+			'aiCategorise.testEmbedMenuItem',
+			'aiCategorise.testEmbed',
+			MenuItemLocation.Tools,
+		);
+
+		log('Test command registered under Tools menu');
 	},
 });

src/manifest.json

@@ -4,7 +4,7 @@
 	"app_min_version": "3.5",
 	"version": "1.0.0",
 	"name": "Note Categorization Plugin",
-	"description": "",
+	"description": "AI-based note categorisation: clusters notes semantically, suggests tags and notebook structures, and detects stale notes.",
 	"author": "Harsh Gupta",
 	"homepage_url": "",
 	"repository_url": "https://github.com/joplin/plugin-note-categorization",

src/pipeline/noteReader.ts

@@ -0,0 +1,28 @@
+import joplin from 'api';
+
+export interface NoteItem {
+	id: string;
+	title: string;
+	body: string;
+	updated_time: number;
+	user_updated_time: number;
+	parent_id: string;
+}
+
+export const fetchAllNotes = async (): Promise<NoteItem[]> => {
+	let page = 1;
+	const allNotes: NoteItem[] = [];
+
+	while (true) {
+		const result = await joplin.data.get(['notes'], {
+			fields: ['id', 'title', 'body', 'updated_time', 'user_updated_time', 'parent_id'],
+			page,
+			limit: 50,
+		});
+		allNotes.push(...result.items);
+		if (!result.has_more) break;
+		page++;
+	}
+
+	return allNotes;
+};

src/utils/logger.ts

@@ -0,0 +1,9 @@
+const LOG_PREFIX = '[ai-categorise]';
+
+export const log = (...args: unknown[]) => {
+	console.info(LOG_PREFIX, ...args);
+};
+
+export const logErr = (...args: unknown[]) => {
+	console.error(LOG_PREFIX, ...args);
+};

src/worker/embedWorker.ts

@@ -0,0 +1,72 @@
+// @ts-ignore
+import { pipeline, env } from '@huggingface/transformers';
+
+const MODEL_ID = 'Xenova/all-MiniLM-L6-v2';
+const MODEL_DTYPE = 'fp32' as const;
+const POOLING = 'mean' as const;
+
+// Worker compiles to dist/worker/, WASM files are at dist/onnx-dist/
+env.backends.onnx.wasm!.wasmPaths = '../onnx-dist/';
+
+let embedder: any = null;
+
+const loadModel = async () => {
+	const t0 = performance.now();
+
+	embedder = await pipeline('feature-extraction', MODEL_ID, {
+		dtype: MODEL_DTYPE,
+	});
+
+	const loadTime = performance.now() - t0;
+
+	// Warm-up: first inference is always slower due to JIT/WASM setup.
+	const tw = performance.now();
+	await embedder('warmup text', { pooling: POOLING, normalize: true });
+	const warmupTime = performance.now() - tw;
+
+	return { loadTime, warmupTime };
+};
+
+const embed = async (text: string) => {
+	if (!embedder) throw new Error('Model not loaded');
+
+	const t0 = performance.now();
+	const output = await embedder(text, { pooling: POOLING, normalize: true });
+	const inferenceTime = performance.now() - t0;
+	const dimensions = output.data.length;
+	const embedding = Array.from(output.data as Float32Array);
+
+	return { inferenceTime, dimensions, embedding };
+};
+
+self.addEventListener('message', async (event) => {
+	const { type } = event.data;
+
+	if (type === 'load') {
+		try {
+			const result = await loadModel();
+			postMessage({ type: 'load-result', success: true, ...result });
+		} catch (e: any) {
+			postMessage({ type: 'load-result', success: false, error: String(e) });
+		}
+	}
+
+	if (type === 'embed') {
+		try {
+			const result = await embed(event.data.text);
+			postMessage({
+				type: 'embed-result',
+				noteId: event.data.noteId,
+				success: true,
+				...result,
+			});
+		} catch (e: any) {
+			postMessage({
+				type: 'embed-result',
+				noteId: event.data.noteId,
+				success: false,
+				error: String(e),
+			});
+		}
+	}
+});

tools/copyAssets.js

@@ -0,0 +1,43 @@
+// Copy onnxruntime-web wasm binaries into dist/onnx-dist so the Web Worker
+// can load them locally without hitting CSP/CORS issues in Electron.
+const fs = require('fs-extra');
+const path = require('path');
+
+const possiblePaths = [
+	path.join(__dirname, '..', 'node_modules', '@huggingface', 'transformers', 'node_modules', 'onnxruntime-web', 'dist'),
+	path.join(__dirname, '..', 'node_modules', 'onnxruntime-web', 'dist'),
+];
+
+let onnxDistDir = null;
+for (const p of possiblePaths) {
+	if (fs.existsSync(p)) {
+		onnxDistDir = p;
+		break;
+	}
+}
+
+if (!onnxDistDir) {
+	console.error('ERROR: Could not find onnxruntime-web dist directory!');
+	console.error('Searched:', possiblePaths);
+	process.exit(1);
+}
+
+const targetDir = path.join(__dirname, '..', 'dist', 'onnx-dist');
+
+// Clean stale files before copying
+fs.removeSync(targetDir);
+fs.ensureDirSync(targetDir);
+
+// Copy only ONNX runtime files (.wasm + .mjs loaders) to reduce plugin archive size
+const runtimeFiles = fs.readdirSync(onnxDistDir).filter(f =>
+	f.startsWith('ort-wasm') && (f.endsWith('.wasm') || f.endsWith('.mjs'))
+);
+
+console.log(`Copying ${runtimeFiles.length} ONNX runtime files from: ${onnxDistDir}`);
+console.log(`                                       to: ${targetDir}`);
+
+for (const file of runtimeFiles) {
+	fs.copySync(path.join(onnxDistDir, file), path.join(targetDir, file));
+}
+
+console.log(`Done! ${runtimeFiles.length} ONNX runtime files copied to dist/onnx-dist/`);

webpack.config.js

@@ -308,8 +308,14 @@ function buildExtraScriptConfigs(userConfig) {
 
 	for (const scriptName of userConfig.extraScripts) {
 		const scriptPaths = resolveExtraScriptPath(scriptName);
-		output.push({ ...extraScriptConfig, entry: scriptPaths.entry,
-			output: scriptPaths.output });
+		output.push({
+			...extraScriptConfig, entry: scriptPaths.entry,
+			output: {
+				filename: scriptPaths.output.filename,
+				path: scriptPaths.output.path,
+			},
+			target: 'web'
+		});
 	}
 
 	return output;